#include "EFTGenReader/EFTHelperUtilities/interface/WCPoint.h"
#include "EFTGenReader/EFTHelperUtilities/interface/WCFit.h"
#include "EFTGenReader/EFTHelperUtilities/interface/TH1EFT.h"
#include "EFTGenReader/EFTHelperUtilities/interface/TH2EFT.h"

#include <fstream>

//to sort the tuple in a descending order of the third element
bool sortbincontent(const tuple<int, int, double>&a, const tuple<int,int,double>&b)
{
        return(get<2>(a)>get<2>(b));
}

int findJetBin(TString category, int bin) {
    if (category.Contains("2lss")) {
        return bin+3;
    }
    else if (category.Contains("3l")) {
        return bin+1;
    }
    else if (category.Contains("4l")) {
        return bin;
    }
    return 0;
}

void printBins(TH1D *&h) {
    std::cout << h->GetName() << std::endl;
    for(int ibin = 1; ibin <= h->GetNbinsX(); ibin++) {
        std::cout << h->GetBinContent(ibin) << ", ";
    }
    std::cout << std::endl;
}

void plot2D(std::vector<TString> input_fnames, TString wc_string) {

    gStyle->SetOptStat(0);
    gStyle->SetPadRightMargin(0.2);
    gStyle->SetPaintTextFormat("4.2f");

    std::vector<TFile*> files;

    std::map<TString,TString> wcdict;
    wcdict["ctW"] = "$\\\\it{c}_{\\\\mathrm{tW}}$";
    wcdict["ctZ"] = "$\\\\it{c}_{\\\\mathrm{tZ}}$";
    wcdict["ctp"] = "$\\\\it{c}_{\\\\mathrm{t \\\\varphi}}$";
    wcdict["cpQM"] = "$\\\\it{c}^{-}_{\\\\mathrm{\\\\varphi Q}}$";
    wcdict["ctG"] = "$\\\\it{c}_{\\\\mathrm{tG}}$";
    wcdict["cbW"] = "$\\\\it{c}_{\\\\mathrm{bW}}$";
    wcdict["cpQ3"] = "$\\\\it{c}^{3(\\\\ell)}_{\\\\mathrm{\\\\varphi Q}}$";
    wcdict["cptb"] = "$\\\\it{c}_{\\\\mathrm{\\\\varphi tb}}$";
    wcdict["cpt"] = "$\\\\it{c}_{\\\\mathrm{\\\\varphi t}}$";
    wcdict["cQl3"] = "$\\\\it{c}^{3(\\\\ell)}_{\\\\mathrm{Q}\\\\ell}$";
    wcdict["cQlM"] = "$\\\\it{c}^{-(\\\\ell)}_{\\\\mathrm{Q}\\\\ell}$";
    wcdict["cQe"] = "$\\\\it{c}^{(\\\\ell)}_{\\\\mathrm{Qe}}$";
    wcdict["ctl"] = "$\\\\it{c}^{(\\\\ell)}_{\\\\mathrm{t}\\\\ell}$";
    wcdict["cte"] = "$\\\\it{c}^{(\\\\ell)}_{\\\\mathrm{te}}$";
    wcdict["ctlS"] = "$\\\\it{c}^{\\\\mathrm{S}(\\\\ell)}_{\\\\mathrm{t}}$";
    wcdict["ctlT"] = "$\\\\it{c}^{\\\\mathrm{T}(\\\\ell)}_{\\\\mathrm{t}}$";

    auto bkgFile = TFile::Open("/afs/crc.nd.edu/user/b/byates2/Public/anatest32_MergeLepFl.root");
    TH1D *l2ss_bkg = (TH1D*)bkgFile->Get("2lss_p_2b.data"); 
    TH1D *l3_1b_bkg = (TH1D*)bkgFile->Get("3l_mix_p_1b.data"); 
    TH1D *l3_2b_bkg = (TH1D*)bkgFile->Get("3l_mix_p_2b.data"); 
    TH1D *l3_sfz_1b_bkg = (TH1D*)bkgFile->Get("3l_mix_sfz_1b.data"); 
    TH1D *l3_sfz_2b_bkg = (TH1D*)bkgFile->Get("3l_mix_sfz_2b.data"); 
    TH1D *l4_bkg = (TH1D*)bkgFile->Get("4l_2b.data"); 
    l2ss_bkg->SetName("2lss_p_2b.bkg");
    l3_1b_bkg->SetName("3l_mix_p_1b.bkg");
    l3_2b_bkg->SetName("3l_mix_p_2b.bkg");
    l3_sfz_1b_bkg->SetName("3l_mix_sfz_1b.bkg");
    l3_sfz_2b_bkg->SetName("3l_mix_sfz_2b.bkg");
    l4_bkg->SetName("4l_2b.bkg");

    std::vector<TString> bkglep = {"2lss_p_2b", "2lss_m_2b", "3l_mix_p_1b", "3l_mix_m_1b", "3l_mix_p_2b", "3l_mix_m_2b", "3l_mix_sfz_1b", "3l_mix_sfz_2b", "4l_2b"};
    std::vector<TString> bkg    = {"WZ", "WWW", "charge_flips", "fakes", "ttGJets"};
    for(auto l : bkglep) {
        for(auto b : bkg) {
            auto histname = TString::Format("%s.%s", l.Data(), b.Data());
            auto tmp = (TH1D*)bkgFile->Get(histname);
            if(histname.Contains("2lss"))
                l2ss_bkg->Add((TH1D*)tmp->Clone());
            else if(histname.Contains("3l_mix_1b"))
                l3_1b_bkg->Add((TH1D*)tmp->Clone());
            else if(histname.Contains("3l_mix_2b"))
                l3_2b_bkg->Add((TH1D*)tmp->Clone());
            else if(histname.Contains("3l_mix_sfz_1b"))
                l3_sfz_1b_bkg->Add((TH1D*)tmp->Clone());
            else if(histname.Contains("3l_mix_sfz_2b"))
                l3_sfz_2b_bkg->Add((TH1D*)tmp->Clone());
            if(histname.Contains("4l"))
                l4_bkg->Add((TH1D*)tmp->Clone());
        }
    }

    // dump the bkg bin contents for inspection
    printBins(l2ss_bkg);
    printBins(l3_1b_bkg);
    printBins(l3_2b_bkg);
    printBins(l3_sfz_1b_bkg);
    printBins(l3_sfz_2b_bkg);
    printBins(l4_bkg);

    std::vector<TString> binlist;
    ofstream myfile;
    myfile.open ("wcs.tex", fstream::app);

    //std::cout << "Output File: " << output_fname << std::endl;
    for (auto s: input_fnames) {
        std::cout << "  Input File: " << s << std::endl;
        TFile* f = nullptr;
        if(s.Contains("_final_")) {
            f = TFile::Open(s, "UPDATE"); //modify the final root file
            std::cout << "appending!" << std::endl;
        }
        else
            f = TFile::Open(s);
        if (f) {
            //f->Print();
            files.push_back(f);
        }
        else
            std::cout << s << " not found!" << std::endl;
    }

    if (!files.size()) {
        return;
    }

    WCPoint *wc_pt = new WCPoint(wc_string.Data());
    auto regexp = TRegexp("[a-zA-Z]+3?i?_-?[0-9]+.[0-9]+");
    TString wc_string_single = TString("wcpoint_" + wc_string(regexp));
    WCPoint *wc_pt_single = new WCPoint(wc_string_single.Data());
    auto wc = TString(wc_pt_single->inputs.begin()->first.c_str());
    auto val = wc_pt_single->inputs.begin()->second;
    std::cout << TString::Format("%s=%0.2f", wc.Data(), val) << std::endl;
    WCPoint *sm_pt = new WCPoint("smpt");

    //std::vector<TString> leps = {"2lss", "3l", "4l"};
    std::vector<TString> leps = {"2lss", "3l", "3l_sfz", "4l"};
    std::vector<TString> hists = {"h_opAng_lep", "h_d_lep", "h_sum2_lep"};
    std::map<TString, double> xsec;
    xsec["ttHJet"] = 0.5085*(1-0.577);
    xsec["ttlnuJet"] = 0.2043;
    xsec["tHq4f"] = 0.0771;
    xsec["ttllNuNuJetNoHiggs"] = 0.2529;
    xsec["tllq4fNoSchanWNoHiggs0p"] = 0.0942;
    auto c = new TCanvas("c","c",1100,800);
    for(auto f : files) {
        std::vector<std::string> words;
        split_string(f->GetName(),words,"_");
        int index(-1);
        for(int i = 0; i < words.size(); i++) {
            if(TString(f->GetName()).Contains("_final_")) continue;
            if(words[i].compare(0,5,"HanV4") == 0) {
                index = i-1;
                break;
            }
        }
        TString fname("");
        if(index>=0) fname = TString::Format("output/output_process_%s_%s_EFT.root", words[index].c_str(), wc.Data());
        std::cout << fname << std::endl;
        std::cout << "Loading event sum" << std::endl;
        auto h_eventsumEFT = (TH1EFT*)f->Get("EFTGenHistsWithCuts/h_eventsumEFT");
        TFile *fout;
        if(!TString(f->GetName()).Contains("_final_")) {
            fout = new TFile(fname, "RECREATE");
            h_eventsumEFT->Write();
        }
        TDirectoryFile *EFTGenHistsWithCuts;
        if(!TString(f->GetName()).Contains("_final_")) {
            EFTGenHistsWithCuts = new TDirectoryFile("EFTGenHistsWithCuts", "EFTGenHistsWithCuts");
        }
        else EFTGenHistsWithCuts = (TDirectoryFile*)f->Get("EFTGenHistsWithCuts");
        EFTGenHistsWithCuts->cd();
        for(auto &lep : leps) {
            binlist.push_back("");
            std::cout << "Loading histograms" << std::endl;
            std::cout << TString::Format("EFTGenHistsWithCuts/h_%s_jetbjetEFT", lep.Data()) << std::endl;
            std::cout << TString::Format("EFTGenHistsWithCuts/h_%s_jetbjetSM", lep.Data()) << std::endl;
            auto h = (TH2EFT*)f->Get(TString::Format("EFTGenHistsWithCuts/h_%s_jetbjetEFT", lep.Data()));
            auto hsm = (TH2D*)f->Get(TString::Format("EFTGenHistsWithCuts/h_%s_jetbjetSM", lep.Data()));
	    TH1D* h_evsp = new TH1D(Form("h_evsp_%s",lep.Data()),Form("h_evsp_%s",lep.Data()),40,0,40);
            if(!TString(f->GetName()).Contains("_final_")) {
                hsm->Scale(xsec[words[index]] * 41530. / h_eventsumEFT->GetBinFit(1).evalPoint(sm_pt));
                std::cout << "Found " << hsm->Integral() << " events" << std::endl;
                h->Scale(*wc_pt);
                h->Scale(xsec[words[index]] * 41530. / h_eventsumEFT->GetBinFit(1).evalPoint(sm_pt));
                h->Write();
                hsm->Write();

            }
            else {
                int nx=0, ny=0;
                double *x=nullptr, *y=nullptr;
                if(lep.Contains("2l")) {
                    nx=2;
                    ny=2;
                    x = new double[nx]{4,6};
                    //x = new double[nx]{4,5,6,7};
                    y = new double[ny]{1,2};
                }
                else if(lep.Contains("3l")) {
                    nx=4;
                    ny=2;
                    x = new double[nx]{2,3,4,5};
                    y = new double[ny]{1,2};
                }
                else if(lep.Contains("4l")) {
                    nx=3;
                    ny=2;
                    x = new double[nx]{2,3,4};
                    y = new double[ny]{1,2};
                }
                if(x!=nullptr && y!=nullptr) {
                    std::cout << "REBINNING!" << std::endl;
                    auto htmp = h->Rebin(nx-1, x, ny-1, y);
                    htmp->SetName(h->GetName());
                    htmp->SetTitle(h->GetTitle());
                    //delete h;
                    h = htmp;
                    //Rebin SM TH2D manually
                    auto hsmtmp = h->RebinSM(hsm, nx-1, x, ny-1, y);
                    /*
                    auto hsmtmp = new TH2D("hsmptmp", "hsmtmp", nx-1, x, ny-1, y);
                    for(int i = 0; i < hsm->GetNbinsX()+1; i++) {
                        for(int j = 0; j < hsm->GetNbinsY()+1; j++) {
                            int bin = hsm->FindBin(i, j);
                            double val = hsm->GetBinContent(bin);
                            double err = hsm->GetBinError(bin);
                            int newbin = hsmtmp->FindBin(i+0.5,j+0.5); 
                            double tmpval = hsmtmp->GetBinContent(newbin);
                            double tmperr = hsmtmp->GetBinError(newbin);
                            hsmtmp->SetBinContent(newbin, val + tmpval);
                            hsmtmp->SetBinError(newbin, sqrt(err*err + tmperr*tmperr));
                        }
                    }
                    //Overflow
                    int bin = hsm->FindBin(hsm->GetNbinsX()+1, hsm->GetNbinsY()+1);
                    double val = hsm->GetBinContent(bin);
                    double err = hsm->GetBinError(bin);
                    int newbin = hsmtmp->FindBin(hsmtmp->GetNbinsX()+1, hsm->GetNbinsY()+1);
                    double tmpval = hsmtmp->GetBinContent(newbin);
                    double tmperr = hsmtmp->GetBinError(newbin);
                    hsmtmp->SetBinContent(newbin, val + tmpval);
                    hsmtmp->SetBinError(newbin, sqrt(err*err + tmperr*tmperr));
                    hsmtmp->SetName(hsm->GetName());
                    hsmtmp->SetTitle(hsm->GetTitle());
                    //Underflow
                    bin = 0;
                    val = hsm->GetBinContent(bin);
                    err = hsm->GetBinError(bin);
                    newbin = 0;
                    tmpval = hsmtmp->GetBinContent(newbin);
                    tmperr = hsmtmp->GetBinError(newbin);
                    hsmtmp->SetBinContent(newbin, val + tmpval);
                    hsmtmp->SetBinError(newbin, sqrt(err*err + tmperr*tmperr));
                    */
                    //Swap out old with new
                    hsmtmp->SetName(hsm->GetName());
                    hsmtmp->SetTitle(hsm->GetTitle());
                    //delete hsm;
                    hsm = hsmtmp;
                }
                h->GetXaxis()->SetRangeUser(x[0], x[nx-1]+1);
                hsm->GetXaxis()->SetRangeUser(x[0], x[nx-1]+1);
                h->GetYaxis()->SetRangeUser(y[0], y[ny-1]+1);
                hsm->GetYaxis()->SetRangeUser(y[0], y[ny-1]+1);
                if(!lep.Contains("3l")) {
                h->GetYaxis()->SetRangeUser(y[1], y[ny-1]+1);
                hsm->GetYaxis()->SetRangeUser(y[1], y[ny-1]+1);
                }
                h->GetXaxis()->SetNdivisions(nx);
                hsm->GetXaxis()->SetNdivisions(nx);
                h->GetYaxis()->SetNdivisions(ny);
                hsm->GetYaxis()->SetNdivisions(ny);

                if(x == nullptr || y == nullptr) {
                    h->GetXaxis()->SetNdivisions(h->GetNbinsX()-1);
                    h->GetYaxis()->SetNdivisions(h->GetNbinsY()-1);
                }
            }
            if(TString(f->GetName()).Contains("_final_")) {
                if(lep.Contains("2l")) {
                    for(int ibin = 0; ibin <= l2ss_bkg->GetNbinsX(); ibin++) {
                        int bin = findJetBin("2lss", ibin);
                        double val = l2ss_bkg->GetBinContent(ibin);
                        h->Fill(bin,2,val);
                        hsm->Fill(bin,2,val);
                    }
                }
                else if(lep.Contains("3l_sfz")) {
                    for(int ibin = 0; ibin <= l3_sfz_1b_bkg->GetNbinsX(); ibin++) {
                        int bin = findJetBin("3l", ibin);
                        double val = l3_sfz_1b_bkg->GetBinContent(ibin);
                        h->Fill(bin,1,val);
                        hsm->Fill(bin,1,val);
                    }
                    for(int ibin = 0; ibin <= l3_sfz_2b_bkg->GetNbinsX(); ibin++) {
                        int bin = findJetBin("3l", ibin);
                        double val = l3_sfz_2b_bkg->GetBinContent(ibin);
                        h->Fill(bin,2,val);
                        hsm->Fill(bin,2,val);
                    }
                }
                else if(lep.Contains("3l")) {
                    for(int ibin = 0; ibin <= l3_1b_bkg->GetNbinsX(); ibin++) {
                        int bin = findJetBin("3l", ibin);
                        double val = l3_1b_bkg->GetBinContent(ibin);
                        h->Fill(bin,1,val);
                        hsm->Fill(bin,1,val);
                    }
                    for(int ibin = 0; ibin <= l3_2b_bkg->GetNbinsX(); ibin++) {
                        int bin = findJetBin("3l", ibin);
                        double val = l3_2b_bkg->GetBinContent(ibin);
                        h->Fill(bin,2,val);
                        hsm->Fill(bin,2,val);
                    }
                }
                else if(lep.Contains("4l")) {
                    for(int ibin = 0; ibin <= l4_bkg->GetNbinsX(); ibin++) {
                        int bin = findJetBin("4l", ibin);
                        double val = l4_bkg->GetBinContent(ibin);
                        h->Fill(bin,2,val);
                        hsm->Fill(bin,2,val);
                    }
                }
            }
            h->Draw("colz texte");
            auto s = TString(h->GetName());
            //if(!TString(f->GetName()).Contains("_final_")) s = s + words[index];
            s = s + ".png";
            c->Print(s,"png");
            c->Print(s.ReplaceAll("png","pdf"),"pdf");
            //int bval = 36;
            int bval = 4;
            std::cout << h->GetBinContent(bval) << " +/- " << h->GetBinError(bval) << std::endl;
            std::cout << hsm->GetBinContent(bval) << " +/- " << hsm->GetBinError(bval) << std::endl;
            if(TString(f->GetName()).Contains("_final_"))
              std::cout << "FoM integral=" << fabs(h->Integral() - hsm->Integral()) / sqrt(hsm->Integral()) << std::endl;
            h->NormalizeTo(hsm);
            std::cout << h->GetBinContent(bval) << " +/- " << h->GetBinError(bval) << std::endl;
            if(TString(f->GetName()).Contains("_final_")) {
                //Only save stat power in final version
                h->SetName(TString(h->GetName()) + "toSM");
                h->SetTitle(TString(h->GetName()));
                h->SetDirectory(f);
                std::cout << "writing h" << std::endl;
                h->Write();
            }
            h->SetTitle(TString::Format("%s=%0.2f", wc.Data(), val));
            //tex += TString::Format("\\begin{frame}\n\\frametitle{%s}\n", wc.Data());
            //tex += TString::Format("\\begin{frame}\n\\frametitle{%s %s}\n\\begin{columns}\n\\column{0.5\\textwidth}\n\\begin{figure}\n\\includegraphics[scale=0.14]{h_%s_jetbjetEFTtoSM_%s_low.png}\n\\end{figure}\n\\column{0.5\\textwidth}\n\\begin{figure}\n\\includegraphics[scale=0.14]{h_%s_jetbjetEFTtoSM_%s_high.png}\n\\end{figure}\n\\end{columns}\n\n\\begin{columns}\n\\column{0.5\\textwidth}\n\\begin{figure}\n\\includegraphics[scale=0.14]{h_%s_jetbjetEFTtoSM_%s_high.png}\n\\end{figure}\n\\column{0.5\\textwidth}\ntable goes here\n\\end{columns}\n\\end{frame}\n\n", wc.Data(), lep.Data(), lep.Data(), wc.Data(), lep.Data(), wc.Data(), lep.Data(), wc.Data()) ;
            if(TString(f->GetName()).Contains("_final_") && TString(f->GetName()).Contains("_low_"))
                myfile << TString::Format("\\begin{frame}\n\\frametitle{%s %s}\n\\begin{columns}\n\\column{0.5\\textwidth}\n\\begin{figure}\n\\includegraphics[scale=0.25]{h_%s_jetbjetEFTtoSM_%s_low}\n\\end{figure}\n\\column{0.5\\textwidth}\n\\begin{figure}\n\\includegraphics[scale=0.25]{h_%s_jetbjetEFTtoSM_%s_high}\n\\end{figure}\n\\end{columns}\n\n\\begin{columns}\n\\column{0.5\\textwidth}\n\\begin{figure}\n\\includegraphics[scale=0.25]{h_%s_evsp_%s}\n\\end{figure}\n\\column{0.25\\textwidth}\n\\Tiny\nLOW%d\n\\column{0.25\\textwidth}\n\\Tiny\nHIGH%d\n\\end{columns}\n\\end{frame}\n\n", wcdict[wc].Data(), lep.Data(), lep.Data(), wc.Data(), lep.Data(), wc.Data(), lep.Data(), wc.Data(), int(&lep - &leps[0]), int(&lep - &leps[0]));
            auto color = (TH2EFT*)h->Clone();
            for(int i = 0; i < color->GetNbinsX(); i++) {
                for(int j = 0; j < color->GetNbinsY(); j++) {
                    int bin = color->FindBin(i,j);
                    //if(bin == 58) std::cout << color->GetBinContent(bin) << " +/- " << color->GetBinError(bin) << std::endl;
                    color->SetBinContent(bin, abs(color->GetBinContent(bin)));
                    if(hsm->GetBinError(bin) / hsm->GetBinContent(bin) > 0.5) color->SetBinContent(bin, -10);
                    if(isnan(abs(h->GetBinContent(bin))) || isinf(abs(h->GetBinContent(bin)))) color->SetBinContent(bin, -10);
                }
            }
            color->SetMinimum(-1e-2);
            color->SetMaximum(5);
            color->Draw("colz");
            h->Draw("same texte");
            s = TString(h->GetName());
            s = s + ".png";
            //s.ReplaceAll("EFT", "EFTtoSM");
            //c->Print(s,"png");
            //c->Print(s.ReplaceAll("png","pdf"),"pdf");
            std::cout << h->GetName() << std::endl;
            c->Print(s,"png");
            c->Print(s.ReplaceAll("png","pdf"),"pdf");

	    //h_evsp part
	    std::vector <std::tuple<int,int,double> >bintuple;
            std::cout << f->GetName() << std::endl;
            //find first and last bins for x- and y-axes
            int xfirst = h->GetXaxis()->GetBinLowEdge(h->GetXaxis()->GetFirst());
            int xlast = h->GetXaxis()->GetBinUpEdge(h->GetXaxis()->GetLast());
            int yfirst = h->GetYaxis()->GetBinLowEdge(h->GetYaxis()->GetFirst());
            int ylast = h->GetYaxis()->GetBinUpEdge(h->GetYaxis()->GetLast());
            /*
            for(int i = 0; i < h->GetNbinsX(); i++) {
                for(int j = 0; j < h->GetNbinsY(); j++) {
            */
            for(int i = xfirst; i < xlast; i++) {
                for(int j = yfirst; j < ylast; j++) {
                    int binnum = h->FindBin(i,j);
                    if(binnum == 0) continue; //skip underflow
                    if(binnum == h->FindBin(100,100)) continue; //skip overflow (100,100) is clearly in the overflow
                    double bincontent = h->GetBinContent(binnum);
                    bincontent = abs(bincontent);
                    if(isnan(bincontent) || isinf(bincontent)) continue;
                    //std::cout << i << "," << j << "\t" << bincontent << std::endl;
                    //ignore bins where SM / sigma_sm > 50% (set to -10 in color histogram)
                    if(color->GetBinContent(binnum) > -10) {
		        bintuple.push_back(make_tuple(i,j,bincontent));
                        h_evsp->Fill(bincontent);
                    }
                }
            }
            if(TString(f->GetName()).Contains("_final_")) {
                h_evsp->GetXaxis()->SetRangeUser(0,41); //draw overflow bin
                std::cout << "writing h_evsp" << std::endl;
                std::cout << "writing h" << std::endl;
                h_evsp->Write();
		sort(bintuple.begin(),bintuple.end(),sortbincontent);
                int max = min((int)bintuple.size(), 10);
		for(int x = 0; x<max; x++){
		    binlist[&lep - &leps[0]] += TString::Format("(totalJet: %d, btaggedJet: %d), statpower: %0.2f\\\\\\\\ \\n", get<0>(bintuple[x]), + get<1>(bintuple[x]), get<2>(bintuple[x]));
		}
                if(TString(f->GetName()).Contains("_high_")) {
                    auto tmpname = TString(f->GetName());
                    tmpname.ReplaceAll("_high_", "_low_");
                    auto fintmp = TFile::Open(tmpname);
                    h_evsp->Add((TH1F*)fintmp->Get(TString::Format("EFTGenHistsWithCuts/h_evsp_%s", lep.Data()))->Clone());
                    fintmp->Close();
                    delete fintmp;
                    h_evsp->Draw();
                    c->Print(TString::Format("h_%s_evsp_%s.png", lep.Data(), wc.Data()),"png");
                    c->Print(TString::Format("h_%s_evsp_%s.pdf", lep.Data(), wc.Data()),"pdf");
                }
	    }
	    
            hsm->GetXaxis()->SetNdivisions(h->GetNbinsX());
            hsm->GetYaxis()->SetNdivisions(h->GetNbinsY());
            hsm->Draw("colz texte");
            s.ReplaceAll("EFTtoSM", "SM");
            c->Print(s,"png");
            c->Print(s.ReplaceAll("png","pdf"),"pdf");
        }

        /*
        for(auto it : hists) {
            std::cout << "Loading other hists" << std::endl;
            auto he = (TH1EFT*)f->Get(TString::Format("EFTGenHistsWithCuts/%sEFT", it.Data()));
            auto hs = (TH1D*)f->Get(TString::Format("EFTGenHistsWithCuts/%sSM", it.Data()));
            if(he == nullptr) break; //only exists in Brent's testing files
            if(!TString(f->GetName()).Contains("_final_")) {
                hs->Scale(xsec[words[index]] * 41530. / h_eventsumEFT->GetBinFit(1).evalPoint(sm_pt));
                he->Scale(*wc_pt);
                he->Scale(xsec[words[index]] * 41530. / h_eventsumEFT->GetBinFit(1).evalPoint(sm_pt));
            }
            double ks=he->KolmogorovTest(hs, "MN");
            he->SetTitle(TString::Format("%s=%0.2f KS=%0.3f", wc_pt->inputs.begin()->first.c_str(), wc_pt->inputs.begin()->second, ks));
            if(!TString(f->GetName()).Contains("_final_")) {
                he->Write();
                hs->Write();
            }
            he->Draw("hist");
            hs->Draw("same");
            TString s(TString::Format("%sEFT.png", it.Data()));
            c->Print(s,"png");
            c->Print(s.ReplaceAll("png","pdf"),"pdf");
            ks=he->KolmogorovTest(hs, "M");
            he->SetTitle(TString::Format("%s=%0.2f KS=%0.3f", wc_pt->inputs.begin()->first.c_str(), wc_pt->inputs.begin()->second, ks));
            he->DrawNormalized("hist");
            hs->DrawNormalized("same");
            s.ReplaceAll("EFT", "normEFT");
            c->Print(s,"pdf");
            c->Print(s.ReplaceAll("pdf","png"),"png");
        }
        */
        if(!TString(f->GetName()).Contains("_final_")) {
            fout->Close();
            delete fout;
        }
        std::cout << "Done with " << f->GetName() << std::endl;
        std::cout << "Closing " << f->GetName() << std::endl;
        f->Close();
    }
    if(files.size() != 1 || !TString(files[0]->GetName()).Contains("final")) {
        system(TString::Format("hadd -f output/output_final_%s_EFT.root output/output_process_*_%s_EFT.root", wc.Data(), wc.Data()));
    }
            //std::cout << std::endl << std::endl << tex << std::endl;
    myfile.close();
    for(int i = 0; i < leps.size(); i++) {
    if(TString(files[0]->GetName()).Contains("_high_"))
            gSystem->Exec(TString::Format("sed -i 's/HIGH%d/%s=%0.2f\\\\\\\\ \\n%s/g' wcs.tex ", i, wcdict[wc.Data()].Data(), val, binlist[i].Data()));
        else                                                             
            gSystem->Exec(TString::Format("sed -i 's/LOW%d/%s=%0.2f\\\\\\\\ \\n%s/g' wcs.tex ", i, wcdict[wc.Data()].Data(), val, binlist[i].Data()));
    }
    gSystem->Exec(TString::Format("sed -i 's/ \\([0-9]*\\)l/ \\1$\\\\ell$/g' wcs.tex"));
    gSystem->Exec(TString::Format("sed -i 's/$_sfz/$ $\\\\mathrm{Z}_{\\\\ell^{+}\\\\ell^{-}}$/g' wcs.tex"));
}