rootEWKanalyzer/src/analysisClass_myCode.C

// remkarks:
// !!! in the W selection every electron is taken, also the 
// non isolated !!!


// implement conversion removal for robust...


#define analysisClass_cxx
#include "analysisClass.h"

#include <TH2.h>
#include <TF2.h>
#include <TH1F.h>
#include <TStyle.h>
#include <TCanvas.h>
#include <TLorentzVector.h>
#include <TVector2.h>
#include <TVector3.h>
#include <TTree.h>

analysisClass::analysisClass(string * inputList, string * cutFile, string * treeName, string * outputFileName, string * cutEfficFile)
  :baseClass(inputList, cutFile, treeName, outputFileName, cutEfficFile)
{
  std::cout << "analysisClass::analysisClass(): begins " << std::endl;

  std::cout << "analysisClass::analysisClass(): ends " << std::endl;
}

analysisClass::~analysisClass()
{
  std::cout << "analysisClass::~analysisClass(): begins " << std::endl;

  std::cout << "analysisClass::~analysisClass(): ends " << std::endl;
}


void filler(myEvent electrons, TH1D *pt, TH1D *eta, TH1D *phi, TH1D *met, TH1D *charge,
            TH1D *deltaPhi, TH1D *deltaEta, TH1D *oneOverEminusOneOverP, TH1D *transMass,
            TH1D *ethIso, TH1D *trkIso, TH1D *ecalIso, TH1D *hcalIso, TH1D* HoverE,
            TH1D *sigmaIetaIeta, TH1D *numberOfMissingInnerHits
) 

{
  pt->Fill(electrons.momentum[0]);
  eta->Fill(electrons.fourvector[0].Eta());
  phi->Fill(electrons.fourvector[0].Phi());
  met->Fill(electrons.missinget);
  charge->Fill(electrons.charge[0]);

  deltaPhi->Fill(fabs(electrons.deltaPhi[0]));
  deltaEta->Fill(fabs(electrons.deltaEta[0]));
  oneOverEminusOneOverP->Fill(fabs(electrons.oneOverEminusOverP[0]));
  transMass->Fill(electrons.transverseMass[0]);
  ethIso->Fill(electrons.ethIso[0]);
  trkIso->Fill(electrons.trkIso[0]);
  ecalIso->Fill(electrons.ecalIso[0]);
  hcalIso->Fill(electrons.hcalIso[0]);
  HoverE->Fill(electrons.HoverE[0]);
  sigmaIetaIeta->Fill(electrons.sigmaIetaIeta[0]);
  numberOfMissingInnerHits->Fill(electrons.numberOfMissingInnerHits[0]);

}

void scaleHisto(TH1D* histo, double factor) {
  int binnumber=histo->GetNbinsX();
  for(int i=0;i<=binnumber+1;i++) {
    double bincontent=histo->GetBinContent(i);
    double newbincontent=bincontent*factor;
    histo->SetBinContent(i,newbincontent);
    double binerror=histo->GetBinError(i);
    double newbinerror=binerror*factor;
    histo->SetBinError(i,newbinerror);
  }
}


void analysisClass::Loop()
{
  std::cout << "analysisClass::Loop() begins" <<std::endl;   
  
  if (fChain == 0) return;
  

  //getHLTtable();

  
  double PtCorrection = 1.;


  int counterSize=15;
  int* counter = new int[counterSize];
  memset(counter,0,counterSize*sizeof(int));
  
  int cNa = 0;
  int cNb = 0;

  FILE *out=fopen("out.txt","w");
  FILE *out_Z=fopen("out_z.txt","w");
  fprintf(out_Z,"Run \tEvent \tLS \tDiLeptonMass \tPt_1 \tPt2 \tEta_1 \tEta_2 \tDiLeptonPt \tsumJetPt \n");


  // --------------------------------------------------------------------------------------------------------------------
  // Analysis input parameters
  // --------------------------------------------------------------------------------------------------------------------
  int workingPoint = 95;   // -1 takes hard coded values (which are the old robust tight values...)
  double sampleSize=-1;
 
  bool isdata=false;
  bool printInfo=false;
  bool noInnerHitInfo=false;
  bool writeIdPlots=true;
  bool writeN1Plots=true;
  bool writeWenuPlots=true;
  bool applyDeltaCorrection=false;
  bool applyJetVeto=false;

  // --------------------------------------------------------------------------------------------------------------------

  double Pi=2*acos(0);  // pi=3.14159...
  double ptMin=20;
  double jetEtaMax=2.5;
  double jetPtMin=30.;
  double deltaRMax=0.3;  // delta R for jet veto 
  
  
  int MAXE=41;

  double totalNumberOfEvents=0;
  vector<double> WorkingPointCuts;
  vector<double> EthCuts;

  vector<int> electronIndex;
  vector<int> jetIndex;


  // --------------------------------------------------------------------------------------------------------------------
  // tag and probe counters
  // --------------------------------------------------------------------------------------------------------------------
  int N_tt=0;
  int N_t0=0;


  // --------------------------------------------------------------------------------------------------------------------
  // Electron Cuts
  // --------------------------------------------------------------------------------------------------------------------
  
  // Geometry
  double etaBarrelMax=1.44;
  double etaEndcapMin=1.56;
  double etaEndcapMax=2.5;
  // Preselection
  double Pre_HoverEMin=0.15;
  double Pre_deltaEtaMax=0.02;
  double Pre_deltaPhiMax=0.15;
  double Pre_pt=20.;
  // ETH ID
  double ETH_oneOverEminusOneOverP_B=0.005;
  double ETH_deltaEtaMax_B=0.004;
  double ETH_deltaPhiMax_B=0.02;
  double ETH_iso_B=0.1;
  int ETH_missingHits_B=1;
  double ETH_oneOverEminusOneOverP_E=0.007;
  double ETH_deltaEtaMax_E=0.006;
  double ETH_deltaPhiMax_E=0.02;
  double ETH_iso_E=0.1;
  int ETH_missingHits_E=1;

//   double Rob_HoverE_B=0.0201;
//   double Rob_SigmaIetaIeta_B=0.0102;
//   double Rob_deltaPhi_B=0.0211;
//   double Rob_deltaEta_B=0.00606;
//   double Rob_trkIso_B=2.34;
//   double Rob_ecalIso_B=3.24;
//   double Rob_hcalIso_B=4.51;
//   double Rob_combIso_B=0.;
//   int Rob_missingHits_B=1;
  
//   double Rob_HoverE_E=0.00253;
//   double Rob_SigmaIetaIeta_E=0.0291;
//   double Rob_deltaPhi_E=0.022;
//   double Rob_deltaEta_E=0.0032;
//   double Rob_trkIso_E=0.826;
//   double Rob_ecalIso_E=2.7;
//   double Rob_hcalIso_E=0.255;
//   double Rob_combIso_E=0.;
//   int Rob_missingHits_E=1;
//   double Rob_dist_E=0.02;
//   double Rob_cot_E=0.02;
  
  int debug=0;


  // fill the eth cuts vector
  EthCuts.push_back(ETH_deltaPhiMax_B);
  EthCuts.push_back(ETH_deltaEtaMax_B);
  EthCuts.push_back(ETH_oneOverEminusOneOverP_B);
  EthCuts.push_back(ETH_iso_B);
  EthCuts.push_back(ETH_missingHits_B);
  EthCuts.push_back(ETH_deltaPhiMax_E);
  EthCuts.push_back(ETH_deltaEtaMax_E);
  EthCuts.push_back(ETH_oneOverEminusOneOverP_E);
  EthCuts.push_back(ETH_iso_E);
  EthCuts.push_back(ETH_missingHits_E);


  // --------------------------------------------------------------------------------------------------------------------
  // read the cut values from include/workingPoints.txt
  // --------------------------------------------------------------------------------------------------------------------

  // check if it is a possible working point
  if(workingPoint>0 && (
     workingPoint!=60 &&
     workingPoint!=70 &&
     workingPoint!=80 &&
     workingPoint!=85 &&
     workingPoint!=90 &&
     workingPoint!=95 )
     ) {
    cerr<<"ERROR: "<<workingPoint<<" is NOT a valid working point!!!"<<endl;
    exit(0);
  }
  // read the file
  if(workingPoint>0) {
    const char *file="include/workingPoints.txt";
    cout<<"Opening file: "<<file<<"..."<<endl;
    ifstream toread (file);
    if(!toread.is_open()) {
      cerr<<"File "<<file<<" not found!!"<<endl;
      //goto END;
    }
    else {
      cout<<"File opened..."<<endl;
    }
    
    // build the working point variable
    char wpB [20];
    char wpE [20];
    sprintf(wpB,"B%d",workingPoint);
    sprintf(wpE,"E%d",workingPoint);
    
    
    // read every line in the file
    if(toread.is_open()) {
      string line;
      float value;
      char name[100];
      //cout<<"Reading working point input file"<<endl;
      while(!toread.eof()) {
        getline (toread, line);
        
        if(line.substr(0,1)=="#") continue;
        //cout<<line<<endl;
        
        char wp[20];
        float v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10;
        sscanf (line.c_str(), "%s\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f\t%f", wp, &v0, &v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8, &v9, &v10);
        // barrel values
        if(!strcmp(wp, wpB)) {
          WorkingPointCuts.push_back(v0); // 0 see
          WorkingPointCuts.push_back(v1); // 1 dphi
          WorkingPointCuts.push_back(v2); // 2 deta
          WorkingPointCuts.push_back(v3); // 3 hoe
          WorkingPointCuts.push_back(v4); // 4 tkIso
          WorkingPointCuts.push_back(v5); // 5 ecalIso
          WorkingPointCuts.push_back(v6); // 6 hcalIso
          WorkingPointCuts.push_back(v7); // 7 combIso
        }
        // endcap values
        if(!strcmp(wp, wpE)) {
          WorkingPointCuts.push_back(v0); // 8 see
          WorkingPointCuts.push_back(v1); // 9 dphi
          WorkingPointCuts.push_back(v2); // 10 deta
          WorkingPointCuts.push_back(v3); // 11 hoe
          WorkingPointCuts.push_back(v4); // 12 tkIso
          WorkingPointCuts.push_back(v5); // 13 ecalIso
          WorkingPointCuts.push_back(v6); // 14 hcalIso
          WorkingPointCuts.push_back(v7); // 15 combIso
          WorkingPointCuts.push_back(v8); // 16 hits
          WorkingPointCuts.push_back(v9); // 17 dist
        }
        
      } // read line
    }  // read file
  } // get working points
  
  cout<<WorkingPointCuts[4]<<endl;
  cout<<WorkingPointCuts[5]<<endl;
  cout<<WorkingPointCuts[6]<<endl;
  cout<<WorkingPointCuts[7]<<endl;
  cout<<WorkingPointCuts[8]<<endl;
  cout<<WorkingPointCuts[9]<<endl;


  // Robust ID

//   if(workingPoint==-1) {
//     WorkingPointCuts.push_back(Rob_SigmaIetaIeta_B);
//     WorkingPointCuts.push_back(Rob_deltaPhi_B);
//     WorkingPointCuts.push_back(Rob_deltaEta_B);
//     WorkingPointCuts.push_back(Rob_HoverE_B);
//     WorkingPointCuts.push_back(Rob_trkIso_B);
//     WorkingPointCuts.push_back(Rob_ecalIso_B);
//     WorkingPointCuts.push_back(Rob_hcalIso_B);
//     WorkingPointCuts.push_back(Rob_missingHits_B);
//     WorkingPointCuts.push_back(Rob_SigmaIetaIeta_E);
//     WorkingPointCuts.push_back(Rob_deltaPhi_E);
//     WorkingPointCuts.push_back(Rob_deltaEta_E);
//     WorkingPointCuts.push_back(Rob_HoverE_E);
//     WorkingPointCuts.push_back(Rob_trkIso_E);
//     WorkingPointCuts.push_back(Rob_ecalIso_E);
//     WorkingPointCuts.push_back(Rob_hcalIso_E);
//     WorkingPointCuts.push_back(Rob_missingHits_E);
//     WorkingPointCuts.push_back(Rob_dist_E);
//     WorkingPointCuts.push_back(Rob_cot_E);
//   }
  
//   if(workingPoint>0) {
//     Rob_SigmaIetaIeta_B=WorkingPointCuts[0];
//     Rob_deltaPhi_B=WorkingPointCuts[1];
//     Rob_deltaEta_B=WorkingPointCuts[2];
//     Rob_HoverE_B=WorkingPointCuts[3];
//     Rob_trkIso_B=WorkingPointCuts[4];
//     Rob_ecalIso_B=WorkingPointCuts[5];
//     Rob_hcalIso_B=WorkingPointCuts[6];
//     Rob_combIso_B=WorkingPointCuts[7];
//     Rob_missingHits_B=WorkingPointCuts[16];
    
//     Rob_SigmaIetaIeta_E=WorkingPointCuts[8];
//     Rob_deltaPhi_E=WorkingPointCuts[9];
//     Rob_deltaEta_E=WorkingPointCuts[10];
//     Rob_HoverE_E=WorkingPointCuts[11];
//     Rob_trkIso_E=WorkingPointCuts[12];
//     Rob_ecalIso_E=WorkingPointCuts[13];
//     Rob_hcalIso_E=WorkingPointCuts[14];
//     Rob_combIso_E=WorkingPointCuts[15];
//     Rob_missingHits_E=WorkingPointCuts[16];
//     Rob_dist_E=WorkingPointCuts[17];
//     Rob_cot_E=WorkingPointCuts[17];
//   }
  
  cout<<"Running the analysis with working point "<<workingPoint<<endl;
  cout<<"Value for barrel / endcap"<<endl;
  char *cutName[8] = {"sigmaIetaIeta", "delta phi at vtx", "delta eta at vtx", "H/E", "trkIso", "ecalIso", "hcalIso", "# inner hits"};
  for(int i=0; i< 8;i++) {
    cout<<cutName[i]<<" < "<<WorkingPointCuts[i]<<" / "<<WorkingPointCuts[8+i]<<endl;
  }

  // --------------------------------------------------------------------------------------------------------------------
  

  // --------------------------------------------------------------------------------------------------------------------
  // define some counters
  // --------------------------------------------------------------------------------------------------------------------
  int c_robust_B=0;
  int c_robust_E=0;
  int c_robust_tree=0;
  int c_eth_1=0;
  int c_eth_2=0;
  int counterTight=0;
  int counterETH=0;
  
  // --------------------------------------------------------------------------------------------------------------------
  

  // --------------------------------------------------------------------------------------------------------------------
  // --------------------------------------------------------------------------------------------------------------------
//   double lumi=6710;
//   double xsec=235500000.0;
  // --------------------------------------------------------------------------------------------------------------------

  
  // --------------------------------------------------------------------------------------------------------------------
  // choose which cut should be applied
  // this is only used for the sequential plots
  // --------------------------------------------------------------------------------------------------------------------
   bool applyCut [] = {true,  // 0: not used...
                       true,  // 1: Preselection, H/E
                       true,  // 2: Preselection, delta phi
                       true,  // 3: Preselection, delta eta
                       true,  // 4: Preselection, pt
                       true, // 5: Trigger
                       true,  // 6: ETH Barrel only (flag can not be changed, cut is always applyed)
                       true, // 7: ETH Barrel, ECAL driven
                       true,  // 8: ETH Barrel, |1/E-1/p|
                       true,  // 9: ETH Barrel, delta eta
                       true,  //10: ETH Barrel, delta phi
                       true,  //11: ETH Barrel, isolation
                       true,  //12: ETH Barrel, conversions
                       true,  //13: not used... (ETH Endcap)
                       true, //14: ETH Endcap, ECAL driven
                       true,  //15: ETH Endcap, |1/E-1/p|
                       true,  //16: ETH Endcap, delta eta
                       true,  //17: ETH Endcap, delta phi
                       true,  //18: ETH Endcap, isolation
                       true,  //19: ETH Endcap, conversions
//                     true,  //20: Robust Barrel,
//                     true,  //21: Robust Barrel, H/E
//                     true,  //22: Robust Barrel, sigma ieta ieta
//                     true,  //23: Robust Barrel, delta phi
//                     true,  //24: Robust Barrel, delta eta
//                     true,  //25: Robust Barrel, track iso
//                     true,  //26: Robust Barrel, ecal iso
//                     true,  //27: Robust Barrel, hcal iso
//                     true,  //28: Robust Barrel, conversions
//                     true,  //29: Robust Endcap,
//                     true,  //30: Robust Endcap, H/E
//                     true,  //31: Robust Endcap, sigma ieta ieta
//                     true,  //32: Robust Endcap, delta phi
//                     true,  //33: Robust Endcap, delta eta
//                     true,  //34: Robust Endcap, track iso
//                     true,  //35: Robust Endcap, ecal iso
//                     true,  //36: Robust Endcap, hcal iso                    
//                     true  //37: Robust Endcap, conversions
   };

   //}

   // --------------------------------------------------------------------------------------------------------------------

   // --------------------------------------------------------------------------------------------------------------------
   // number of events
   // this histogram is filled for normalization purposes i.e. to keep track of the MC sample sizes
   // --------------------------------------------------------------------------------------------------------------------
   TH1I *h_numberOfEvents;
   h_numberOfEvents=new TH1I("numberOfEvents", "numberOfEvents", 1, -0.01, 1.01);
   // --------------------------------------------------------------------------------------------------------------------


   // --------------------------------------------------------------------------------------------------------------------
   // Electron plots
   // --------------------------------------------------------------------------------------------------------------------
   char name [50];
   int nbins=12;
   double start=0.;
   double end=120.;
   TH1D *hs_El_ElPt[MAXE];
   TH1D *hs_El_ElEta[MAXE];
   TH1D *hs_El_ElPhi[MAXE];
   TH1D *hs_El_ElDeltaPhi[MAXE];
   TH1D *hs_El_ElDeltaEta[MAXE];
   TH1D *hs_El_ElOneOverEminusOneOverP[MAXE];
   TH1D *hs_El_ElMet[MAXE];
   TH1D *hs_El_ElTransMass[MAXE];
   TH1D *hs_El_ElCharge[MAXE];
   TH1D *hs_El_Njets[MAXE];
   TH1D *hs_El_ElEthIso[MAXE];
   TH1D *hs_El_ElTrkIso[MAXE];
   TH1D *hs_El_ElEcalIso[MAXE];
   TH1D *hs_El_ElHcalIso[MAXE];
   TH1D *hs_El_ElCombIso[MAXE];
   TH1D *hs_El_ElHoverE[MAXE];
   TH1D *hs_El_ElSigmaIetaIeta[MAXE];
   TH1D *hs_El_ElNumberOfMissingInnerHits[MAXE];
    for(int i=0; i<MAXE; i++) {
      sprintf(name,"s_El_ElPt_%d",i);
      hs_El_ElPt[i]=new TH1D(name, name, nbins, start, end);
      hs_El_ElPt[i]->SetXTitle("p_{T} [GeV]");
      hs_El_ElPt[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElEta_%d",i);
      hs_El_ElEta[i]=new TH1D(name, name, 10, -2.5, 2.5);
      hs_El_ElEta[i]->SetXTitle("#eta");
      hs_El_ElEta[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElPhi_%d",i);
      hs_El_ElPhi[i]=new TH1D(name, name, 15, -Pi,Pi);
      hs_El_ElPhi[i]->SetXTitle("#phi");
      hs_El_ElPhi[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElDeltaPhi_%d",i);
      hs_El_ElDeltaPhi[i]=new TH1D(name, name, 30, -0.05001, 0.05001);
      hs_El_ElDeltaPhi[i]->SetXTitle("#Delta #phi");
      hs_El_ElDeltaPhi[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElDeltaEta_%d",i);
      hs_El_ElDeltaEta[i]=new TH1D(name, name, 30, -0.05001, 0.05001);
      hs_El_ElDeltaEta[i]->SetXTitle("#Delta #eta");
      hs_El_ElDeltaEta[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElMet_%d",i);
      hs_El_ElMet[i]=new TH1D(name, name, nbins, start, end);
      hs_El_ElMet[i]->SetXTitle("#slash{E}_{T} [GeV]");
      hs_El_ElMet[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElTransMass_%d",i);
      hs_El_ElTransMass[i]=new TH1D(name, name, nbins, start, end);
      hs_El_ElTransMass[i]->SetXTitle("m_{T} [GeV]");
      hs_El_ElTransMass[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElCharge_%d",i);
      hs_El_ElCharge[i]=new TH1D(name, name, 2, -2, 2);
      hs_El_ElCharge[i]->SetXTitle("Charge");
      hs_El_ElCharge[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_Njets_%d",i);
      hs_El_Njets[i]=new TH1D(name, name, 10, 0, 10);
      hs_El_Njets[i]->SetXTitle("number of jets");
      hs_El_Njets[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElOneOverEminusOneOverP_%d",i);
      hs_El_ElOneOverEminusOneOverP[i]=new TH1D(name, name, 30, -0.01, 0.5);
      hs_El_ElOneOverEminusOneOverP[i]->SetXTitle("|1/E-1/p|");
      hs_El_ElOneOverEminusOneOverP[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElEthIso_%d",i);
//       hs_El_ElEthIso[i]=new TH1D(name, name, 50, -0.01, 5.);
      hs_El_ElEthIso[i]=new TH1D(name, name, 20, -0.01, 1.1);
      hs_El_ElEthIso[i]->SetXTitle("ETH Iso");
      hs_El_ElEthIso[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElTrkIso_%d",i);
//       hs_El_ElTrkIso[i]=new TH1D(name, name, 100, -0.01, 50.);
      hs_El_ElTrkIso[i]=new TH1D(name, name, 20, -0.01, 1.1);
      hs_El_ElTrkIso[i]->SetXTitle("Trk Iso");
      hs_El_ElTrkIso[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElEcalIso_%d",i);
      hs_El_ElEcalIso[i]=new TH1D(name, name, 20, -0.01, 1.1);
//       hs_El_ElEcalIso[i]=new TH1D(name, name, 40, -0.01, 20.);
      hs_El_ElEcalIso[i]->SetXTitle("ECAL Iso");
      hs_El_ElEcalIso[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElHcalIso_%d",i);
      hs_El_ElHcalIso[i]=new TH1D(name, name, 20, -0.01, 10.);
      hs_El_ElHcalIso[i]->SetXTitle("HCAL Iso");
      hs_El_ElHcalIso[i]->SetYTitle("events / bin");

      sprintf(name,"s_El_ElCombIso_%d",i);
      hs_El_ElCombIso[i]=new TH1D(name, name, 20, -0.01, 3.1);
      hs_El_ElCombIso[i]->SetXTitle("Combined Iso");
      hs_El_ElCombIso[i]->SetYTitle("events / bin");

      sprintf(name,"s_El_ElHoverE_%d",i);
      hs_El_ElHoverE[i]=new TH1D(name, name, 30, -0.01, 0.5);
      hs_El_ElHoverE[i]->SetXTitle("H/E");
      hs_El_ElHoverE[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElSigmaIetaIeta_%d",i);
      hs_El_ElSigmaIetaIeta[i]=new TH1D(name, name, 50, -0.01, 0.08);
      hs_El_ElSigmaIetaIeta[i]->SetXTitle("#sigma_{i#eta i#eta}");
      hs_El_ElSigmaIetaIeta[i]->SetYTitle("events / bin");
      sprintf(name,"s_El_ElNumberOfMissingInnerHits_%d",i);
      hs_El_ElNumberOfMissingInnerHits[i]=new TH1D(name, name, 10, 0., 10.);
      hs_El_ElNumberOfMissingInnerHits[i]->SetXTitle("Number of missing inner hits");
      hs_El_ElNumberOfMissingInnerHits[i]->SetYTitle("events / bin");
    }

    TH1D *hc_El_counter;
    hc_El_counter=new TH1D("c_El_counter", "c_El_counter",15, 0, 15);
    hc_El_counter->GetXaxis()->SetBinLabel(1,"# e preselection");
    hc_El_counter->GetXaxis()->SetBinLabel(2,"# e presel, barrel");
    hc_El_counter->GetXaxis()->SetBinLabel(3,"# e see");
    hc_El_counter->GetXaxis()->SetBinLabel(4,"# e dphi");
    hc_El_counter->GetXaxis()->SetBinLabel(5,"# e deta");
    hc_El_counter->GetXaxis()->SetBinLabel(6,"# e hoe");
    hc_El_counter->GetXaxis()->SetBinLabel(7,"# e combIso");
    hc_El_counter->GetXaxis()->SetBinLabel(8,"# e conversion");
    hc_El_counter->GetXaxis()->SetBinLabel(9,"# e presel, endcap");
    hc_El_counter->GetXaxis()->SetBinLabel(10,"# e see");
    hc_El_counter->GetXaxis()->SetBinLabel(11,"# e dphi");
    hc_El_counter->GetXaxis()->SetBinLabel(12,"# e deta");
    hc_El_counter->GetXaxis()->SetBinLabel(13,"# e hoe");
    hc_El_counter->GetXaxis()->SetBinLabel(14,"# e combIso");
    hc_El_counter->GetXaxis()->SetBinLabel(15,"# e conversion");
    
    // acceptance plots
    TH2D *h_ElEtaVsScEta;
    h_ElEtaVsScEta = new TH2D("ElEtaVsScEta", "h_ElEtaVsScEta", 10, -2.5, 2.5, 10, -2.5, 2.5);
//     TH2D *h_ElPhiVsScPhi;
//     h_ElPhiVsScPhi = new TH2D("ElPhiVsScPhi", "h_ElPhiVsScPhi", 10, -Pi, Pi, 10, -Pi, Pi);
    TH2D *h_ElPtVsScEt;
    h_ElPtVsScEt = new TH2D("ElPtVsScEt", "ElPtVsScEt", 20, 0, 200, 20, 0, 200);
    

    // --------------------------------------------------------------------------------------------------------------------


    // --------------------------------------------------------------------------------------------------------------------
    // Electron ID N-1 plots
    // --------------------------------------------------------------------------------------------------------------------
    int MAXN=4;
    TH1D *hn1_El_ElDeltaPhi[MAXN];
    TH1D *hn1_El_ElDeltaEta[MAXN];
    TH1D *hn1_El_ElOneOverEminusOneOverP[MAXN];
//     TH1D *hn1_El_ElPt[MAXN];
//     TH1D *hn1_El_ElEta[MAXN];
//     TH1D *hn1_El_ElPhi[MAXN];
//     TH1D *hn1_El_ElMet[MAXN];
//     TH1D *hn1_El_ElTransMass[MAXN];
//     TH1D *hn1_El_ElCharge[MAXN];
//     TH1D *hn1_El_Njets[MAXN];
    TH1D *hn1_El_ElEthIso[MAXN];
//     TH1D *hn1_El_ElTrkIso[MAXN];
//     TH1D *hn1_El_ElEcalIso[MAXN];
//     TH1D *hn1_El_ElHcalIso[MAXN];
    TH1D *hn1_El_ElCombIso[MAXN];
    TH1D *hn1_El_ElHoverE[MAXN];
    TH1D *hn1_El_ElSigmaIetaIeta[MAXN];
    TH1D *hn1_El_ElNumberOfMissingInnerHits[MAXN];
    

    for(int i=0; i<MAXN;i++) {
      sprintf(name,"n1_El_ElDeltaPhi_%d",i);
      hn1_El_ElDeltaPhi[i]=new TH1D(name, name, 30, -0.05001, 0.05001);    // plotting absolut value
//      hn1_El_ElDeltaPhi[i]=new TH1D(name, name, 15, -0.05001, 0.05001);     // plotting real value
      hn1_El_ElDeltaPhi[i]->SetXTitle("#Delta #phi");
      hn1_El_ElDeltaPhi[i]->SetYTitle("events / bin");
      sprintf(name,"n1_El_ElDeltaEta_%d",i);
      hn1_El_ElDeltaEta[i]=new TH1D(name, name, 30, -0.02001, 0.02001);     // plotting absolut value
//       hn1_El_ElDeltaEta[i]=new TH1D(name, name, 15, -0.05001, 0.05001);     // plotting real value
      hn1_El_ElDeltaEta[i]->SetXTitle("#Delta #eta");
      hn1_El_ElDeltaEta[i]->SetYTitle("events / bin");
      sprintf(name,"n1_El_ElOneOverEminusOneOverP_%d",i);
      hn1_El_ElOneOverEminusOneOverP[i]=new TH1D(name, name, 15, -0.0001, 0.05001);
      hn1_El_ElOneOverEminusOneOverP[i]->SetXTitle("|1/E-1/p|");
      hn1_El_ElOneOverEminusOneOverP[i]->SetYTitle("events / bin");
      sprintf(name,"n1_El_ElEthIso_%d",i);
      hn1_El_ElEthIso[i]=new TH1D(name, name, 50, -0.01, 5.);
      hn1_El_ElEthIso[i]->SetXTitle("Isolation");
      hn1_El_ElEthIso[i]->SetYTitle("events / bin");


//       sprintf(name,"n1_El_ElPt_%d",i);
//       hn1_El_ElPt[i]=new TH1D(name, name, nbins, start, end);
//       hn1_El_ElPt[i]->SetXTitle("p_{T} [GeV]");
//       hn1_El_ElPt[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElEta_%d",i);
//       hn1_El_ElEta[i]=new TH1D(name, name, 30, -5., 5.);
//       hn1_El_ElEta[i]->SetXTitle("#eta");
//       hn1_El_ElEta[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElPhi_%d",i);
//       hn1_El_ElPhi[i]=new TH1D(name, name, 30, -Pi,Pi);
//       hn1_El_ElPhi[i]->SetXTitle("#phi");
//       hn1_El_ElPhi[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElMet_%d",i);
//       hn1_El_ElMet[i]=new TH1D(name, name, nbins, start, end);
//       hn1_El_ElMet[i]->SetXTitle("#slash{E}_{T} [GeV]");
//       hn1_El_ElMet[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElTransMass_%d",i);
//       hn1_El_ElTransMass[i]=new TH1D(name, name, nbins, start, end);
//       hn1_El_ElTransMass[i]->SetXTitle("m_{T} [GeV]");
//       hn1_El_ElTransMass[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElCharge_%d",i);
//       hn1_El_ElCharge[i]=new TH1D(name, name, 2, -2, 2);
//       hn1_El_ElCharge[i]->SetXTitle("Charge");
//       hn1_El_ElCharge[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_Njets_%d",i);
//       hn1_El_Njets[i]=new TH1D(name, name, 10, 0, 10);
//       hn1_El_Njets[i]->SetXTitle("number of jets");
//       hn1_El_Njets[i]->SetYTitle("events / bin");

//       sprintf(name,"n1_El_ElTrkIso_%d",i);
// //       sprintf(name,"n1_El_ElTrkIso_%d",i);
//       hn1_El_ElTrkIso[i]=new TH1D(name, name, 20, -0.01, 0.3);
//       hn1_El_ElTrkIso[i]->SetXTitle("Trk Iso");
//       hn1_El_ElTrkIso[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElEcalIso_%d",i);
//       hn1_El_ElEcalIso[i]=new TH1D(name, name, 20, -0.01, 0.3);
// //       hn1_El_ElEcalIso[i]=new TH1D(name, name, 40, -0.01, 20.);
//       hn1_El_ElEcalIso[i]->SetXTitle("ECAL Iso");
//       hn1_El_ElEcalIso[i]->SetYTitle("events / bin");
//       sprintf(name,"n1_El_ElHcalIso_%d",i);
//       hn1_El_ElHcalIso[i]=new TH1D(name, name, 20, -0.01, 0.3);
// //       hn1_El_ElHcalIso[i]=new TH1D(name, name, 20, -0.01, 10.);
//       hn1_El_ElHcalIso[i]->SetXTitle("HCAL Iso");
//       hn1_El_ElHcalIso[i]->SetYTitle("events / bin");

      sprintf(name,"n1_El_ElCombIso_%d",i);
      hn1_El_ElCombIso[i]=new TH1D(name, name, 20, -0.01, 0.5);
//       hn1_El_ElCombIso[i]=new TH1D(name, name, 20, -0.01, 10.);
      hn1_El_ElCombIso[i]->SetXTitle("Combined Iso");
      hn1_El_ElCombIso[i]->SetYTitle("events / bin");

      sprintf(name,"n1_El_ElHoverE_%d",i);
      hn1_El_ElHoverE[i]=new TH1D(name, name, 30, -0.01, 0.2);
      hn1_El_ElHoverE[i]->SetXTitle("H/E");
      hn1_El_ElHoverE[i]->SetYTitle("events / bin");
      sprintf(name,"n1_El_ElSigmaIetaIeta_%d",i);
      hn1_El_ElSigmaIetaIeta[i]=new TH1D(name, name, 50, -0.01, 0.08);
      hn1_El_ElSigmaIetaIeta[i]->SetXTitle("#sigma_{i#eta i#eta}");
      hn1_El_ElSigmaIetaIeta[i]->SetYTitle("events / bin");
      sprintf(name,"n1_El_ElNumberOfMissingInnerHits_%d",i);
      hn1_El_ElNumberOfMissingInnerHits[i]=new TH1D(name, name, 10, 0., 10.);
      hn1_El_ElNumberOfMissingInnerHits[i]->SetXTitle("Number of missing inner hits");
      hn1_El_ElNumberOfMissingInnerHits[i]->SetYTitle("events / bin");


    }
    
    // --------------------------------------------------------------------------------------------------------------------
    

   // --------------------------------------------------------------------------------------------------------------------
   // W Selection plots
   // --------------------------------------------------------------------------------------------------------------------
   int MAXS=29;
//    char name [50];
//    int nbins=20;
//    double start=0.;
//    double end=120.;
   TH1D *hs_W_ElPt[MAXS];
   TH1D *hs_W_ElEta[MAXS];
   TH1D *hs_W_ElPhi[MAXS];
   TH1D *hs_W_ElDeltaPhi[MAXS];
   TH1D *hs_W_ElMet[MAXS];
   TH1D *hs_W_ElTransMass[MAXS];
   TH1D *hs_W_ElCharge[MAXS];
   TH1D *hs_W_Njets[MAXS];
    for(int i=0; i<MAXS; i++) {
      sprintf(name,"s_W_ElPt_%d",i);
      hs_W_ElPt[i]=new TH1D(name, name, nbins, start, end);
      hs_W_ElPt[i]->SetXTitle("p_{T} [GeV]");
      hs_W_ElPt[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_ElEta_%d",i);
      hs_W_ElEta[i]=new TH1D(name, name, 30, -5., 5.);
      hs_W_ElEta[i]->SetXTitle("#eta");
      hs_W_ElEta[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_ElPhi_%d",i);
      hs_W_ElPhi[i]=new TH1D(name, name, 30, -Pi,Pi);
      hs_W_ElPhi[i]->SetXTitle("#phi");
      hs_W_ElPhi[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_ElDeltaPhi_%d",i);
      hs_W_ElDeltaPhi[i]=new TH1D(name, name, 15, 0., Pi);
      hs_W_ElDeltaPhi[i]->SetXTitle("#Delta #phi_{e,#slash{E}_{T}}");
      hs_W_ElDeltaPhi[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_ElMet_%d",i);
      hs_W_ElMet[i]=new TH1D(name, name, nbins, start, end);
      hs_W_ElMet[i]->SetXTitle("#slash{E}_{T} [GeV]");
      hs_W_ElMet[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_ElTransMass_%d",i);
      hs_W_ElTransMass[i]=new TH1D(name, name, nbins, start, end);
      hs_W_ElTransMass[i]->SetXTitle("m_{T} [GeV]");
      hs_W_ElTransMass[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_ElCharge_%d",i);
      hs_W_ElCharge[i]=new TH1D(name, name, 2, -2, 2);
      hs_W_ElCharge[i]->SetXTitle("Charge");
      hs_W_ElCharge[i]->SetYTitle("events / bin");
      sprintf(name,"s_W_Njets_%d",i);
      hs_W_Njets[i]=new TH1D(name, name, 10, 0, 10);
      hs_W_Njets[i]->SetXTitle("number of jets");
      hs_W_Njets[i]->SetYTitle("events / bin");
    }

    int MAXWcounter=16;
    int *Wcounter = new int[MAXWcounter];
    memset(Wcounter,0,MAXWcounter*sizeof(int));


    TH1D *hc_W_counter;
    hc_W_counter=new TH1D("c_W_counter", "c_W_counter",16, 0, 16 );
    hc_W_counter->GetXaxis()->SetBinLabel(1,"# e, N jets, Preselection");
    hc_W_counter->GetXaxis()->SetBinLabel(2,"# W, N jets");
    hc_W_counter->GetXaxis()->SetBinLabel(3,"# W+, N jets");
    hc_W_counter->GetXaxis()->SetBinLabel(4,"# W-, N jets");
    hc_W_counter->GetXaxis()->SetBinLabel(5,"# e, 0 jets, Preselection");
    hc_W_counter->GetXaxis()->SetBinLabel(6,"# W, 0 jets");
    hc_W_counter->GetXaxis()->SetBinLabel(7,"# W+, 0 jets");
    hc_W_counter->GetXaxis()->SetBinLabel(8,"# W-, 0 jets");
    hc_W_counter->GetXaxis()->SetBinLabel(9,"# e, 1 jet, Preselection");
    hc_W_counter->GetXaxis()->SetBinLabel(10,"# W, 1 jet");
    hc_W_counter->GetXaxis()->SetBinLabel(11,"# W+, 1 jet");
    hc_W_counter->GetXaxis()->SetBinLabel(12,"# W-, 1 jet");
    hc_W_counter->GetXaxis()->SetBinLabel(13,"# e, >1 jets, Preselection");
    hc_W_counter->GetXaxis()->SetBinLabel(14,"# W, >1 jets");
    hc_W_counter->GetXaxis()->SetBinLabel(15,"# W+, >1 jets");
    hc_W_counter->GetXaxis()->SetBinLabel(16,"# W-, >1jets");

   // --------------------------------------------------------------------------------------------------------------------


    // --------------------------------------------------------------------------------------------------------------------
    // Z plots 
    // --------------------------------------------------------------------------------------------------------------------    
    int MAXZ=4;
    TH1D *h_Z_invMass[MAXZ];
    TH1D *h_Z_ptAll[MAXZ];
    TH1D *h_Z_etaAll[MAXZ];
    TH1D *h_Z_phiAll[MAXZ];
    TH1D *h_Z_deltaPhi[MAXZ];
    TH1D *h_Z_ptDiLepton[MAXZ];
    TH1D *h_Z_etaDiLepton[MAXZ];
    TH1D *h_Z_phiDiLepton[MAXZ];

    TH1D *h_Z_leadingJetPt[MAXZ];
    TH1D *h_Z_summedJetPt[MAXZ];
    TH1D *h_Z_leadingJetEta[MAXZ];
    TH1D *h_Z_summedJetEta[MAXZ];
    TH1D *h_Z_leadingJetPhi[MAXZ];
    TH1D *h_Z_summedJetPhi[MAXZ];
    TH1D *h_Z_nJets[MAXZ];
    TH1D *h_Z_leadingJetDeltaPt[MAXZ];
    TH1D *h_Z_leadingJetDeltaEta[MAXZ];
    TH1D *h_Z_leadingJetDeltaPhi[MAXZ];
    TH1D *h_Z_summedJetDeltaPt[MAXZ];
    TH1D *h_Z_summedJetDeltaEta[MAXZ];
    TH1D *h_Z_summedJetDeltaPhi[MAXZ];
    TH1D *h_Z_recoilPt[MAXZ];
    TH1D *h_Z_recoilEta[MAXZ];
    TH1D *h_Z_recoilPhi[MAXZ];
    TH1D *h_Z_metPt[MAXZ];
    TH1D *h_Z_metEta[MAXZ];
    TH1D *h_Z_metPhi[MAXZ];


    for(int i=0; i<MAXZ; i++) {
      sprintf(name,"h_Z_invMass_%d",i);
      h_Z_invMass[i] = new TH1D(name,name,80,0,200);
      h_Z_invMass[i]->SetXTitle("m_{ee} [GeV/c^{2}]");
      h_Z_invMass[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_ptAll_%d",i);
      h_Z_ptAll[i] = new TH1D(name,name,20,0,200);
      h_Z_ptAll[i]->SetXTitle("p_{T} [GeV]");
      h_Z_ptAll[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_etaAll_%d",i);
      h_Z_etaAll[i] = new TH1D(name,name,12,-3.,3.);
      h_Z_etaAll[i]->SetXTitle("#eta");
      h_Z_etaAll[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_phiAll_%d",i);
      h_Z_phiAll[i] = new TH1D(name,name,30,-Pi,Pi);
      h_Z_phiAll[i]->SetXTitle("#phi");
      h_Z_phiAll[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_deltaPhi_%d",i);
      h_Z_deltaPhi[i] = new TH1D(name,name,15,0,Pi);
      h_Z_deltaPhi[i]->SetXTitle("#Delta #phi_{ee}");
      h_Z_deltaPhi[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_ptDiLepton_%d",i);
      h_Z_ptDiLepton[i] = new TH1D(name,name,20,0,200);
      h_Z_ptDiLepton[i]->SetXTitle("p_{T} [GeV]");
      h_Z_ptDiLepton[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_etaDiLepton_%d",i);
      h_Z_etaDiLepton[i] = new TH1D(name,name,16,-8.,8.);
      h_Z_etaDiLepton[i]->SetXTitle("#eta");
      h_Z_etaDiLepton[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_phiDiLepton_%d",i);
      h_Z_phiDiLepton[i] = new TH1D(name,name,30,-Pi,Pi);
      h_Z_phiDiLepton[i]->SetXTitle("#phi");
      h_Z_phiDiLepton[i]->SetYTitle("events / bin");


      sprintf(name,"h_Z_leadingJetPt_%d",i);
      h_Z_leadingJetPt[i] = new TH1D(name,name,20,0,200);
      h_Z_leadingJetPt[i]->SetXTitle("p_{T} [GeV]");
      h_Z_leadingJetPt[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_summedJetPt_%d",i);
      h_Z_summedJetPt[i] = new TH1D(name,name,20,0,200);
      h_Z_summedJetPt[i]->SetXTitle("p_{T} [GeV]");
      h_Z_summedJetPt[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_leadingJetEta_%d",i);
      h_Z_leadingJetEta[i] = new TH1D(name,name,12,-3,3);
      h_Z_leadingJetEta[i]->SetXTitle("#eta");
      h_Z_leadingJetEta[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_summedJetEta_%d",i);
      h_Z_summedJetEta[i] = new TH1D(name,name,16,-8,8);
      h_Z_summedJetEta[i]->SetXTitle("#eta");
      h_Z_summedJetEta[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_leadingJetPhi_%d",i);
      h_Z_leadingJetPhi[i] = new TH1D(name,name,30,-Pi,Pi);
      h_Z_leadingJetPhi[i]->SetXTitle("#phi");
      h_Z_leadingJetPhi[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_summedJetPhi_%d",i);
      h_Z_summedJetPhi[i] = new TH1D(name,name,30,-Pi,Pi);
      h_Z_summedJetPhi[i]->SetXTitle("#phi");
      h_Z_summedJetPhi[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_nJets_%d",i);
      h_Z_nJets[i] = new TH1D(name,name,11,0,11);
      h_Z_nJets[i]->SetXTitle("jet number");
      h_Z_nJets[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_leadingJetDeltaPt_%d",i);
      h_Z_leadingJetDeltaPt[i] = new TH1D(name,name,60,-150,150);
      h_Z_leadingJetDeltaPt[i]->SetXTitle("#Delta p_{T,jZ} [GeV]");
      h_Z_leadingJetDeltaPt[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_leadingJetDeltaEta_%d",i);
      h_Z_leadingJetDeltaEta[i] = new TH1D(name,name,16,-8,8);
      h_Z_leadingJetDeltaEta[i]->SetXTitle("#Delta #eta_{jZ}");
      h_Z_leadingJetDeltaEta[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_leadingJetDeltaPhi_%d",i);
      h_Z_leadingJetDeltaPhi[i] = new TH1D(name,name,15,0,Pi);
      h_Z_leadingJetDeltaPhi[i]->SetXTitle("#Delta #phi_{jZ}");
      h_Z_leadingJetDeltaPhi[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_summedJetDeltaPt_%d",i);
      h_Z_summedJetDeltaPt[i] = new TH1D(name,name,60,-150,150);
      h_Z_summedJetDeltaPt[i]->SetXTitle("#Delta p_{T,jZ} [GeV]");
      h_Z_summedJetDeltaPt[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_summedJetDeltaEta_%d",i);
      h_Z_summedJetDeltaEta[i] = new TH1D(name,name,16,-8,8);
      h_Z_summedJetDeltaEta[i]->SetXTitle("#Delta #eta_{jZ}");
      h_Z_summedJetDeltaEta[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_summedJetDeltaPhi_%d",i);
      h_Z_summedJetDeltaPhi[i] = new TH1D(name,name,15,0,Pi);
      h_Z_summedJetDeltaPhi[i]->SetXTitle("#Delta #phi_{jZ}");
      h_Z_summedJetDeltaPhi[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_recoilPt_%d",i);
      h_Z_recoilPt[i] = new TH1D(name,name,20,0,200);
      h_Z_recoilPt[i]->SetXTitle("p_{T,j+Z} [GeV]");
      h_Z_recoilPt[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_recoilEta_%d",i);
      h_Z_recoilEta[i] = new TH1D(name,name,16,-8,8);
      h_Z_recoilEta[i]->SetXTitle("#eta_{j+Z}");
      h_Z_recoilEta[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_recoilPhi_%d",i);
      h_Z_recoilPhi[i] = new TH1D(name,name,30,-Pi,Pi);
      h_Z_recoilPhi[i]->SetXTitle("#phi_{j+Z}");
      h_Z_recoilPhi[i]->SetYTitle("events / bin");

      sprintf(name,"h_Z_metPt_%d",i);
      h_Z_metPt[i] = new TH1D(name,name,20,0,200);
      h_Z_metPt[i]->SetXTitle("#slash{p}_{T} [GeV]");
      h_Z_metPt[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_metEta_%d",i);
      h_Z_metEta[i] = new TH1D(name,name,16,-8,8);
      h_Z_metEta[i]->SetXTitle("#eta_{#slash{p}_{T}}");
      h_Z_metEta[i]->SetYTitle("events / bin");
      sprintf(name,"h_Z_metPhi_%d",i);
      h_Z_metPhi[i] = new TH1D(name,name,30,-Pi,Pi);
      h_Z_metPhi[i]->SetXTitle("#phi_{#slash{p}_{T}}");
      h_Z_metPhi[i]->SetYTitle("events / bin");
      
//       TH2D *h_Z_summedJetDeltaPhi_VS_deltaPhi("summedJetDeltaPhi_VS_deltaPhi", "summedJetDeltaPhi_VS_deltaPhi", 30,-Pi,Pi,15,0,Pi);

    }
      // --------------------------------------------------------------------------------------------------------------------


   // --------------------------------------------------------------------------------------------------------------------
   // get the trigger map this is done once per input file
   // check that all files in the same input file have the
   // same trigger table
   // --------------------------------------------------------------------------------------------------------------------
    getHLTtable(); 
   // --------------------------------------------------------------------------------------------------------------------


    ////////////////////////////////////////////////////////////////////
    ////////////////////Loop over entries starts here //////////////////
    ////////////////////////////////////////////////////////////////////
    

    TH1D *h_jetPt = new TH1D("h_jetPt", "jet_Pt",100,0,100);
    
    /////////initialize variables
    
    Long64_t nentries = fChain->GetEntriesFast();
    std::cout << "analysisClass::Loop(): nentries = " << nentries << std::endl;   
    
    ////// The following ~7 lines have been taken from rootNtupleClass->Loop() /////
    ////// If the root version is updated and rootNtupleClass regenerated,     /////
    ////// these lines may need to be updated.                                 /////    
    Long64_t nb = 0;
    

    for (Long64_t jentry=0; jentry<nentries;jentry++) {  // loop over all events (entries) in the tree/chain


      Long64_t ientry = fChain->LoadTree(jentry);  // ientry: this is a counter over each single file in the input list

      if (ientry < 0) {cerr<<"WARNING: ientry = "<<ientry<<" is smaller than 0! (this is ok if the end of the file is reached...)"<<endl; break; }
      
      nb=fChain->GetEntry(jentry);
      //fChain->GetEntry(jentry);
      
      if(jentry < 10 || jentry%1000 == 0) {
        std::cout << "analysisClass::Loop(): Events processed = " << jentry << std::endl;   
      }
      
      if(sampleSize!=-1 && sampleSize==jentry) {
        goto END;
      }
      totalNumberOfEvents++;
      h_numberOfEvents->Fill(1);
      
     ////////////////////////////////////////////////////////////////////
     ////////////////////// User's code starts here /////////////////////
     ////////////////////////////////////////////////////////////////////
     
     // check the methods defined in baseClass
     
     testEvent lepton;
     lepton = fillTestEvent();
     for(int ii=0;ii<NEles;ii++) {
       //        cout<<"pt: "<<lepton.fourMomentum[ii].Perp()<<endl;
     }
     
     jetIndex.clear();
     electronIndex.clear();


     vector<TLorentzVector> electronsTight;
     vector<TLorentzVector> electronsETH;
     vector<TLorentzVector> electronsTightIsolated;
     vector<TLorentzVector> electronsETHIsolated;
     vector<TLorentzVector> jets;
     electronsTight.clear();
     electronsETH.clear();
     jets.clear();
     
     
     int BSC_techbit = 0;
     int BeamHalo    = 0;
     
     
     // --------------------------------------------------------------------------------
     // get the MET
     // --------------------------------------------------------------------------------
     double met;
     double metPhi;
//      double metEta;
     double delPhiMet;
     met=PFMET;
     metPhi=PFMETphi;
//      metEta=PFMETeta;
     
     // --------------------------------------------------------------------------------
     // get the number of jets
     // --------------------------------------------------------------------------------
     int njets=0;
     
     
     //          vector<TLorentzVector> jets;
     for(int j=0;j<NJets;j++) {
       TLorentzVector vec;
       vec.SetPxPyPzE(JPx[j],JPy[j],JPz[j],JE[j]);
       if(JPx[j]>jetPtMin) {
             jets.push_back(vec);
       }
     }
     vector<TLorentzVector> eles;
     for(int e=0;e<NEles;e++) {
       TLorentzVector vec;
       vec.SetPxPyPzE(ElPx[e],ElPy[e],ElPz[e],ElE[e]);
       myEvent ele;
       ele.fourvector.push_back(vec);
       ele.momentum.push_back(ElPt[e]);
       ele.missinget=met;
       ele.charge.push_back(ElCharge[e]);
       double dEtaCorrection=0;
       double dPhiCorrection=0;
       if(isdata==true && applyDeltaCorrection==true) {
         dEtaCorrection=detaCorrections(ElEta[e], ElPhi[e]);
         dPhiCorrection=dphiCorrections(ElEta[e], ElPhi[e]);
       }
       ele.deltaPhi.push_back(ElDeltaPhiSuperClusterAtVtx[e] - dPhiCorrection);
       ele.deltaEta.push_back(ElDeltaEtaSuperClusterAtVtx[e] - dEtaCorrection);
       ele.oneOverEminusOverP.push_back(fabs(1/ElCaloEnergy[e]-1/ElTrkMomAtVtx[e]));
       ele.transverseMass.push_back(transverseMass(ElPt[e], met, deltaPhi(ElPhi[e],metPhi)));
       ele.ethIso.push_back(ElDR03TkSumPt[e]/ElCaloEnergy[e]);
       if(workingPoint>0) {
         ele.trkIso.push_back(ElDR03TkSumPt[e]/ElPt[e]);
         ele.ecalIso.push_back(ElDR03EcalRecHitSumEt[e]/ElPt[e]);
         ele.hcalIso.push_back(ElDR03HcalTowerSumEt[e]/ElPt[e]);
       }
       if(workingPoint<0) {
         ele.trkIso.push_back(ElDR03TkSumPt[e]);
         ele.ecalIso.push_back(ElDR04EcalRecHitSumEt[e]);
         ele.hcalIso.push_back(ElDR04HcalTowerSumEt[e]);
       }
       ele.HoverE.push_back(ElHcalOverEcal[e]);
       ele.sigmaIetaIeta.push_back(ElSigmaIetaIeta[e]);
       if(noInnerHitInfo==false) {
         ele.numberOfMissingInnerHits.push_back(ElNumberOfMissingInnerHits[e]);
       }
       else if(noInnerHitInfo==true) {
         ele.numberOfMissingInnerHits.push_back(0);
       }
       // check if really only one electron is filled
       if(ele.fourvector.size()>1) {
         cout<<"ele size to large!!!: "<<ele.fourvector.size()<<endl;
         break;
       }
       
       if(WorkingPointID(ele, WorkingPointCuts)==true && ele.momentum[0]>20) {
         eles.push_back(vec);
         //debug++;
       }
     }
     
     int matched=0;
     double dR=9999.;
     for(int nj=0;nj<jets.size();nj++) {
       for(int ne=0;ne<eles.size();ne++) {
         
         double deltaR=fabs(jets[nj].DeltaR(eles[ne]));
         if(deltaR<dR) dR=deltaR;
       }
       if(dR>deltaRMax) njets++;
     }
     
     // --------------------------------------------------------------------------------
     // ugly implemented JET VETO and MET cut
     // --------------------------------------------------------------------------------


         if(applyJetVeto==true && (njets>0 || met<25)) continue;

         // --------------------------------------------------------------------------------

         // --------------------------------------------------------------------------------
         // Let's have a look at the electrons
         // --------------------------------------------------------------------------------
         

         // define the different electrons
         myEvent tightElectrons;
         myEvent ethElectrons;


         double etaMaxBarrel=1.44;
         double etaMaxEndcap=2.5;
         
         double deltaPhiCut=0.02;
         double deltaEtaCut=0.004;
         double oneOverEminusOneOverPCut=0.005;
         bool ethIDpassed=false;
         

         // loop over all electrons in one event
         for(int i=0; i<NEles; i++) {

//         if(ElectronPreselection(i)==0) debug++;


           // --------------------------------------------------------------------------------
           // check acceptance region of the electrons...
           // --------------------------------------------------------------------------------
           double accEta;
//         accEta = ElEta[i];
           accEta = ElSCEta[i];  // use the SC eta to define acceptance
           // --------------------------------------------------------------------------------
           

           // --------------------------------------------------------------------------------
           // apply corrections for delta eta and delta phi
           // --------------------------------------------------------------------------------
           double dEtaCorrection=0;
           double dPhiCorrection=0;
           if(isdata==true && applyDeltaCorrection==true) {
             dEtaCorrection=detaCorrections(accEta, ElPhi[i]);
             dPhiCorrection=dphiCorrections(accEta, ElPhi[i]);
           }
           // --------------------------------------------------------------------------------
             
           // --------------------------------------------------------------------------------
           // fill the myevent
           // --------------------------------------------------------------------------------
           TLorentzVector vec;
           vec.SetPxPyPzE(ElPx[i],ElPy[i],ElPz[i],ElE[i]);
           myEvent candidate;
           candidate.fourvector.push_back(vec);
           candidate.momentum.push_back(ElPt[i]);
           candidate.missinget=met;
           candidate.charge.push_back(ElCharge[i]);
           candidate.deltaPhi.push_back(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection);
           candidate.deltaEta.push_back(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection);
           candidate.oneOverEminusOverP.push_back(fabs(1/ElCaloEnergy[i]-1/ElTrkMomAtVtx[i]));
           candidate.transverseMass.push_back(transverseMass(ElPt[i], met, deltaPhi(ElPhi[i],metPhi)));
           candidate.ethIso.push_back(ElDR03TkSumPt[i]/ElCaloEnergy[i]);
           if(workingPoint>0) {
             candidate.trkIso.push_back(ElDR03TkSumPt[i]/ElPt[i]);
             candidate.ecalIso.push_back(ElDR03EcalRecHitSumEt[i]/ElPt[i]);
             candidate.hcalIso.push_back(ElDR03HcalTowerSumEt[i]/ElPt[i]);
           }
           if(workingPoint<0) {
             candidate.trkIso.push_back(ElDR03TkSumPt[i]);
             candidate.ecalIso.push_back(ElDR04EcalRecHitSumEt[i]);
             candidate.hcalIso.push_back(ElDR04HcalTowerSumEt[i]);
           }
           candidate.HoverE.push_back(ElHcalOverEcal[i]);
           candidate.sigmaIetaIeta.push_back(ElSigmaIetaIeta[i]);
           if(noInnerHitInfo==false) {
             candidate.numberOfMissingInnerHits.push_back(ElNumberOfMissingInnerHits[i]);
           }
           else if(noInnerHitInfo==true) {
             candidate.numberOfMissingInnerHits.push_back(0);
           }

           // check if really only one electron is filled
           if(candidate.fourvector.size()>1) {
             cout<<"candidate size to large!!!: "<<candidate.fourvector.size()<<endl;
             break;
           }
           // --------------------------------------------------------------------------------
           
           // check if electron is in acceptance region of the detector
           if(fabs(accEta)<etaEndcapMax) {
           

             // fill a set of plots for the gsf electron candidates
             int cut=0;
             filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                    hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                    hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                    hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                    );
             
             // make the electron preselection
             if(applyCut[1]==false || ElHcalOverEcal[i]<Pre_HoverEMin) {
               cut=1;
               filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                      hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                      hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                      hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                      );   
               if(applyCut[2]==false || fabs(ElDeltaPhiSuperClusterAtVtx[i] -dPhiCorrection)<Pre_deltaPhiMax) {
                 cut=2;
                 filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                        hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                        hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                        hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                        );
                 if(applyCut[3]==false || fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection)<Pre_deltaEtaMax) {
                   cut=3;
                   filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                          hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                          hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                          hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                          );
                   
                   if(applyCut[4]==false || ElPt[i]>Pre_pt) {
                     cut=4;
                     filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                            hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                            hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                            hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                            );
                     

                     // now the preselection is done...
                     
                     // ask for triggers HLT_Photon10
                     //                  cout<<"Trigger: 53: "<<HLTResults[53]<<"/ 54: "<<HLTResults[54]<<"/ 55: "<<HLTResults[55]<<endl;
                     
                     // get the right trigger bit
                     int Photon10;
                     int Photon15;
                     int Photon10_Cleaned;
                     int Ele15;
                     Photon10 = getHLTtriggerBit("HLT_Photon10_L1R");
                     Photon15 = getHLTtriggerBit("HLT_Photon15_L1R");
//                   Photon10_Cleaned = getHLTtriggerBit("HLT_Photon10_Cleaned_L1R");
                     Ele15 = getHLTtriggerBit("HLT_Ele15_LW_L1R");
                     
                     if(applyCut[5]==false || HLTResults[Photon10]==1 || HLTResults[Photon15]==1 || HLTResults[Ele15]==1) {
//                   if(true) {
                       cut=5;
                       filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                              hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                              hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                              hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                              );
                       
                       
                       // now the different IDs

                     // check if electron from conversion...
                     bool isConversion;
                     if((fabs(ElConvPartnerTrkDist[i])<0.02 && fabs(ElConvPartnerTrkDCot[i])<0.02) || ElNumberOfMissingInnerHits[i]>1) isConversion=true;
                     else isConversion=false;

                     
                     // first the ETH one for the barrel
                     double OneoverEminusOneoverP=fabs(1/ElCaloEnergy[i]-1/ElTrkMomAtVtx[i]);
                     if(fabs(accEta)<etaBarrelMax) {
                       cut=6;
                       //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                       filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                              hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                              hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                              hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                              );
                       // only ECAL driven electrons
                       if(applyCut[7]==false || ElEcalDriven[i]==1) {
                         cut=7;
                         //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                         filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                );
                         // |1/E-1/p|
                         if(applyCut[8]==false || OneoverEminusOneoverP<ETH_oneOverEminusOneOverP_B) {
                           cut=8;
                           //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                           filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                  hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                  hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                  hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                  );
                           // delta eta
                           if(applyCut[9]==false || fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection)<ETH_deltaEtaMax_B) {
                             cut=9;
                             //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                             filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                    hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                    hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                    hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                    );
                             // delta phi
                             if(applyCut[10]==false || fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection)<ETH_deltaPhiMax_B) {
                               cut=10;
                               //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                               filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                      hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                      hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                      hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                      );
                               // isolation
                               double iso=ElDR04TkSumPt[i]/ElCaloEnergy[i];
                               if(applyCut[11]==false || iso<ETH_iso_B) {
                                 cut=11;
                                 //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                                 filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                        hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                        hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                        hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                        );
                                 // remove conversions
//                               if(applyCut[12]==false || (ElNumberOfMissingInnerHits[i]<2 && ElConvPartnerTrkDist[i]<Rob_dist_E && ElConvPartnerTrkDCot[i]<Rob_cot_E) ) {
                                 if(applyCut[12]==false || isConversion==false) {
                                   cut=12;
                                   //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                                   filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                          hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                          hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                          hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                          );                               
                                 } // conversions
                               } // isolation
                             } //delta phi, barrel
                           } //delta eta, barrel
                         } // 1/e-1/p, barrel        
                       }  // ECAL driven, barrel
                     } // ETH barrel
                     
                     // now the ETH ID for the endcaps
                     else if(fabs(accEta)>etaEndcapMin && fabs(accEta)<etaEndcapMax) {
                       cut=13;
                       //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                       filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                              hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                              hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                              hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                              );
                       // only ECAL driven electrons
                       if(applyCut[14]==false || ElEcalDriven[i]==1) {
                         cut=14;
                         //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                         filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                );
                         // |1/E-1/p|
                         if(applyCut[15]==false || OneoverEminusOneoverP<ETH_oneOverEminusOneOverP_E) {
                           cut=15;
                           //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                           filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                  hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                  hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                  hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                  );
                           // delta eta
                           if(applyCut[16]==false || fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection)<ETH_deltaEtaMax_E) {
                             cut=16;
                             //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                             filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                    hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                    hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                    hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                    );
                             // delta phi
                             if(applyCut[17]==false || fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection)<ETH_deltaPhiMax_E) {
                               cut=17;
                               //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                               filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                      hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                      hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                      hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                      );
                               // isolation
                               double iso=ElDR04TkSumPt[i]/ElCaloEnergy[i];
                               if(applyCut[18]==false || iso<ETH_iso_E) {
                                 cut=18;
                                 //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                                 filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                        hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                        hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                        hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                        );
                                 // remove conversions
                                 if(applyCut[19]==false || isConversion==false) {
                                   cut=19;
                                   //filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut]);
                                   filler(candidate, hs_El_ElPt[cut], hs_El_ElEta[cut], hs_El_ElPhi[cut], hs_El_ElMet[cut], hs_El_ElCharge[cut],
                                          hs_El_ElDeltaPhi[cut], hs_El_ElDeltaEta[cut], hs_El_ElOneOverEminusOneOverP[cut], hs_El_ElTransMass[cut],
                                          hs_El_ElEthIso[cut], hs_El_ElTrkIso[cut], hs_El_ElEcalIso[cut], hs_El_ElHcalIso[cut],
                                          hs_El_ElHoverE[cut], hs_El_ElSigmaIetaIeta[cut], hs_El_ElNumberOfMissingInnerHits[cut]
                                          );
                                 } // conversions
                               } // isolation
                             } //delta phi
                           } //delta eta
                         } // 1/e-1/p                
                       }  // ECAL driven
                       
                     } // ETH endcap
                     
                     // now let's do the Robust one
                     

                     // --------------------------------------------------------------------------------------------------------------------
                     // Fill the N-1 plots
                     // --------------------------------------------------------------------------------------------------------------------
                     
                     // ETH

                     // delta phi plot
                     // barrel deltaPhi

                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaPhi", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
                        fabs(ElEta[i])<etaBarrelMax) {
                       hn1_El_ElDeltaPhi[0]->Fill(fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection));
                     }
                     // endcap
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaPhi", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) && 
                        fabs(ElEta[i])>etaBarrelMax && 
                        fabs(ElEta[i])<etaEndcapMax) {
                       hn1_El_ElDeltaPhi[1]->Fill(fabs(ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection));
                     }
                     // delta eta
                     // barrel
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaEta", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) && 
                        fabs(ElEta[i])<etaBarrelMax) {
                       hn1_El_ElDeltaEta[0]->Fill(fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection));
                     }
                     // endcap
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "deltaEta", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
                        fabs(ElEta[i])>etaBarrelMax &&
                        fabs(ElEta[i])<etaEndcapMax) {
                       hn1_El_ElDeltaEta[1]->Fill(fabs(ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection));
                     }
                     // 1/e-1/p
                     // barrel
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "oneOverEminusOneOverP", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
                        fabs(ElEta[i])<etaBarrelMax) {
                       hn1_El_ElOneOverEminusOneOverP[0]->Fill(fabs(1/ElCaloEnergy[i] - 1/ElTrkMomAtVtx[i]));
                     }
                     // endcap
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "oneOverEminusOneOverP", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
                        fabs(ElEta[i])>etaBarrelMax &&
                        fabs(ElEta[i])<etaEndcapMax) {
                       hn1_El_ElOneOverEminusOneOverP[1]->Fill(fabs(1/ElCaloEnergy[i] - 1/ElTrkMomAtVtx[i]));
                     }
                     // isolation
                     // barrel
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "iso", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
                        fabs(ElEta[i])<etaBarrelMax) {
                       hn1_El_ElEthIso[0]->Fill(ElDR04TkSumPt[i]/ ElCaloEnergy[i]);
                     }
                     // endcap
                     if(ethNminus1(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i], "iso", isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])) &&
                        fabs(ElEta[i])>etaBarrelMax &&
                        fabs(ElEta[i])<etaEndcapMax) {
                       hn1_El_ElEthIso[1]->Fill(ElDR04TkSumPt[i]/ ElCaloEnergy[i]);
                     }
                     //--------------------------------------------------------------------------------------------------------------------
                     

                     } //HLT_Photon10 trigger
                 }// pt
               } // delta eta
             } // delta phi
           } // H/E
           } // acceptance region


           //--------------------------------------------------------------------------------------------------------------------
           //--------------------------------------------------------------------------------------------------------------------
           // new code with WPelectronID function
           //--------------------------------------------------------------------------------------------------------------------
           //--------------------------------------------------------------------------------------------------------------------
           
           int cut;
           double Pt=ElPt[i] * PtCorrection;
           double Eta=ElEta[i];
           double Phi=ElPhi[i];
           double Charge=ElCharge[i];
           double delPhi=ElDeltaPhiSuperClusterAtVtx[i]-dphiCorrections(ElEta[i], ElPhi[i]);
           double delEta=ElDeltaEtaSuperClusterAtVtx[i]-detaCorrections(ElEta[i], ElPhi[i]);
           double transMass=transverseMass(ElPt[i] * PtCorrection, PFMET, deltaPhi(ElPhi[i],metPhi));
           double Hoe=ElHcalOverEcal[i];
           double trkIso  = ElDR03TkSumPt[i];
           double ecalIso = ElDR03EcalRecHitSumEt[i];
           double hcalIso = ElDR03HcalTowerSumEt[i];
           double combIso_B=(trkIso + max(0., ecalIso - 1.) + hcalIso) / ( ElPt[i] * PtCorrection);
           double combIso_E=(trkIso + ecalIso + hcalIso) / (ElPt[i] * PtCorrection);
           double See=ElSigmaIetaIeta[i];
           double missingHits=ElNumberOfMissingInnerHits[i];
           
           
           // check if trigger fired
           int Photon10 = getHLTtriggerBit("HLT_Photon10_L1R");
           int Photon15 = getHLTtriggerBit("HLT_Photon15_L1R");
//         int bit = getHLTtriggerBit("HLT_Photon10_Cleaned_L1R");
           int Ele15 = getHLTtriggerBit("HLT_Ele15_LW_L1R");

           if(HLTResults[Photon10]!=1 && HLTResults[Photon15]!=1 && HLTResults[Ele15]!=1) continue;
             

           if(Event==27837545 || Event==73939173 || Event==15512525 || Event==191815699 || Event==29377895 || Event==29377895 || Event==74868952 || Event==76643965 || Event==62016483 || Event==4352136) {
             cout<<"##################################"<<endl;
             cout<<"Event: "<<Event<<" Run: "<<Run<<endl;
             cout<<"Preselection: "<<ElectronPreselection(i)<<endl;
             cout<<"Selection: "<<WPElectronID(i, all, WorkingPointCuts)<<endl;


             cout<<"##################################"<<endl;

           }

           // check if electron is preselected
           if(ElectronPreselection(i)!=0) continue;
           

//         cout<<"acc: "<<accEta<<endl;
//         cout<<"eta: "<<ElEta[i]<<endl;
//         cout<<"SC: "<<ElSCEta[i]<<endl;
           
           // the N-1 plots
           if(fabs(accEta)<etaBarrelMax) {
             if(WPElectronID(i, see, WorkingPointCuts)==0)  hn1_El_ElSigmaIetaIeta[2]->Fill(See);
             if(WPElectronID(i, dphi, WorkingPointCuts)==0) hn1_El_ElDeltaPhi[2]->Fill(delPhi);
             if(WPElectronID(i, deta, WorkingPointCuts)==0) hn1_El_ElDeltaEta[2]->Fill(delEta);
             if(WPElectronID(i, hoe, WorkingPointCuts)==0)  hn1_El_ElHoverE[2]->Fill(Hoe);
             if(WPElectronID(i, combiso, WorkingPointCuts)==0)    hn1_El_ElCombIso[2]->Fill(combIso_B);
             if(WPElectronID(i, conversion, WorkingPointCuts)==0) hn1_El_ElNumberOfMissingInnerHits[2]->Fill(missingHits);
           }
           if(fabs(accEta)>etaEndcapMin && fabs(accEta)<etaEndcapMax) {
             if(WPElectronID(i, see, WorkingPointCuts)==0)  hn1_El_ElSigmaIetaIeta[3]->Fill(See);
             if(WPElectronID(i, dphi, WorkingPointCuts)==0) hn1_El_ElDeltaPhi[3]->Fill(delPhi);
             if(WPElectronID(i, deta, WorkingPointCuts)==0) hn1_El_ElDeltaEta[3]->Fill(delEta);
             if(WPElectronID(i, hoe, WorkingPointCuts)==0)  hn1_El_ElHoverE[3]->Fill(Hoe);
             if(WPElectronID(i, combiso, WorkingPointCuts)==0)    hn1_El_ElCombIso[3]->Fill(combIso_E);
             if(WPElectronID(i, conversion, WorkingPointCuts)==0) hn1_El_ElNumberOfMissingInnerHits[3]->Fill(missingHits);
           } 
           
           if(WPElectronID(i, all, WorkingPointCuts)==0) {
             // count the number of electrons in one event
             electronIndex.push_back(i);

             fprintf(out,"%i\t%i\n",Run, Event);
//           cout<<"Run: "<<Run<<" Event: "<<Event<<endl;

             // look at the charges of the IDed electrons
             int cGsf=ElCharge[i];
             int cSc=ElScPixCharge[i];

             if(cGsf==cSc) cNa++;
             else cNb++;

             // check the acceptance (etc.) variables
             h_ElEtaVsScEta->Fill(ElEta[i], ElSCEta[i]);
//           h_ElPhiVsScPhi->Fill(ElPhi[i], El);
             TVector3 track;
             track.SetXYZ(ElPx[i], ElPy[i], ElPz[i]);
             double trackEta=track.Eta();
             h_ElPtVsScEt->Fill(ElPt[i] * PtCorrection , ElCaloEnergy[i]/cosh(trackEta));


           }


           // the sequential counting and filling
           // preselection
           counter[0]++;
           // split in barrel and endcap
           if(fabs(accEta)<etaBarrelMax) {
             // preselected in barrel
             counter[1]++;
             //fillIt(i, 20);
             // fill the (right) histos
             cut=20;
             hs_El_ElPt[cut]->Fill(Pt);
             hs_El_ElEta[cut]->Fill(Eta);
             hs_El_ElPhi[cut]->Fill(Phi);
             hs_El_ElCharge[cut]->Fill(Charge);
             hs_El_ElDeltaPhi[cut]->Fill(delPhi);
             hs_El_ElDeltaEta[cut]->Fill(delEta);
             hs_El_ElTransMass[cut]->Fill(transMass);
             hs_El_ElHoverE[cut]->Fill(Hoe);
             hs_El_ElSigmaIetaIeta[cut]->Fill(See);
             hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
             hs_El_ElCombIso[cut]->Fill(combIso_B);
             // hs_El_ElMet[cut]
             // hs_El_ElOneOverEminusOneOverP[cut]
             // hs_El_ElEthIso[cut]
             // hs_El_ElTrkIso[cut]
             // hs_El_ElEcalIso[cut]
             // hs_El_ElHcalIso[cut]
             
             // after see cut
             if(WPElectronID(i, all, WorkingPointCuts)>1 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[2]++;
               cut=21;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_B);
             }
             
             // after dphi
             if(WPElectronID(i, all, WorkingPointCuts)>2 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[3]++;
               cut=22;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_B);
             }
             // after deta
             if(WPElectronID(i, all, WorkingPointCuts)>3 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[4]++;
               cut=23;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_B);
             }
             // after hoe
             if(WPElectronID(i, all, WorkingPointCuts)>4 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[5]++;
               cut=24;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_B);
             }
             // after iso
             if(WPElectronID(i, all, WorkingPointCuts)>5 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[6]++;
               cut=25;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_B);
             }
             // after conversion == total IDed
             if(WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[7]++;
               cut=26;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_B);
             }
           } //barrel
           if(fabs(accEta)>etaEndcapMin && fabs(accEta)<etaEndcapMax) {
             // preselected in endcaps
             counter[8]++;
             cut=27;
             hs_El_ElPt[cut]->Fill(Pt);
             hs_El_ElEta[cut]->Fill(Eta);
             hs_El_ElPhi[cut]->Fill(Phi);
             hs_El_ElCharge[cut]->Fill(Charge);
             hs_El_ElDeltaPhi[cut]->Fill(delPhi);
             hs_El_ElDeltaEta[cut]->Fill(delEta);
             hs_El_ElTransMass[cut]->Fill(transMass);
             hs_El_ElHoverE[cut]->Fill(Hoe);
             hs_El_ElSigmaIetaIeta[cut]->Fill(See);
             hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
             hs_El_ElCombIso[cut]->Fill(combIso_E);
                       
             // after see cut
             if(WPElectronID(i, all, WorkingPointCuts)>1 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[9]++;
               cut=28;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_E);
             }
             // after dphi
             if(WPElectronID(i, all, WorkingPointCuts)>2 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[10]++;
               cut=29;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_E);
             }
             // after deta
             if(WPElectronID(i, all, WorkingPointCuts)>3 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[11]++;
               cut=30;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_E);
             }
             // after hoe
             if(WPElectronID(i, all, WorkingPointCuts)>4 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[12]++;
               cut=31;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_E);
             }
             // after iso
             if(WPElectronID(i, all, WorkingPointCuts)>5 || WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[13]++;
               cut=32;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_E);
                       }
             // after conversion == total IDed
             if(WPElectronID(i, all, WorkingPointCuts)==0) {
               counter[14]++;
               cut=33;
               hs_El_ElPt[cut]->Fill(Pt);
               hs_El_ElEta[cut]->Fill(Eta);
               hs_El_ElPhi[cut]->Fill(Phi);
               hs_El_ElCharge[cut]->Fill(Charge);
               hs_El_ElDeltaPhi[cut]->Fill(delPhi);
               hs_El_ElDeltaEta[cut]->Fill(delEta);
               hs_El_ElTransMass[cut]->Fill(transMass);
               hs_El_ElHoverE[cut]->Fill(Hoe);
               hs_El_ElSigmaIetaIeta[cut]->Fill(See);
               hs_El_ElNumberOfMissingInnerHits[cut]->Fill(missingHits);
               hs_El_ElCombIso[cut]->Fill(combIso_E);
             }
           }  // endcaps
           

           //--------------------------------------------------------------------------------------------------------------------
           //--------------------------------------------------------------------------------------------------------------------
           //--------------------------------------------------------------------------------------------------------------------
           
           
           // ID the electrons 
           bool tightid=false;
           bool ethid=false;
           if(ElIDTight[i]==1) tightid=true;
           if(ethID(ElEcalDriven[i], ElDeltaPhiSuperClusterAtVtx[i] - dPhiCorrection, ElDeltaEtaSuperClusterAtVtx[i] - dEtaCorrection, ElCaloEnergy[i], ElTrkMomAtVtx[i], ElEta[i])==true) ethid=true;
           
           // check wether the elcetrons are in the barrel or the endcaps
           bool isbarrel=false;
           bool isendcap=false;
           if(fabs(ElEta[i])<etaMaxBarrel) isbarrel=true;
           if(fabs(ElEta[i])>etaMaxBarrel && fabs(ElEta[i])<etaMaxEndcap) isendcap=true;

           // Isolate the electrons
           double isolated=false;
           if(isolation(ElDR04TkSumPt[i], ElCaloEnergy[i])==true) isolated=true;
           
   
           // fill histos for tight ID
           
           if(tightid==true) {
             TLorentzVector vec;
             vec.SetPxPyPzE(ElPx[i],ElPy[i],ElPz[i],ElE[i]);
             electronsTight.push_back(vec);
             if(isolated==true) {
               electronsTightIsolated.push_back(vec);
             }
             
             // fill the myEvent
             if(vec.Pt()>ptMin) {
               tightElectrons.fourvector.push_back(vec);
               tightElectrons.charge.push_back(ElCharge[i]);
               if(isolated==true) tightElectrons.isolation.push_back(true);
               else if(isolated==false) tightElectrons.isolation.push_back(false);
             }
             
           }
           

         } // loop over all electrons in one event
         

         //--------------------------------------------------------------------------------------------------------------------
         // jet cleaning (new)
         //--------------------------------------------------------------------------------------------------------------------

         // the new number of jets is the size of the jetIndex vector
         // use that for jet veto...
         TLorentzVector electron;
         TLorentzVector jet;
         for(int j=0; j<NJets; j++) {
           if(JPt[j]<jetPtMin || fabs(JEta[j])>jetEtaMax) continue;
           jet.SetPxPyPzE(JPx[j],JPy[j],JPz[j],JE[j]);
           
           double deltaR=999; // have to calculate the minimal deltaR for EACH jet!
           for(int e=0;e<electronIndex.size();e++) {
             int index=electronIndex[e];
             electron.SetPtEtaPhiE(ElPt[index] * PtCorrection ,ElEta[index],ElPhi[index],ElE[index]);
             
             double dR=fabs(jet.DeltaR(electron));
             if(dR<deltaR) deltaR=dR;
//           cout<<"delta R: "<<deltaR<<endl;
           }
           if(deltaR<deltaRMax) continue;
           jetIndex.push_back(j);
         }


         //////////////////////
         // now check the ordering of the jets!
         //////////////////////


//       for(int ji=0; ji<jetIndex.size; ji++) {
           
//       }


         //--------------------------------------------------------------------------------------------------------------------


         //--------------------------------------------------------------------------------------------------------------------
         // Tag and Probe efficiency measurement
         //--------------------------------------------------------------------------------------------------------------------

         // an event gets tagged, if it consists of one IDed and isolated electron
         // AND a gsf candidate with pt>20 GeV in the fiducial region
         // AND the invariant mass is close to the Z mass
         
         bool isTagged=false;
         if(electronIndex.size()>0 && NEles>1) {
           for(int i=0; i<NEles; i++) {
             // should  also cut on the invariant mass !!!!!
             if(i==electronIndex[0] || ElPt[i]<20 || (fabs(ElEta[i])>1.44 && fabs(ElEta[i])<1.56 )|| fabs(ElEta[i])>2.5) continue;
             isTagged=true;
           }
         }
         // now the Z event is tagged
         if(isTagged==true) {
           // increment the various counters
           N_t0++;
           // check the event contains two IDed electrons
           if(electronIndex.size()==2) N_tt++;


         }

         
         //--------------------------------------------------------------------------------------------------------------------


         // --------------------------------------------------------------------------------------------------------------------
         // Z Selection (new)
         // --------------------------------------------------------------------------------------------------------------------
         if(electronIndex.size()==2) {
           // calculate the invariant mass
           double invMass;
           TLorentzVector e1, e2;
           e1.SetPtEtaPhiE(ElPt[electronIndex[0]] * PtCorrection ,ElEta[electronIndex[0]],ElPhi[electronIndex[0]],ElE[electronIndex[0]]);
           e2.SetPtEtaPhiE(ElPt[electronIndex[1]] * PtCorrection ,ElEta[electronIndex[1]],ElPhi[electronIndex[1]],ElE[electronIndex[1]]);
           invMass = (e1+e2).M();

           double summedJetPt;
           double summedJetEta;
           double summedJetPhi;
           double recoilPt;
           double recoilEta;
           double recoilPhi;

           // these variables are only defined if there really are jets...
           TLorentzVector jsum;
           if(jetIndex.size()>0) {
             for(int ji=0; ji<jetIndex.size(); ji++) {
               TLorentzVector vec;
               vec.SetPxPyPzE(JPx[ji], JPy[ji], JPz[ji], JE[ji]);
               jsum=jsum+vec;
             }
             summedJetPt = jsum.Pt();
             summedJetEta = jsum.Eta();
             summedJetPhi = jsum.Phi();
             // add also the Z
             jsum+=e1;
             jsum+=e2;
             recoilPt = jsum.Pt();
             recoilEta = jsum.Eta();
             recoilPhi = jsum.Phi();
           }

           fprintf(out_Z,"%i \t%i \t%i \t%f \t%f \t%f \t%f \t%f\n",Run, Event, LumiSection, invMass, ElPt[electronIndex[0]], ElPt[electronIndex[1]], (e1+e2).Pt(), summedJetPt);

           h_Z_invMass[0]->Fill(invMass);
           h_Z_ptAll[0]->Fill(ElPt[electronIndex[0]]);
           h_Z_ptAll[0]->Fill(ElPt[electronIndex[1]]);
           h_Z_etaAll[0]->Fill(ElEta[electronIndex[0]]);
           h_Z_etaAll[0]->Fill(ElEta[electronIndex[1]]);
           h_Z_phiAll[0]->Fill(ElPhi[electronIndex[0]]);
           h_Z_phiAll[0]->Fill(ElPhi[electronIndex[1]]);
           h_Z_deltaPhi[0]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
           h_Z_ptDiLepton[0]->Fill((e1+e2).Pt());
           h_Z_etaDiLepton[0]->Fill((e1+e2).Eta());
           h_Z_phiDiLepton[0]->Fill((e1+e2).Phi());

           // now variables with "jetty" content

           h_Z_nJets[0]->Fill(jetIndex.size());
           if(jetIndex.size()>0) {
             h_Z_leadingJetPt[0]->Fill(JPt[jetIndex[0]]);
             h_Z_leadingJetEta[0]->Fill(JEta[jetIndex[0]]);
             h_Z_leadingJetPhi[0]->Fill(JPhi[jetIndex[0]]);
             h_Z_summedJetPt[0]->Fill(summedJetPt);
             h_Z_summedJetEta[0]->Fill(summedJetEta);
             h_Z_summedJetPhi[0]->Fill(summedJetPhi);
             
             h_Z_leadingJetDeltaPt[0]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
             h_Z_leadingJetDeltaEta[0]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
             h_Z_leadingJetDeltaPhi[0]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
             h_Z_summedJetDeltaPt[0]->Fill(summedJetPt - (e1+e2).Pt());
             h_Z_summedJetDeltaEta[0]->Fill(summedJetEta - (e1+e2).Eta());
             h_Z_summedJetDeltaPhi[0]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
             
             h_Z_recoilPt[0]->Fill(recoilPt);
             h_Z_recoilEta[0]->Fill(recoilEta);
             h_Z_recoilPhi[0]->Fill(recoilPhi);
             h_Z_metPt[0]->Fill(met);
             //            h_Z_metEta[0]->Fill(metEta);
             h_Z_metPhi[0]->Fill(metPhi);
           }


           // check both in barrel
           if(fabs(ElEta[electronIndex[0]]) < etaBarrelMax && fabs(ElEta[electronIndex[1]]) < etaBarrelMax) {
           h_Z_invMass[1]->Fill(invMass);

           h_Z_ptAll[1]->Fill(ElPt[electronIndex[0]]);
           h_Z_ptAll[1]->Fill(ElPt[electronIndex[1]]);
           h_Z_etaAll[1]->Fill(ElEta[electronIndex[0]]);
           h_Z_etaAll[1]->Fill(ElEta[electronIndex[1]]);
           h_Z_phiAll[1]->Fill(ElPhi[electronIndex[0]]);
           h_Z_phiAll[1]->Fill(ElPhi[electronIndex[1]]);
           h_Z_deltaPhi[1]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
           h_Z_ptDiLepton[1]->Fill((e1+e2).Pt());
           h_Z_etaDiLepton[1]->Fill((e1+e2).Eta());
           h_Z_phiDiLepton[1]->Fill((e1+e2).Phi());

           // now variables with "jetty" content
           h_Z_nJets[1]->Fill(jetIndex.size());
           if(jetIndex.size()>0) {
             h_Z_leadingJetPt[1]->Fill(JPt[jetIndex[0]]);
             h_Z_leadingJetEta[1]->Fill(JEta[jetIndex[0]]);
             h_Z_leadingJetPhi[1]->Fill(JPhi[jetIndex[0]]);
             h_Z_summedJetPt[1]->Fill(summedJetPt);
             h_Z_summedJetEta[1]->Fill(summedJetEta);
             h_Z_summedJetPhi[1]->Fill(summedJetPhi);
             
             h_Z_leadingJetDeltaPt[1]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
             h_Z_leadingJetDeltaEta[1]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
             h_Z_leadingJetDeltaPhi[1]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
             h_Z_summedJetDeltaPt[1]->Fill(summedJetPt - (e1+e2).Pt());
             h_Z_summedJetDeltaEta[1]->Fill(summedJetEta - (e1+e2).Eta());
             h_Z_summedJetDeltaPhi[1]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
             
             h_Z_recoilPt[1]->Fill(recoilPt);
             h_Z_recoilEta[1]->Fill(recoilEta);
             h_Z_recoilPhi[1]->Fill(recoilPhi);
             h_Z_metPt[1]->Fill(met);
             //            h_Z_metEta[1]->Fill(metEta);
             h_Z_metPhi[1]->Fill(metPhi);
           }


           }
           // check both in endcaps
           if(fabs(ElEta[electronIndex[0]]) > etaBarrelMax && fabs(ElEta[electronIndex[1]]) > etaBarrelMax) {
           h_Z_invMass[2]->Fill(invMass);

           h_Z_ptAll[2]->Fill(ElPt[electronIndex[0]]);
           h_Z_ptAll[2]->Fill(ElPt[electronIndex[1]]);
           h_Z_etaAll[2]->Fill(ElEta[electronIndex[0]]);
           h_Z_etaAll[2]->Fill(ElEta[electronIndex[1]]);
           h_Z_phiAll[2]->Fill(ElPhi[electronIndex[0]]);
           h_Z_phiAll[2]->Fill(ElPhi[electronIndex[1]]);
           h_Z_deltaPhi[2]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
           h_Z_ptDiLepton[2]->Fill((e1+e2).Pt());
           h_Z_etaDiLepton[2]->Fill((e1+e2).Eta());
           h_Z_phiDiLepton[2]->Fill((e1+e2).Phi());

           // now variables with "jetty" content
           h_Z_nJets[2]->Fill(jetIndex.size());
           if(jetIndex.size()>0) {
             h_Z_leadingJetPt[2]->Fill(JPt[jetIndex[0]]);
             h_Z_leadingJetEta[2]->Fill(JEta[jetIndex[0]]);
             h_Z_leadingJetPhi[2]->Fill(JPhi[jetIndex[0]]);
             h_Z_summedJetPt[2]->Fill(summedJetPt);
             h_Z_summedJetEta[2]->Fill(summedJetEta);
             h_Z_summedJetPhi[2]->Fill(summedJetPhi);
             
             h_Z_leadingJetDeltaPt[2]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
             h_Z_leadingJetDeltaEta[2]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
             h_Z_leadingJetDeltaPhi[2]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
             h_Z_summedJetDeltaPt[2]->Fill(summedJetPt - (e1+e2).Pt());
             h_Z_summedJetDeltaEta[2]->Fill(summedJetEta - (e1+e2).Eta());
             h_Z_summedJetDeltaPhi[2]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
             
             h_Z_recoilPt[2]->Fill(recoilPt);
             h_Z_recoilEta[2]->Fill(recoilEta);
             h_Z_recoilPhi[2]->Fill(recoilPhi);
             h_Z_metPt[2]->Fill(met);
             //            h_Z_metEta[2]->Fill(metEta);
             h_Z_metPhi[2]->Fill(metPhi);
           }

           }
           // check one in barrel the other in endcap
           if((fabs(ElEta[electronIndex[0]]) < etaBarrelMax && fabs(ElEta[electronIndex[1]]) > etaBarrelMax) ||
              (fabs(ElEta[electronIndex[1]]) < etaBarrelMax && fabs(ElEta[electronIndex[0]]) > etaBarrelMax) ) {
           h_Z_invMass[3]->Fill(invMass);

           h_Z_ptAll[3]->Fill(ElPt[electronIndex[0]]);
           h_Z_ptAll[3]->Fill(ElPt[electronIndex[1]]);
           h_Z_etaAll[3]->Fill(ElEta[electronIndex[0]]);
           h_Z_etaAll[3]->Fill(ElEta[electronIndex[1]]);
           h_Z_phiAll[3]->Fill(ElPhi[electronIndex[0]]);
           h_Z_phiAll[3]->Fill(ElPhi[electronIndex[1]]);
           h_Z_deltaPhi[3]->Fill(deltaPhi(ElPhi[electronIndex[0]], ElPhi[electronIndex[1]]));
           h_Z_ptDiLepton[3]->Fill((e1+e2).Pt());
           h_Z_etaDiLepton[3]->Fill((e1+e2).Eta());
           h_Z_phiDiLepton[3]->Fill((e1+e2).Phi());

           // now variables with "jetty" content
           h_Z_nJets[3]->Fill(jetIndex.size());
           if(jetIndex.size()>0) {
             h_Z_leadingJetPt[3]->Fill(JPt[jetIndex[0]]);
             h_Z_leadingJetEta[3]->Fill(JEta[jetIndex[0]]);
             h_Z_leadingJetPhi[3]->Fill(JPhi[jetIndex[0]]);
             h_Z_summedJetPt[3]->Fill(summedJetPt);
             h_Z_summedJetEta[3]->Fill(summedJetEta);
             h_Z_summedJetPhi[3]->Fill(summedJetPhi);
             
             h_Z_leadingJetDeltaPt[3]->Fill(JPt[jetIndex[0]] - (e1+e2).Pt());
             h_Z_leadingJetDeltaEta[3]->Fill(JEta[jetIndex[0]] - (e1+e2).Eta());
             h_Z_leadingJetDeltaPhi[3]->Fill(deltaPhi(JPhi[jetIndex[0]],(e1+e2).Phi()));
             h_Z_summedJetDeltaPt[3]->Fill(summedJetPt - (e1+e2).Pt());
             h_Z_summedJetDeltaEta[3]->Fill(summedJetEta - (e1+e2).Eta());
             h_Z_summedJetDeltaPhi[3]->Fill(deltaPhi(summedJetPhi, (e1+e2).Phi()));
             
             h_Z_recoilPt[3]->Fill(recoilPt);
             h_Z_recoilEta[3]->Fill(recoilEta);
             h_Z_recoilPhi[3]->Fill(recoilPhi);
             h_Z_metPt[3]->Fill(met);
             //            h_Z_metEta[3]->Fill(metEta);
             h_Z_metPhi[3]->Fill(metPhi);
           }
           }


           // debug++;
         }
         // --------------------------------------------------------------------------------------------------------------------

 
//       //--------------------------------------------------------------------------------------------------------------------
//       // jet cleaning (new)
//       //--------------------------------------------------------------------------------------------------------------------

//       // the new number of jets is the size of the jetIndex vector
//       // use that for jet veto...
//       TLorentzVector electron;
//       TLorentzVector jet;
//       double deltaR=999;
//       for(int j=0; j<NJets; j++) {
//         if(JPt[j]<jetPtMin || fabs(JEta[j])>jetEtaMax) continue;
//         jet.SetPxPyPzE(JPx[j],JPy[j],JPz[j],JE[j]);
           
//         for(int e=0;e<electronIndex.size();e++) {
//           int index=electronIndex[e];
//           electron.SetPtEtaPhiE(ElPt[index] * PtCorrection ,ElEta[index],ElPhi[index],ElE[index]);
             
             
//           deltaR=jet.DeltaR(electron);
// //        cout<<deltaR<<endl;
//         }
//         if(deltaR<deltaRMax) continue;
//         jetIndex.push_back(j);
//       }
         
//       //--------------------------------------------------------------------------------------------------------------------


         //--------------------------------------------------------------------------------------------------------------------
         // W selection (new)
         //--------------------------------------------------------------------------------------------------------------------
         if(electronIndex.size()==1) {


           int Wcut;
           double dphiMax=2.8;
           double delPhiMet=deltaPhi(ElPhi[electronIndex[0]], PFMETphi);
           double Mt=transverseMass(ElPt[electronIndex[0]] * PtCorrection, met, delPhiMet);
           double Pt=ElPt[electronIndex[0]] * PtCorrection;
           double Eta=ElEta[electronIndex[0]];
           double Phi=ElPhi[electronIndex[0]];
           double Charge=ElCharge[electronIndex[0]];
           int Njets=jetIndex.size();

           ///////////////////
           // plots for barrel
           ///////////////////


//         if(WSelection(electronIndex[0], full)==0) {
//           fprintf(out,"%i\t%i\n",Run, Event);
//           cout<<"Run: "<<Run<<" Event: "<<Event<<endl;
//         }


           if(fabs(ElEta[electronIndex[0]])<etaBarrelMax) {

             ///////////
             // N jets
             //////////

             // fill plots after preselection
             if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
               Wcounter[0]++;
               Wcut=0;
               hs_W_ElTransMass[Wcut]->Fill(Mt);
               hs_W_ElPt[Wcut]->Fill(Pt);
               hs_W_ElEta[Wcut]->Fill(Eta);
               //          hs_W_ElDeltaPhi[Wcut]->Fill();
               hs_W_ElMet[Wcut]->Fill(met);
               hs_W_ElCharge[Wcut]->Fill(Charge);
               hs_W_Njets[Wcut]->Fill(njets);
               hs_W_ElPhi[Wcut]->Fill(Phi);
             }

             // fill N-1 plots

             if(WSelection(electronIndex[0], misset)==0) {
               Wcut=1;
               hs_W_ElTransMass[Wcut]->Fill(Mt);
               hs_W_ElPt[Wcut]->Fill(Pt);
               hs_W_ElEta[Wcut]->Fill(Eta);
               //          hs_W_ElDeltaPhi[Wcut]->Fill();
               hs_W_ElMet[Wcut]->Fill(met);
               hs_W_ElCharge[Wcut]->Fill(Charge);
               hs_W_Njets[Wcut]->Fill(njets);
               hs_W_ElPhi[Wcut]->Fill(Phi);
             }
             if(WSelection(electronIndex[0], pt)==0) {
               Wcut=2;
               hs_W_ElTransMass[Wcut]->Fill(Mt);
               hs_W_ElPt[Wcut]->Fill(Pt);
               hs_W_ElEta[Wcut]->Fill(Eta);
               //          hs_W_ElDeltaPhi[Wcut]->Fill();
               hs_W_ElMet[Wcut]->Fill(met);
               hs_W_ElCharge[Wcut]->Fill(Charge);
               hs_W_Njets[Wcut]->Fill(njets);
               hs_W_ElPhi[Wcut]->Fill(Phi);
             }
             if(WSelection(electronIndex[0], mt)==0) {
               Wcut=3;
               hs_W_ElTransMass[Wcut]->Fill(Mt);
               hs_W_ElPt[Wcut]->Fill(Pt);
               hs_W_ElEta[Wcut]->Fill(Eta);
               //          hs_W_ElDeltaPhi[Wcut]->Fill();
               hs_W_ElMet[Wcut]->Fill(met);
               hs_W_ElCharge[Wcut]->Fill(Charge);
               hs_W_Njets[Wcut]->Fill(njets);
               hs_W_ElPhi[Wcut]->Fill(Phi);
             }
             if(WSelection(electronIndex[0], full)==0) {
               Wcounter[1]++;
               Wcut=4;
               hs_W_ElTransMass[Wcut]->Fill(Mt);
               hs_W_ElPt[Wcut]->Fill(Pt);
               hs_W_ElEta[Wcut]->Fill(Eta);
               //          hs_W_ElDeltaPhi[Wcut]->Fill();
               hs_W_ElMet[Wcut]->Fill(met);
               hs_W_ElCharge[Wcut]->Fill(Charge);
               hs_W_Njets[Wcut]->Fill(njets);
               hs_W_ElPhi[Wcut]->Fill(Phi);
               // split charge
               if(Charge==1) {
                 Wcounter[2]++;
                 Wcut=5 ;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               else if(Charge==-1) {
                 Wcounter[3]++;
                 Wcut=6 ;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               } // charge 
             }   // W selection
             

             ///////////
             // 0 jets
             //////////
             
             if(njets==0) {
               
               // fill plots after preselection
               if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
                 Wcounter[4]++;
                 Wcut=7;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               
               // fill N-1 plots
               
               if(WSelection(electronIndex[0], misset)==0) {
                 Wcut=8;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               if(WSelection(electronIndex[0], pt)==0) {
                 Wcut=9;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               if(WSelection(electronIndex[0], mt)==0) {
                 Wcut=10;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               if(WSelection(electronIndex[0], full)==0) {
                 Wcounter[5]++;
                 Wcut=11;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
                 
                 // split charge
                 if(Charge==1) {
                   Wcounter[6]++;
                   Wcut=12;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   //      hs_W_ElDeltaPhi[Wcut]->Fill();
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 }
                 else if(Charge==-1) {
                   Wcounter[7]++;
                   Wcut=13;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   //      hs_W_ElDeltaPhi[Wcut]->Fill();
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 }
               } // W selection
             } // 0 jets

             ///////////
             // 1 jet
             //////////
             
             if(njets==1) {
               
               // fill plots after preselection
               if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
                 Wcounter[8]++;
                 Wcut=14;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               
               // fill N-1 plots
               
               // leaving the delta phi Wcut
               double dphi = deltaPhi(ElPhi[electronIndex[0]], JPhi[jetIndex[0]]);
               if(WSelection(electronIndex[0], full)==0) {
                 Wcut=15;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }

               // now I have to apply the delta phi Wcut!
               
               if(fabs(dphi)<dphiMax) {

                 if(WSelection(electronIndex[0], misset)==0) {
                   Wcut=16;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 }
                 if(WSelection(electronIndex[0], pt)==0) {
                   Wcut=17;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 }
                 if(WSelection(electronIndex[0], mt)==0) {
                   Wcut=18;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 }
                 if(WSelection(electronIndex[0], full)==0) {
                   Wcounter[9]++;
                   Wcut=19;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                   // split charge
                   if(Charge==1) {
                     Wcounter[10]++;
                     Wcut=20;
                     hs_W_ElTransMass[Wcut]->Fill(Mt);
                     hs_W_ElPt[Wcut]->Fill(Pt);
                     hs_W_ElEta[Wcut]->Fill(Eta);
                     hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                     hs_W_ElMet[Wcut]->Fill(met);
                     hs_W_ElCharge[Wcut]->Fill(Charge);
                     hs_W_Njets[Wcut]->Fill(njets);
                     hs_W_ElPhi[Wcut]->Fill(Phi);
                   }
                   else if(Charge==-1) {
                     Wcounter[11]++;
                     Wcut=21;
                     hs_W_ElTransMass[Wcut]->Fill(Mt);
                     hs_W_ElPt[Wcut]->Fill(Pt);
                     hs_W_ElEta[Wcut]->Fill(Eta);
                     hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                     hs_W_ElMet[Wcut]->Fill(met);
                     hs_W_ElCharge[Wcut]->Fill(Charge);
                     hs_W_Njets[Wcut]->Fill(njets);
                     hs_W_ElPhi[Wcut]->Fill(Phi);
                   } // charge
                 } // W sel
               } // dphi Wcut
             } // 1 jet

             //////////
             // >1 jet
             //////////
             
             if(njets>1) {
               
               // fill plots after preselection
               if(WSelection(electronIndex[0], full)>1 || WSelection(electronIndex[0], full)==0) {
                 Wcounter[12]++;
                 Wcut=22;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               
               // fill N-1 plots
               
               if(WSelection(electronIndex[0], misset)==0) {
                 Wcut=23;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               if(WSelection(electronIndex[0], pt)==0) {
                 Wcut=24;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               if(WSelection(electronIndex[0], mt)==0) {
                 Wcut=25;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
               }
               if(WSelection(electronIndex[0], full)==0) {
                 Wcounter[13]++;
                 Wcut=26;
                 hs_W_ElTransMass[Wcut]->Fill(Mt);
                 hs_W_ElPt[Wcut]->Fill(Pt);
                 hs_W_ElEta[Wcut]->Fill(Eta);
                 //        hs_W_ElDeltaPhi[Wcut]->Fill();
                 hs_W_ElMet[Wcut]->Fill(met);
                 hs_W_ElCharge[Wcut]->Fill(Charge);
                 hs_W_Njets[Wcut]->Fill(njets);
                 hs_W_ElPhi[Wcut]->Fill(Phi);
                 // split charge
                 if(Charge==1) {
                   Wcounter[14]++;
                   Wcut=27;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 }
                 else if(Charge==-1) {
                   Wcounter[15]++;
                   Wcut=28;
                   hs_W_ElTransMass[Wcut]->Fill(Mt);
                   hs_W_ElPt[Wcut]->Fill(Pt);
                   hs_W_ElEta[Wcut]->Fill(Eta);
                   hs_W_ElDeltaPhi[Wcut]->Fill(dphi);
                   hs_W_ElMet[Wcut]->Fill(met);
                   hs_W_ElCharge[Wcut]->Fill(Charge);
                   hs_W_Njets[Wcut]->Fill(njets);
                   hs_W_ElPhi[Wcut]->Fill(Phi);
                 } //charge
               } // w sel
             } // > 1 jets

           } // barrel

           else if(fabs(ElEta[electronIndex[0]])>etaBarrelMax && fabs(ElEta[electronIndex[0]])<etaEndcapMax) {
             if(WSelection(electronIndex[0], pre)==0) {debug++; cout<<"W found"<<endl;}
//           cout<<"Run: "<<Run<<" Event: "<<Event<<endl;

           }
           
         }
         //--------------------------------------------------------------------------------------------------------------------
         
         
       ////////////////////////////////////////////////////////////////////
       ////////////////////// User's code ends here ///////////////////////
       ////////////////////////////////////////////////////////////////////
       
     } // End loop over events

 END:
   cerr<<"Program ended after "<<sampleSize<<" events ..."<<endl;
   

   for(int b=0;b<MAXWcounter;b++) {
     hc_W_counter->SetBinContent(b+1,Wcounter[b]);
   }
   for(int b=0;b<counterSize;b++) {
     hc_El_counter->SetBinContent(b+1,counter[b]);
   }
   

   fclose(out);
   fclose(out_Z);


   cout<<counterTight<<endl;
   cout<<counterETH<<endl;

   cout<<"Total number of robust electrons (sequential cuts): "<<c_robust_B/*+c_robust_E*/<<endl;
   cout<<"Total number of robust electrons (out of tree): "<<c_robust_tree<<endl;

   cout<<"# of electrons with cGsf == cSC: "<<cNa<<endl;
   cout<<"# of electrons with cGsf != cSC: "<<cNb<<endl;

   cout<<"N_t: "<<N_tt<<" N_t0: "<<N_t0<<endl;
   if(N_tt>0) {
     double effy = ((double) 2*N_tt/(N_t0+N_tt));
     cout<<"Electron ID efficiency (tag&probe): "<<effy<<endl;
   }
   else cout<<"No tag & probe available!"<<endl;
   cout<<"debug: "<<debug<<endl;

   for(int ci=0; ci<15; ci++) {
     cout<<ci<<": "<<counter[ci]<<endl;
   }


   delete [] counter;
   counter=NULL;
   delete [] Wcounter;
   Wcounter=NULL;

   //////////write histos 
   h_jetPt->Write();

   // acceptance plots
   h_ElEtaVsScEta->Write();
//    h_ElPhiVsScPhi->Write();
   h_ElPtVsScEt->Write();
   
   // sum barrel and endcap into general plots
   for(int a=34; a<MAXE; a++) {
     hs_El_ElPt[a]->Add(hs_El_ElPt[a-7]);
     hs_El_ElPt[a]->Add(hs_El_ElPt[a-14]);
     hs_El_ElEta[a]->Add(hs_El_ElEta[a-7]);
     hs_El_ElEta[a]->Add(hs_El_ElEta[a-14]);
     hs_El_ElPhi[a]->Add(hs_El_ElPhi[a-7]);
     hs_El_ElPhi[a]->Add(hs_El_ElPhi[a-14]);
     hs_El_ElCharge[a]->Add(hs_El_ElCharge[a-7]);
     hs_El_ElCharge[a]->Add(hs_El_ElCharge[a-14]);
     hs_El_ElDeltaPhi[a]->Add(hs_El_ElDeltaPhi[a-7]);
     hs_El_ElDeltaPhi[a]->Add(hs_El_ElDeltaPhi[a-14]);
     hs_El_ElDeltaEta[a]->Add(hs_El_ElDeltaEta[a-7]);
     hs_El_ElDeltaEta[a]->Add(hs_El_ElDeltaEta[a-14]);
     hs_El_ElTransMass[a]->Add(hs_El_ElTransMass[a-7]);
     hs_El_ElTransMass[a]->Add(hs_El_ElTransMass[a-14]);
     hs_El_ElHoverE[a]->Add(hs_El_ElHoverE[a-7]);
     hs_El_ElHoverE[a]->Add(hs_El_ElHoverE[a-14]);
     hs_El_ElSigmaIetaIeta[a]->Add(hs_El_ElSigmaIetaIeta[a-7]);
     hs_El_ElSigmaIetaIeta[a]->Add(hs_El_ElSigmaIetaIeta[a-14]);
     hs_El_ElNumberOfMissingInnerHits[a]->Add(hs_El_ElNumberOfMissingInnerHits[a-7]);
     hs_El_ElNumberOfMissingInnerHits[a]->Add(hs_El_ElNumberOfMissingInnerHits[a-14]);
     hs_El_ElCombIso[a]->Add(hs_El_ElCombIso[a-7]);
     hs_El_ElCombIso[a]->Add(hs_El_ElCombIso[a-14]);
   }


   // write the plots to the *.root file
   
   h_numberOfEvents->Write();

   if(writeIdPlots==true) {
     for(int i=0;i<MAXE;i++) {
       hs_El_ElPt[i]->Write();
       hs_El_ElEta[i]->Write();
       hs_El_ElPhi[i]->Write();
       hs_El_ElDeltaPhi[i]->Write();
       hs_El_ElMet[i]->Write();
       hs_El_ElTransMass[i]->Write();
       hs_El_ElCharge[i]->Write();
       hs_El_Njets[i]->Write();
       hs_El_ElDeltaPhi[i]->Write();
       hs_El_ElDeltaEta[i]->Write();
       hs_El_ElOneOverEminusOneOverP[i]->Write();
       hs_El_ElTransMass[i]->Write();
       hs_El_Njets[i]->Write();
       hs_El_ElEthIso[i]->Write();
       hs_El_ElTrkIso[i]->Write();
       hs_El_ElEcalIso[i]->Write();
       hs_El_ElHcalIso[i]->Write();
       hs_El_ElCombIso[i]->Write();
       hs_El_ElHoverE[i]->Write();
       hs_El_ElSigmaIetaIeta[i]->Write();
       hs_El_ElNumberOfMissingInnerHits[i]->Write();
     }
     hc_El_counter->Write();
   }


   if(writeN1Plots==true) {
     for(int i=0; i<MAXN; i++) {
       hn1_El_ElDeltaPhi[i]->Write();
       hn1_El_ElDeltaEta[i]->Write();
       hn1_El_ElOneOverEminusOneOverP[i]->Write();

//        hn1_El_ElPt[i]->Write();
//        hn1_El_ElEta[i]->Write();
//        hn1_El_ElPhi[i]->Write();
//        hn1_El_ElMet[i]->Write();
//        hn1_El_ElTransMass[i]->Write();
//        hn1_El_ElCharge[i]->Write();
//        hn1_El_Njets[i]->Write();
//        hn1_El_ElTransMass[i]->Write();
//        hn1_El_Njets[i]->Write();
       hn1_El_ElEthIso[i]->Write();
//        hn1_El_ElTrkIso[i]->Write();
//        hn1_El_ElEcalIso[i]->Write();
//        hn1_El_ElHcalIso[i]->Write();
       hn1_El_ElCombIso[i]->Write();
       hn1_El_ElHoverE[i]->Write();
       hn1_El_ElSigmaIetaIeta[i]->Write();
       hn1_El_ElNumberOfMissingInnerHits[i]->Write();
     }
   }
   if(writeWenuPlots) {
     for(int i=0;i<MAXS;i++) {
       hs_W_ElPt[i]->Write();
       hs_W_ElEta[i]->Write();
       hs_W_ElPhi[i]->Write();
       hs_W_ElDeltaPhi[i]->Write();
       hs_W_ElMet[i]->Write();
       hs_W_ElTransMass[i]->Write();
       hs_W_ElCharge[i]->Write();
       hs_W_Njets[i]->Write();
     }
     hc_W_counter->Write();
   }

   for(int i=0;i<MAXZ;i++) {
     h_Z_invMass[i]->Write();
     h_Z_ptAll[i]->Write();
     h_Z_etaAll[i]->Write();
     h_Z_phiAll[i]->Write();
     h_Z_deltaPhi[i]->Write();
     h_Z_ptDiLepton[i]->Write();
     h_Z_etaDiLepton[i]->Write();
     h_Z_phiDiLepton[i]->Write();

     h_Z_leadingJetPt[i]->Write();
     h_Z_summedJetPt[i]->Write();
     h_Z_leadingJetEta[i]->Write();
     h_Z_summedJetEta[i]->Write();
     h_Z_leadingJetPhi[i]->Write();
     h_Z_summedJetPhi[i]->Write();
     h_Z_nJets[i]->Write();
     h_Z_leadingJetDeltaPt[i]->Write();
     h_Z_leadingJetDeltaEta[i]->Write();
     h_Z_leadingJetDeltaPhi[i]->Write();
     h_Z_summedJetDeltaPt[i]->Write();
     h_Z_summedJetDeltaEta[i]->Write();
     h_Z_summedJetDeltaPhi[i]->Write();
     h_Z_recoilPt[i]->Write();
     h_Z_recoilEta[i]->Write();
     h_Z_recoilPhi[i]->Write();
     h_Z_metPt[i]->Write();
     h_Z_metEta[i]->Write();
     h_Z_metPhi[i]->Write();

   }
     std::cout << "analysisClass::Loop() ends" <<std::endl;   
}


Revision:	1.2
Committed:	Tue Jul 20 15:32:43 2010 UTC (14 years, 9 months ago) by jueugste
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1979 -1691 lines
Log Message:	many changes...