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

TH2F *Eta_Pt_SI_DIall                ;
TH2F *Eta_Pt_SI_DIsel                ;
TH2F *hmapden;
TH1F *TrigRight_Wrong                ;


TH1F *InvMass                     ;
TH1F *InvMass_EFMU4_Jpsimumupass  ;
TH1F *InvMass_EF_2MU4_Jpsimumupass;

TH1F *Pt_Mu                        ; 
TH1F *Eta_Mu                       ; 
TH1F *Phi_Mu                       ; 
TH1F *DR_Mu                        ; 

TH1F *Pt_Jpsi                      ;                   
TH1F *Phi_Jpsi                     ;
TH1F *Eta_Jpsi                     ; 


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

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

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

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

//TFile *F1 = new TFile("TPout_EFMU4_EFMU4_DATA2010_CombComb_staco.root");
//TFile *F1 = new TFile("TPout_MCh150_CombComb_staco.root");
TFile *F1 = new TFile("Efmu4_trkjpsi_2011_periodG.root");
//TFile *F1 = new TFile("TPout_EFMU4_EFMU4_MCJpsi_NuovoPerl_CombComb_staco.root");
TFile *F2 = new TFile("TMapDen.root","read");

TH2F *EffMapall=(TH2F*) F1->Get("hmapselalleff");
TH2F *EffMapall_den=(TH2F*) F2->Get("hmapden"); // map for P(efmu4|ef_mu4_jpsimumu)
TH2F *Eta_Pt_SingleEmu_Num;
TH2F *Eta_Pt_SingleEmu_Den;

long i=0;

const float mu_mass=0.105658367;
const int nbinsPt=7;
const int nbinsEta=18;
const float binsPt[8]={0,3,4,5,7,9,15,25};
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=2500;
const float maxJpsi=4300;
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("DATA2011_periodoG_trkJpsi.root", "RECREATE");
   ///histo for P(EF_mu4|EF_mu4_Jpsimumu)
   int nptbins  = 7; 
   float ptbin[8]={0,3,4,5,7,9,15,25};
   int netabins = 18; 
   float etabin[19]={-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};
   Eta_Pt_SI_DIall=new TH2F("mapden_all","mapden_all",netabins,etabin,nptbins,ptbin);        
   Eta_Pt_SI_DIsel=new TH2F("mapnum_sel","mapnum_sel",netabins,etabin,nptbins,ptbin);        
   hmapden = new TH2F("hmapden","hmapden",netabins,etabin,nptbins,ptbin);        
   
   ///histo for P(EF_mu4|EF_mu4_Jpsimumu) emulation
   Eta_Pt_SingleEmu_Num=new TH2F("Eta_Pt_SingleEmu_Num","Eta_Pt_SingleEmu_Num",nbinsEtaMap,binsEtaMap,nbinsPt,binsPt);
   Eta_Pt_SingleEmu_Den=new TH2F("Eta_Pt_SingleEmu_Den","Eta_Pt_SingleEmu_Den",nbinsEtaMap,binsEtaMap,nbinsPt,binsPt);


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

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

   //Barrel
   //numerators
   WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b   =new TH1F("WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b","WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b",nbinsPt,binsPt); 
   WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b =new TH1F("WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b","WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4b",nbinsPt,binsPt); 
   
   //denominators
   PtMajor_Jpsi_EFMU4b                 =new TH1F("PtMajor_Jpsi_EFMU4b","PtMajor_Jpsi_EFMU4b",nbinsPt,binsPt); 
   PtMinor_Jpsi_EFMU4b                 =new TH1F("PtMinor_Jpsi_EFMU4b","PtMinor_Jpsi_EFMU4b",nbinsPt,binsPt); 
  
   //EndCap
   //numerators
   WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e   =new TH1F("WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e","WPtMajor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e",nbinsPt,binsPt); 
   WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e =new TH1F("WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e","WPtMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4e",nbinsPt,binsPt); 
  
   //denominators
   PtMajor_Jpsi_EFMU4e                   =new TH1F("PtMajor_Jpsi_EFMU4e","PtMajor_Jpsi_EFMU4e",nbinsPt,binsPt); 
   PtMinor_Jpsi_EFMU4e                 =new TH1F("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_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);

  // retireve trigger info
  b_muL1MU0pass->GetEntry(entry);
  b_mu1L1MU0dr->GetEntry(entry);
  b_mu2L1MU0dr->GetEntry(entry);
  b_muEFMU4pass->GetEntry(entry);
  b_muEFMU4_JPSIMUMUpass->GetEntry(entry);
  b_mu1EFMU4dr->GetEntry(entry);
  b_mu1EFMU4eta->GetEntry(entry);
  b_mu1EFMU4phi->GetEntry(entry);
  b_mu2EFMU4dr->GetEntry(entry);
  b_mu2EFMU4eta->GetEntry(entry);
  b_mu2EFMU4phi->GetEntry(entry);
  b_mu1EFMU4_JPSIMUMUdr->GetEntry(entry);
  b_mu1EFMU4_JPSIMUMUdpt->GetEntry(entry);
  b_mu1EFMU4_JPSIMUMUeta->GetEntry(entry);
  b_mu1EFMU4_JPSIMUMUphi->GetEntry(entry);
  b_mu2EFMU4_JPSIMUMUdr->GetEntry(entry);
  b_mu2EFMU4_JPSIMUMUdpt->GetEntry(entry);
  b_mu2EFMU4_JPSIMUMUeta->GetEntry(entry);
  b_mu2EFMU4_JPSIMUMUphi->GetEntry(entry);
  
 
  int SingleL1Pass = muL1MU0pass;
  int SingleL16Pass = muL1MU6pass;
  int SingleL110Pass = muL1MU10pass;
  int SinglePass   = muEFMU4pass;
  int Single6Pass   = muEFMU6pass;
  int Single10Pass   = muEFMU10pass;
  int DimuPass     = muEFMU4_JPSIMUMUpass;
  
  float SingleL1M1dr =mu1L1MU0dr;
  float SingleL16M1dr =mu1L1MU0dr;
  float SingleL110M1dr =mu1L1MU0dr;
  float SingleM1dr   =mu1EFMU4dr;
  float Single6M1dr   =mu1EFMU6dr;
  float Single10M1dr   =mu1EFMU10dr;
  float SingleM1eta  =mu1EFMU4eta;
  float SingleM1phi  =mu1EFMU4phi;
  
  float SingleL1M2dr =mu2L1MU0dr;
  float SingleL16M2dr =mu2L1MU0dr;
  float SingleL110M2dr =mu2L1MU0dr;
  float SingleM2dr =mu2EFMU4dr;
  float Single6M2dr   =mu2EFMU6dr;
  float Single10M2dr   =mu2EFMU10dr;
  float SingleM2eta=mu2EFMU4eta;
  float SingleM2phi=mu2EFMU4phi;

  float DimuM1dr =mu1EFMU4_JPSIMUMUdr ;
  float DimuM1eta=mu1EFMU4_JPSIMUMUeta;
  float DimuM1phi=mu1EFMU4_JPSIMUMUphi; 
  
  float DimuM2dr =mu2EFMU4_JPSIMUMUdr ;
  float DimuM2eta=mu2EFMU4_JPSIMUMUeta;
  float DimuM2phi=mu2EFMU4_JPSIMUMUphi;

  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;

  int qMajor=0;
  int qMinor=0;

  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;
      qMajor=mu1q;
      qMinor=mu2q;
      if(MuTrig=1) TrigRight_Wrong->Fill(0.5);
      else TrigRight_Wrong->Fill(1.5);
    }
  else
    {
      MuMax=2;
      major=mu2;
      minor=mu1;
      qMajor=mu2q;
      qMinor=mu1q;
      if(MuTrig=2) TrigRight_Wrong->Fill(0.5);
      else TrigRight_Wrong->Fill(1.5);
    }
  int SingleOrPass = 0;
  int SingleL1OrPass = 0;
  int SingleL1dr_pass = 0;
  int SingleMu1OrPass = 0;
  int SingleMu2OrPass = 0;
  cout << endl << endl;
  if (SingleL1Pass == 1 || SingleL16Pass == 1 || SingleL110Pass == 1) 
    {
      SingleL1OrPass=1;
      cout << " pass L1 single muon"<< endl;
    }
  if (SinglePass == 1 || Single6Pass == 1 || Single10Pass == 1) SingleOrPass=1;
      {
	cout << " pass EF single muon"<< endl;
      }	
  if ((SingleL1M1dr<0.4   ||  SingleL1M2dr<0.4  ) ||
      (SingleL16M1dr<0.4  ||  SingleL16M2dr<0.4 ) ||
      (SingleL110M1dr<0.4 ||  SingleL110M2dr<0.4) 
      ) 
    {
      SingleL1dr_pass = 1;
      cout << " pass at least 1 L1muon Dr"<< endl;
    }
  
  if (SingleM1dr<0.005 || Single6M1dr<0.005 || Single10M1dr<0.005) SingleMu1OrPass=1;
  
  if (SingleM2dr<0.005 || Single6M2dr<0.005 || Single10M2dr<0.005)  SingleMu2OrPass=1;
  
  if (SingleMu1OrPass || SingleMu2OrPass) cout << " pass at least 1 EFmuon Dr"<< endl;

  if(SingleOrPass==1 && SingleL1OrPass==1 && SingleL1dr_pass == 1)
    {
      cout << " pass single EFmu4 + l1mu0 + l1dr  "<<endl;

      if(MuMax==1 && SingleMu1OrPass == 1)
	{
	  EF_mu4_passed=true; 
	  cout << " pass mu1 single EFmu4dr  "<<endl;      	  
	  if(DimuPass==1 && (DimuM1dr<0.005 && DimuM2dr<0.005))
	    {
	      cout << " Event pass single EF_mu4_jpsimumu  "<<endl;      	  
	      EF_mu4_Jpsimumu_passed=true;
	      dr1=DR(SingleM1eta,SingleM1phi,DimuM1eta,DimuM1phi);
	    }
	}
      else if(MuMax==2 && SingleMu2OrPass == 1)
	{
	  EF_mu4_passed=true;
	  cout << " pass mu2 single EFmu4dr  "<<endl;      	  
	  if(DimuPass==1 && (DimuM1dr<0.005 && DimuM2dr<0.005))
	    {
	      cout << " Event pass single EF_mu4_jpsimumu  "<<endl;      	  
	      EF_mu4_Jpsimumu_passed=true;
	      dr2=DR(SingleM2eta,SingleM2eta,DimuM2eta,DimuM2phi);
	    }
	} 
    }

 

 if(DimuPass==1 && (DimuM1dr<0.005 && DimuM2dr<0.005))
   {
     cout << " pass single EFmu4_jpsimumu AND EFmu4_jpsimumudr  "<<endl;      	  
     EF_mu4_Jpsimumu_passed_only=true;
     Eta_Pt_SingleEmu_Den->Fill(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(mu2eta_EF,mu2pt_EF);   
       }
   }
  
 if(isJpsi && EF_mu4_Jpsimumu_passed_only)
   {
     // Here the denominator map
     // P(EFMu4|EFmu4_jpsimumu) is filled!!
     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());
	   }
       }
   }
 
 //Compute the 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_TrkJpsi(major.Pt()));
      //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 == 0) weit=0.001;
      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(qMajor*major.Eta(),weit/weit_den);
      WEtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(qMinor*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(qMajor*major.Eta());
      EtaMinor_Jpsi_EFMU4_Jpsimumupass_vs_EFMU4->Fill(qMinor*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(qMajor*major.Eta());
      EtaMinor_Jpsi_EFMU4->Fill(qMinor*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
 
  Eta_Pt_SI_DIall->Sumw2();
  Eta_Pt_SI_DIsel->Sumw2();
  hmapden->Divide(Eta_Pt_SI_DIsel,Eta_Pt_SI_DIall,1.,1.,"b") ;
  outfile->Write();
  outfile->Close();


}

int Selector::BinX(float Eta)
{
  float eta;
  eta=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<3) return 1;
  if(pT<4 && pT>=3) return 2;
  if(pT<5 && pT>=4) return 3;
  if(pT<7 && pT>=5) return 4;
  if(pT<9 && pT>=7) return 5;
  if(pT<15 && pT>=9) 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>=15) return 7;
}

int Selector::BinY_TrkJpsi(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 3;//era 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;
}