#include <iostream>
#include <fstream>
#include <cmath>

const int NPoints = 16;//16+8;
const int NHisto = 4;
/*
// int index[NPoints] =
// {
//   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,20,25,30,32,35,40,45,50
// };
// 
// float data[NPoints] =
// {
//   0.0362009,
//   0.0252392,
//   0.0174974,
//   0.0143904,
//   // 4
//   0.0112863,
//   0.011292,
//   0.0113725,
//   0.0108157,
// // 8
//   0.00999338,
//   0.0101452,
//   0.0111497,
//   0.0112426,
//   // 12
//   0.0105435,
//   0.0108844,
//   0.00994164,
//   0.00911458,
//   // 16
//   0.00964732,
//   0.00854952,
//   0.0083868,
//   0.00848147,
//   0.00811448,
//   0.00783045,
//   0.00710015,
//   0.00689926
// };*/

struct TDataPoint{
  int index;
  float data;
  TDataPoint(): index(0), data(0) {};
  TDataPoint( TDataPoint &a){ index = a.index; data = a.data; };
  TDataPoint(int _index, float _data): index(_index), data(_data) {};
};

// centr
/*
TDataPoint data0[NPoints] = // 1core = phys cores // 1ev/thr
{
  TDataPoint(1, 0.0561303),
  TDataPoint(2, 0.0601046),
  TDataPoint(3, 0.0397835),
  TDataPoint(4, 0.0344815),
  TDataPoint(5, 0.0294455),
  TDataPoint(6, 0.0276115),
  TDataPoint(7, 0.0238234),
  TDataPoint(8, 0.0218966),
  TDataPoint(9, 0.01901),
  TDataPoint(10, 0.0179896),
  TDataPoint(11, 0.0162583),
  TDataPoint(12, 0.013785),
  TDataPoint(13, 0.0145613),
  TDataPoint(14, 0.0132628),
  TDataPoint(15, 0.0123737),
  TDataPoint(16, 0.0125994)
};

TDataPoint data1[NPoints] = // 1core = phys cores // 10ev/thr
{
  TDataPoint(1, 0.0582196),
  TDataPoint(2, 0.0477268),
  TDataPoint(3, 0.0319807),
  TDataPoint(4, 0.0257612),
  TDataPoint(5, 0.0206433),
  TDataPoint(6, 0.0176917),
  TDataPoint(7, 0.0152651),
  TDataPoint(8, 0.0135654),
  TDataPoint(9, 0.0120879),
  TDataPoint(10, 0.0105484),
  TDataPoint(11, 0.00973949),
  TDataPoint(12, 0.00891792),
  TDataPoint(13, 0.00846039),
  TDataPoint(14, 0.00791938),
  TDataPoint(15, 0.00745795),
  TDataPoint(16, 0.00732309)
};

TDataPoint data2[NPoints] = // 1core = phys cores // 100ev/thr
{
  TDataPoint(1, 0.05793),
  TDataPoint(2, 0.0476666),
  TDataPoint(3, 0.0321942),
  TDataPoint(4, 0.0241627),
  TDataPoint(5, 0.0199271),
  TDataPoint(6, 0.0168075),
  TDataPoint(7, 0.0147901),
  TDataPoint(8, 0.0128561),
  TDataPoint(9, 0.0113564),
  TDataPoint(10, 0.0102382),
  TDataPoint(11, 0.00927394),
  TDataPoint(12, 0.00854277),
  TDataPoint(13, 0.00787669),
  TDataPoint(14, 0.00731296),
  TDataPoint(15, 0.00693072),
  TDataPoint(16, 0.00661578)
};
*/

//mbias
TDataPoint data3[NPoints] =  // 1000ev/thr
{
  TDataPoint(1, 0.00776257),
  TDataPoint(2, 0.00644313),
  TDataPoint(3, 0.00431873),
  TDataPoint(4, 0.00330728),
  TDataPoint(5, 0.00269595),
  TDataPoint(6, 0.00229054),
  TDataPoint(7, 0.00196418),
  TDataPoint(8, 0.0017434),
  TDataPoint(9, 0.00155634),
  TDataPoint(10, 0.00142086),
  TDataPoint(11, 0.00128552),
  TDataPoint(12, 0.0011833),
  TDataPoint(13, 0.00110066),
  TDataPoint(14, 0.00102241),
  TDataPoint(15, 0.000957783),
  TDataPoint(16, 0.000912)
};

TDataPoint data2[NPoints] =  // 100ev/thr
{
  TDataPoint(1, 0.00799267),
  TDataPoint(2, 0.00639808),
  TDataPoint(3, 0.00439172),
  TDataPoint(4, 0.00337255),
  TDataPoint(5, 0.00276511),
  TDataPoint(6, 0.00236984),
  TDataPoint(7, 0.00202815),
  TDataPoint(8, 0.00180852),
  TDataPoint(9, 0.00162748),
  TDataPoint(10, 0.00148024),
  TDataPoint(11, 0.00134809),
  TDataPoint(12, 0.00129656),
  TDataPoint(13, 0.00117713), // !
  TDataPoint(14, 0.0011343),
  TDataPoint(15, 0.00105125),
  TDataPoint(16, 0.00096978)
};

TDataPoint data1[NPoints] =  // 10ev/thr
{
  TDataPoint(1, 0.00761772),
  TDataPoint(2, 0.0075385),
  TDataPoint(3, 0.00513572),
  TDataPoint(4, 0.00435657),
  TDataPoint(5, 0.00368364),
  TDataPoint(6, 0.00332384),
  TDataPoint(7, 0.00276552),
  TDataPoint(8, 0.00263374),
  TDataPoint(9, 0.00232775),
  TDataPoint(10, 0.00202013),
  TDataPoint(11, 0.00188387),
  TDataPoint(12, 0.00177442),
  TDataPoint(13, 0.00162814),
  TDataPoint(14, 0.00159227),
  TDataPoint(15, 0.00146571),
  TDataPoint(16, 0.00147941)
};

TDataPoint data0[NPoints] =  // 1ev/thr
{
  TDataPoint(1, 0.00754364),
  TDataPoint(2, 0.00720395),
  TDataPoint(3, 0.00548803),
  TDataPoint(4, 0.00445202),
  TDataPoint(5, 0.00390443),
  TDataPoint(6, 0.00371762),
  TDataPoint(7, 0.00331914),
  TDataPoint(8, 0.00325565),
  TDataPoint(9, 0.00288376),
  TDataPoint(10, 0.00276598),
  TDataPoint(11, 0.00256765),
  TDataPoint(12, 0.0025588),
  TDataPoint(13, 0.00235227),
  TDataPoint(14, 0.00230429),
  TDataPoint(15, 0.00225103),
  TDataPoint(16, 0.00217405)
};

TDataPoint dataAll[NHisto][NPoints];

void MakeMultiHisto()
{

  for (int i = 0; i < NPoints; i++){
    dataAll[0][i] = data0[i];
  }
  for (int i = 0; i < NPoints; i++){
    dataAll[1][i] = data1[i];
  }
  for (int i = 0; i < NPoints; i++){
    dataAll[2][i] = data2[i];
  }
  for (int i = 0; i < NPoints; i++){
    dataAll[3][i] = data3[i];
  }
  
  TH1F *hAll[NHisto];
  int maxIndex = dataAll[0][NPoints-1].index;
  for (int iHisto = 0; iHisto < NHisto; iHisto++){
    TString name = "Histo";
    name += iHisto;
    hAll[iHisto] = new TH1F(name, name, maxIndex+1, -0.5, maxIndex+0.5);
    TH1F *h = hAll[iHisto];
    TDataPoint *data = &(dataAll[iHisto]);


    for (int i=0; i<NPoints; i+=1){
      data[i].data = (0 != data[i].data) ? 1./data[i].data : 10000.;
      h->SetBinContent(data[i].index+1,data[i].data);
      h->SetBinError(data[i].index+1,1.); // need for draw markers!
    }
    h->GetXaxis()->SetTitle("Number of logical cores");
    h->GetYaxis()->SetTitle("Events / s");
    h->GetYaxis()->SetTitleOffset(1.4);
    h->GetYaxis()->SetRangeUser(0,1200);
    h->GetYaxis()->SetTitleFont(22);
    h->GetXaxis()->SetTitleFont(22);
    h->GetYaxis()->SetLabelFont(22);
    h->GetXaxis()->SetLabelFont(22);
    h->SetLineColor(0);
    h->SetLineWidth(0);
//     h->SetMarkerStyle(21);
    h->SetMarkerSize(1.8);
//     h->SetMarkerColor(2);

    switch(iHisto){
      case 0: h->SetMarkerStyle(21); break;
      case 1: h->SetMarkerStyle(23); break;
      case 2: h->SetMarkerStyle(22); break;
      case 3: h->SetMarkerStyle(20); break;
      default:   h->SetMarkerStyle(20);
    }
    switch(iHisto){
      case 0: h->SetMarkerColor(kRed + 2); break;
      case 1: h->SetMarkerColor(kGreen + 2); break;
      case 2: h->SetMarkerColor(kBlue + 2); break;
      case 3: h->SetMarkerColor(kBlack); break;
      default: h->SetMarkerColor(kBlack);
    }
    
//     h->SetMarkerColor(100+2+iHisto);
  }

  gStyle->SetCanvasColor(10);
  gStyle->SetFrameFillColor(10);
  gStyle->SetTitleColor(0);
  gStyle->SetHistFillColor(0);
  gStyle->SetOptStat(00000000);
  gStyle->SetPadGridX(1);
  gStyle->SetPadGridY(1);
  gStyle->SetOptTitle(0);
  gStyle->SetTextFont(22);


  TCanvas *c1 = new TCanvas("ITBB", "ITBB", 700, 700);
  TLegend *leg1 = new TLegend(0.2-0.03,.62+0.05,0.55-0.03,.75+0.05);
  leg1->SetFillColor(0);
  leg1->SetLineWidth(0);
  leg1->SetBorderSize(0);
  leg1->SetTextFont(22);
//   leg1->SetTextSize(4);

  for (int i = 0; i < NHisto; i++){
    TH1F *h = hAll[i];

    if (i) h->Draw("same"); else h->Draw();

    leg1->AddEntry( hAll[NHisto-i-1],Form("10^{%i} Events/thread",NHisto-i-1) );
  }

  leg1->Draw();
}