/////////////////////////////////////////////////////////////////////
//                                                                 //
//                  Here starts the USER's block                   //
//                                                                 //
//    USER has to go through the lines bellow and include input    //
//    root files, variables to be read and plotted, as well as     //
//    their X and Y axis ranges, labels, legends and colors.       //
//                                                                 //
//    USERS can also define the bin edges to compute the number    //
//    of entries per bin per input file per variable.              //
//                                                                 //
/////////////////////////////////////////////////////////////////////

// Set width and height of canvas.
// NOTE: It is safer to not touch in the canvas settup, unless you
//       know what you are doing.
Float_t canvas_ratio = 0.29; // right side percent of the pad not covered
Int_t wCanvas = 750;  // width
Int_t hCanvas = 600;  // height

// Would you like to apply a linear (0) or a log scale (1) to Y axis?
Int_t linear_log_scale = 1;

// Would you like to only pop up the plots, or to only save them, or to do both?
// In case of USER running in batch mode ('root -b' option), this code
// will automatically save plots in ".png" format.
// What do you like to do?
//   - Pop up only -> 0
//   - Save only -> 1
//   - Both (pop up and save) -> 2
Int_t pop_save = 1;

// If USER wants to save plots, tell what format:
// pdf? png? eps? root?
string output_file_format[] = {"png", "pdf", "root"};

// If USER wants to save plots, provide a commom name.
string output_file_name = "distribution_TP_ID_v5";

// Would you like to get the entries per bin per input file per variable?
// If "NO"  -> output_entries_per_bin = 0  || (macro will create plots only)
// If "YES" -> output_entries_per_bin = 1  || (macro will get entries only)
// If "YES" -> output_entries_per_bin > 1  || (macro will do both things: create plots and get entries)
Int_t output_entries_per_bin = 0;

// Would you like to scale MC samples from normalization in Z peak based on data / MC ration?
// If "NO"  -> 0
// If "YES" -> 1
Int_t normalize = 0;

// Distance between label and Y axis.
// NOTE: It is safer to not touch in the canvas settup, unless you
//       know what you are doing.
Float_t y_title_offset = 1.40;

// Set legend position
double xMinLegend = 0.72; // minimum x position of the legend
double yMinLegend = 0.35;  // minimum y position of the legend
double xMaxLegend = 0.99; // maximum x position of the legend
double yMaxLegend = 0.9;  // maximum y position of the legend

// Include bellow as many lines as you need to add ROOT files.
// First input ROOT file must have DATA events (root file 0).
// The code will create histogrms in stacks following the order
// of the input root files as they appear here: the histogram
// on the top corresponds to the input root file 1, while the
// histogram on the bottom corresponds to the last input root
// file entry bellow.
string input_files[] = {
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_SingleMuRun2012C_22Jan2013_v1.root",       // root file 0 (Data)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_20_withNVtxWeights.root",                // root file 1 (DY->MuMu M 20)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_120_withNVtxWeights.root",               // root file 2 (DY->MuMu M 120)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_200_withNVtxWeights.root",               // root file 3 (DY->MuMu M 200)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_500_withNVtxWeights.root",               // root file 4 (DY->MuMu M 500)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_800_withNVtxWeights.root",               // root file 5 (DY->MuMu M 800)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_1000_withNVtxWeights.root",              // root file 6 (DY->MuMu M 1000)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_1500_withNVtxWeights.root",              // root file 7 (DY->MuMu M 1500)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/tnpZ_M_2000_withNVtxWeights.root",              // root file 8 (DY->MuMu M 2000)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/DYToTauTau_M_20_withNVtxWeights.root",          // root file 9 (DY->TauTau M 20)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/ttbar_withNVtxWeights.root",                    // root file 10 (ttbar)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/T_tW_withNVtxWeights.root",                     // root file 11 (tW)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/Tbar_tW_withNVtxWeights.root",                  // root file 12 (tbarW)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/WW_withNVtxWeights.root",                       // root file 13 (WW)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/WZ_withNVtxWeights.root",                       // root file 14 (WZ)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/ZZ_withNVtxWeights.root",                       // root file 15 (ZZ)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/WJetsToLNu_withNVtxWeights.root",               // root file 16 (W+Jets->lnu)
  "dcap://osg-se.sprace.org.br:/pnfs/sprace.org.br/data/cms/store/user/adesouza/MuonPOG/HighMassDimuonEff_WithVertexReweighting_Dec_26_2013/QCD_Pt_20_MuEnrichedPt_15_withNVtxWeights.root" // root file 17 (Inclusive QCD)
};

// Write the weight of each input ROOT file.
// Of course, weight of DATA is "1.0".
double weight[] = {
  1.0,      // input file 0  (DATA)
  4.0989119,//    2.5756,   // input file 1  (DY->MuMu M 20)
  0.8787172,//    0.5522,   // input file 2  (DY->MuMu M 120)
  0.1097428,//    0.0690,   // input file 3  (DY->MuMu M 200)
  0.0032626,//    0.0021,   // input file 4  (DY->MuMu M 500)
  0.0004058,//    0.0003,   // input file 5  (DY->MuMu M 800)
  0.0001327,//    0.00008,  // input file 6  (DY->MuMu M 1000)
  0.0000126,//    0.000008, // input file 7  (DY->MuMu M 1500)
  0.0000016,//    0.000001, // input file 8  (DY->MuMu M 2000)
  4.0970485,//    2.5745,   // input file 9  (DY->TauTau M 20)
  0.0761073,//    0.0478,   // input file 10 (ttbar) // Verify with Cesar's results.
  0.1572465,//    0.0988,   // input file 11 (tW)
  0.1585843,//    0.0996,   // input file 12 (tbarW)
  0.0386323,//    0.0243,   // input file 13 (WW)
  0.0234053,//    0.0147,   // input file 14 (WZ)
  0.0126613,//    0.0080,   // input file 15 (ZZ)
  13.897167,//    8.7325,   // input file 16 (W+Jets->lnu)
  44.194163 //    27.7702   // input file 17 (Inclusive QCD)
  //    0.4290    // input file 18 (DY+Jets->LL M 50)
};


// Write the list of variables inside an array.
string list_of_variables[] = {
  "pair_newTuneP_probe_pt",
  "eta",
  "phi",
  "pair_newTuneP_mass",
  "tag_nVertices",
  "pair_deltaR",
  "tkIso/pair_newTuneP_probe_pt", // here is where we stopped by with older trees
  "combRelIsoPF04dBeta",
  "tag_combRelIsoPF04dBeta",
  "innertkSigmaPtOverPt",
  "tag_innertrackPtRelError",
  "NewTuneP_eta",
  "tag_NewTuneP_eta",
  "NewTuneP_phi",
  "tag_NewTuneP_phi",
  "NewTuneP_pt",
  "tag_NewTuneP_pt",
  "tag_MET",
  "pair_collinearity1",
  "pair_DimuonVtxProbePtAtTheVtx",
  "pair_DimuonVtxTagPtAtTheVtx",
  "pair_DimuonVtxProbePtBefore",
  "pair_DimuonVtxTagPtBefore",
  "pair_DimuonVtxZcoordinate",
  "pair_DimuonVtxRdistance",
  "pair_DimuonVtxRdistanceFromBS",
  "pair_DimuonVtxFitNormQui2",
  "pair_dz"
};


// USER has to tell what is the variable name related to the mass.
string mass_variable = "pair_newTuneP_mass";

// Write the selections on the mass with respect to each input ROOT file.
string mass_selection[] = {
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 0  (Data)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass <  120.0)", // root file 1  (DY->MuMu M 20)
  "(pair_newTuneP_mass >=  120.0) && (pair_newTuneP_mass <  200.0)", // root file 2  (DY->MuMu M 120)
  "(pair_newTuneP_mass >=  200.0) && (pair_newTuneP_mass <  500.0)", // root file 3  (DY->MuMu M 200)
  "(pair_newTuneP_mass >=  500.0) && (pair_newTuneP_mass <  800.0)", // root file 4  (DY->MuMu M 500)
  "(pair_newTuneP_mass >=  800.0) && (pair_newTuneP_mass < 1000.0)", // root file 5  (DY->MuMu M 800)
  "(pair_newTuneP_mass >= 1000.0) && (pair_newTuneP_mass < 1500.0)", // root file 6  (DY->MuMu M 1000)
  "(pair_newTuneP_mass >= 1500.0) && (pair_newTuneP_mass < 2000.0)", // root file 7  (DY->MuMu M 1500)
  "(pair_newTuneP_mass >= 2000.0)",                                  // root file 8  (DY->MuMu M 2000)
  "(pair_newTuneP_mass >=  20.0) && (pair_newTuneP_mass < 3000.0)", // root file 9  (DY->TauTau M 20)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 10 (ttbar)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 11 (tW)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 12 (tbarW)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 13 (WW)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 14 (WZ)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 15 (ZZ)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)", // root file 16 (W+Jets->lnu)
  "(pair_newTuneP_mass >=   0.0) && (pair_newTuneP_mass < 3000.0)"  // root file 17 (Inclusive QCD)
};


// Write the default event selections (with exception of mass).
string default_selection = "(eta >= -2.4) && (eta <= 2.4) && (charge != tag_charge) && \
(tag_NewTuneP_pt > 45.) && (pair_collinearity1 > 0.02) && (pair_dz >= -0.2) && (pair_dz <= 0.2) && \
(pair_DimuonVtxFitNormQui2 < 10.)";

// Number of bins, Y and X axis ranges and stylistic definitions from USER.
//
// If you want, you can also provide the histogram title and the Y and X
// axis labels for each variable. Labels are giving to each histogram
// corresponding to each input root file.
// Give also a different color to each histogram corresponding to each input
// root file.
// Order of numbers bellow has to follow order of the list of variables provided above.
int number_of_bins[] = {100, 50, 34, 100, 60, 100, 100,
			100, 100, 100, 100, 50, 50, 34,
			34, 100, 100, 100, 350, 100, 100,
			100, 100, 100, 100, 100, 100, 100};
//---------------------------------------------------------------
double x_minimum[] = {0., -2.5, -3.4, 0., 0., 0., 0.,
		      0., 0., 0., 0., -2.5, -2.5, -3.4,
		      -3.4, 0., 0., 0., 0., 0., 0.,
		      0., 0., -50., 0., 0., 0., -1.0};
//---------------------------------------------------------------
double x_maximum[] = {1000., 2.5, 3.4, 3000., 60., 6., 1.,
		      0.5, 0.15, 1.0, 0.12, 2.5, 2.5, 3.4,
		      3.4, 1000., 1000., 500., 3.5, 500., 500.,
		      500., 500., 50., 1., 1., 100., 1.0};
//---------------------------------------------------------------
double y_minimum[] = {50., 1000., 10000., 50., 0.005, 0.5, 500.,
		      1000., 1000., 100., 0.05, 1000., 1000., 10000.,
		      10000., 100., 0.5, 0.5, 10000., 0.5, 0.5,
		      0.5, 0.5, 0.5, 100., 0.001, 1., 0.1};
//---------------------------------------------------------------
double y_maximum[] = {10000000., 500000., 500000., 100000., 20000, 500000000., 200000000.,
		      10000000., 100000000., 10000000., 200000000., 500000., 500000., 500000.,
		      500000., 200000000., 500000., 500000., 500000000., 500000., 500000.,
		      500000., 500000., 500000., 500000., 5000000., 500000., 200000000.};
//---------------------------------------------------------------

// Provide label of X axis.
string x_axis_label[] = {
  "p_{T} #left[GeV/c#right]",
  "#eta",
  "#phi [rad]",
  "m_{#mu#mu} #left[GeV/c^{2}#right]",
  "Number of Vertices",
  "#Delta R (#mu,#mu)",
  "IsolationR03 SumPt/pt", // ===================================
  "combRelIsoPF04dBeta", //
  "tag_combRelIsoPF04dBeta", //
  "innertkSigmaPtOverPt",
  "tag_innertrackPtRelError",
  "NewTuneP_eta",
  "tag_NewTuneP_eta",
  "NewTuneP_phi",
  "tag_NewTuneP_phi",
  "NewTuneP_pt",
  "tag_NewTuneP_pt",
  "tag_MET",
  "pair_collinearity1",
  "pair_DimuonVtxProbePtAtTheVtx",
  "pair_DimuonVtxTagPtAtTheVtx",
  "pair_DimuonVtxProbePtBefore",
  "pair_DimuonVtxTagPtBefore",
  "pair_DimuonVtxZcoordinate",
  "pair_DimuonVtxRdistance",
  "pair_DimuonVtxRdistanceFromBS",
  "pair_DimuonVtxFitNormQui2",
  "pair_dz"
};

// Provide label of Y axis.
string y_axis_label[] ={
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events", //---------------------------------------
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events",
  "Events"
};

// Provide titles
string title_of_histogram[] = {"", "", "", "", "", "", "",
			       "", "", "", "", "", "", "",
			       "", "", "", "", "", "", "",
			       "", "", "", "", "", "", ""};

// Provide label of histograms concerning each input ROOT file
string label_of_histogram[] = {
  "Data-RunC, 7.05 fb^{-1}",   // root file 0  (Data)
  "DY #rightarrow #mu#mu, 20 < M(#mu#mu) <  120",   // root file 1  (DY->MuMu M 20)
  "DY #rightarrow #mu#mu, 120 < M(#mu#mu) <  200",  // root file 2  (DY->MuMu M 120)
  "DY #rightarrow #mu#mu, 200 < M(#mu#mu) <  500",  // root file 3  (DY->MuMu M 200)
  "DY #rightarrow #mu#mu, 500 < M(#mu#mu) <  800",  // root file 4  (DY->MuMu M 500)
  "DY #rightarrow #mu#mu, 800 < M(#mu#mu) < 1000",  // root file 5  (DY->MuMu M 800)
  "DY #rightarrow #mu#mu, 1000 < M(#mu#mu) < 1500", // root file 6  (DY->MuMu M 1000)
  "DY #rightarrow #mu#mu, 1500 < M(#mu#mu) < 2000", // root file 7  (DY->MuMu M 1500)
  "DY #rightarrow #mu#mu, M(#mu#mu) > 2000",        // root file 8  (DY->MuMu M 2000)
  "DY #rightarrow #tau#tau",                        // root file 9  (DY->TauTau M 20)
  "t#bar{t}",                                       // root file 10 (ttbar)
  "tW",                                             // root file 11 (tW)
  "#bar{t}W",                                       // root file 12 (tbarW)
  "WW",                                             // root file 13 (WW)
  "WZ",                                             // root file 14 (WZ)
  "ZZ",                                             // root file 15 (ZZ)
  "W+Jets #rightarrow l#nu",                        // root file 16 (W+Jets->lnu)
  "Inclusive QCD"                                   // root file 17 (Inclusive QCD)
};

// The first color number will be the color of the histograms correspondent to the first
// input ROOT file, while the last color number will be assigned to the last input file.
int color_of_histogram[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18};

// Write the binning for each variable:
//
double pt_bins[] = {45., 50., 55., 60., 65., 70., 75., 80., 85., 90., 140., 300., 500.};
double eta_bins[] = {-2.4, -2.1, -1.6, -1.2, -0.9, -0.6, -0.3, -0.2, 0.2, 0.3, 0.6, 0.9, 1.2, 1.6, 2.1, 2.4};
double phi_bins[] = {-3.0, -2.5, -2.0, -1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0};
double mass_bins[] = {60, 120, 200, 500, 800, 1000, 1500, 2000, 3000};
double vertex_bins[] = {0.5, 2.5, 4.5, 6.5, 8.5, 10.5, 12.5, 14.5, 16.5, 18.5, 20.5, 22.5, 24.5, 26.5, 28.5, 30.5};
double deltaR_bins[] = {0.0, 0.5, 0.75, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 6.0};
double probeIso_bins[] = {0.0, 0.005, 0.01, 0.015, 0.02, 0.025, 0.03, 0.035, 0.04, 0.045, 0.05, 0.055, 0.06, 0.065, 0.07, 0.075, 0.08, 0.085, 0.09, 0.095, 0.1, 0.105, 0.11};// ===================================================================
double combRelIsoPF04dBeta_bins[] = {0.0, 0.005, 0.01};
double tag_combRelIsoPF04dBeta_bins[] = {0.0, 0.005, 0.01};
double innertkSigmaPtOverPt_bins[] = {0.0, 0.005, 0.0};
double tag_innertrackPtRelError_bins[] = {0.0, 0.005, 0.01};
double NewTuneP_eta_bins[] = {0.0, 0.005, 0.01};
double tag_NewTuneP_eta_bins[] = {0.0, 0.005, 0.01};
double NewTuneP_phi_bins[] = {0.0, 0.005, 0.01};
double tag_NewTuneP_phi_bins[] = {0.0, 0.005, 0.01};
double NewTuneP_pt_bins[] = {0.0, 0.005, 0.01};
double tag_NewTuneP_pt_bins[] = {0.0, 0.005, 0.01};
double tag_MET_bins[] = {0.0, 0.005, 0.01};
double pair_collinearity1_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxProbePtAtTheVtx_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxTagPtAtTheVtx_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxProbePtBefore_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxTagPtBefore_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxZcoordinate_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxRdistance_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxRdistanceFromBS_bins[] = {0.0, 0.005, 0.01};
double pair_DimuonVtxFitNormQui2_bins[] = {0.0, 0.005, 0.01};
double pair_dz_bins[] = {0.0, 0.005, 0.01};


////////////////////////////////////////////////////////////////////
// Make sure the loops bellow correspond to the variables above.  //
////////////////////////////////////////////////////////////////////
void fill_bins (vector <vector <double> > &bin_edges) {
  Int_t total_number_of_variables = (sizeof(list_of_variables) / sizeof(string));
  bin_edges.resize(total_number_of_variables + 1);

  for ( Int_t i = 0; i < (sizeof(pt_bins) / sizeof(double)); i++ )
    bin_edges[0].push_back( pt_bins[i] );
  for ( Int_t i = 0; i < (sizeof(eta_bins) / sizeof(double)); i++ )
    bin_edges[1].push_back( eta_bins[i] );
  for ( Int_t i = 0; i < (sizeof(phi_bins) / sizeof(double)); i++ )
    bin_edges[2].push_back( phi_bins[i] );
  for ( Int_t i = 0; i < (sizeof(mass_bins) / sizeof(double)); i++ )
    bin_edges[3].push_back( mass_bins[i] );
  for ( Int_t i = 0; i < (sizeof(vertex_bins) / sizeof(double)); i++ )
    bin_edges[4].push_back( vertex_bins[i] );
  for ( Int_t i = 0; i < (sizeof(deltaR_bins) / sizeof(double)); i++ )
    bin_edges[5].push_back( deltaR_bins[i] );
  for ( Int_t i = 0; i < (sizeof(probeIso_bins) / sizeof(double)); i++ )
    bin_edges[6].push_back( probeIso_bins[i] );
  for ( Int_t i = 0; i < (sizeof(combRelIsoPF04dBeta_bins) / sizeof(double)); i++ )
    bin_edges[7].push_back( combRelIsoPF04dBeta_bins[i] );
  for ( Int_t i = 0; i < (sizeof(tag_combRelIsoPF04dBeta_bins) / sizeof(double)); i++ )
    bin_edges[8].push_back( tag_combRelIsoPF04dBeta_bins[i] );
  for ( Int_t i = 0; i < (sizeof(innertkSigmaPtOverPt_bins) / sizeof(double)); i++ )
    bin_edges[9].push_back( innertkSigmaPtOverPt_bins[i] );
  for ( Int_t i = 0; i < (sizeof(tag_innertrackPtRelError_bins) / sizeof(double)); i++ )
    bin_edges[10].push_back( tag_innertrackPtRelError_bins[i] );
  for ( Int_t i = 0; i < (sizeof(NewTuneP_eta_bins) / sizeof(double)); i++ )
    bin_edges[11].push_back( NewTuneP_eta_bins[i] );
  for ( Int_t i = 0; i < (sizeof(tag_NewTuneP_eta_bins) / sizeof(double)); i++ )
    bin_edges[12].push_back( tag_NewTuneP_eta_bins[i] );
  for ( Int_t i = 0; i < (sizeof(NewTuneP_phi_bins) / sizeof(double)); i++ )
    bin_edges[13].push_back( NewTuneP_phi_bins[i] );
  for ( Int_t i = 0; i < (sizeof(tag_NewTuneP_phi_bins) / sizeof(double)); i++ )
    bin_edges[14].push_back( tag_NewTuneP_phi_bins[i] );
  for ( Int_t i = 0; i < (sizeof(NewTuneP_pt_bins) / sizeof(double)); i++ )
    bin_edges[15].push_back( NewTuneP_pt_bins[i] );
  for ( Int_t i = 0; i < (sizeof(tag_NewTuneP_pt_bins) / sizeof(double)); i++ )
    bin_edges[16].push_back( tag_NewTuneP_pt_bins[i] );
  for ( Int_t i = 0; i < (sizeof(tag_MET_bins) / sizeof(double)); i++ )
    bin_edges[17].push_back( tag_MET_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_collinearity1_bins) / sizeof(double)); i++ )
    bin_edges[18].push_back( pair_collinearity1_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxProbePtAtTheVtx_bins) / sizeof(double)); i++ )
    bin_edges[19].push_back( pair_DimuonVtxProbePtAtTheVtx_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxTagPtAtTheVtx_bins) / sizeof(double)); i++ )
    bin_edges[20].push_back( pair_DimuonVtxTagPtAtTheVtx_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxProbePtBefore_bins) / sizeof(double)); i++ )
    bin_edges[21].push_back( pair_DimuonVtxProbePtBefore_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxTagPtBefore_bins) / sizeof(double)); i++ )
    bin_edges[22].push_back( pair_DimuonVtxTagPtBefore_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxZcoordinate_bins) / sizeof(double)); i++ )
    bin_edges[23].push_back( pair_DimuonVtxZcoordinate_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxRdistance_bins) / sizeof(double)); i++ )
    bin_edges[24].push_back( pair_DimuonVtxRdistance_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxRdistanceFromBS_bins) / sizeof(double)); i++ )
    bin_edges[25].push_back( pair_DimuonVtxRdistanceFromBS_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_DimuonVtxFitNormQui2_bins) / sizeof(double)); i++ )
    bin_edges[26].push_back( pair_DimuonVtxFitNormQui2_bins[i] );
  for ( Int_t i = 0; i < (sizeof(pair_dz_bins) / sizeof(double)); i++ )
    bin_edges[27].push_back( pair_dz_bins[i] );
}
/////////////////////////////////////////////////
/////////                            ////////////
/////////          End of File       ////////////
/////////                            ////////////
/////////////////////////////////////////////////