plottingHelper.C

Go to the documentation of this file.

#include "plottingHelper.h"


namespace PlottingHelper {

using namespace std;

//Declaration of internal classes and structs

namespace {
// Struct specifying borders of some object which can be approximated by rectangles
// We use such approach to define position of histograms
struct Borders{
    vector<Rectangle> recs;
    void GetHistBorders(TH1 *h);
    void FromAbs2px(double scaleUp, double scaleDn);
    void FromNDC2px();
    static double Distance2(const Rectangle &r1, const Rectangle &r2);
};



//Contains internal methods for automatic placement of legends
struct PLACER {
    int nLeg;
    vector<unsigned> dims;
    vector<vector<pair<int,int>>> layOuts;
    vector<vector<double>> distToHists;

    vector<vector<Borders>> legBorders;
    vector<Borders> borders;

    vector<double> SizesX, SizesY;

    int nSteps = 11;
    double minSepar;

    void init(vector<TLegend *> legs, vector<double> &sizesX, vector<double> &sizesY);
    pair<double,vector<int> > iterate();
    void GetLegendsPositions();
    void GetDistancesPx(double scaleUp, double scaleDn);
    pair<double,double> GetSolution(vector<double> &xx, vector<double> &yy,
                                                         int nScaleSteps=10);
    void LoadHistoBorders(vector<Borders> &borders);
    double analyze(const vector<int> &indx, vector<double> &dists);

};

// Iterator which goes over all positions specified in the constructor
//
// Note that bitwise "or" operator | can be used to select more complex layout
struct PosIterator {
    PosIterator(int _nSteps, unsigned Pos) {
        pos = Pos;
        nSteps = _nSteps;
        last = nSteps-1;
        iSave = -1; jSave = nSteps;
        //Iterate();
    }
    bool Iterate();

    int nSteps, last;
    int iSave, jSave;
    unsigned pos;
};

}

//Don't search for lower distance if minSkip reach
static double MinDistanceSingle(vector<Borders> &bor, double minSkip, double x, double y, double w, double h);
static double MinDistanceSingle(vector<Borders> &bor, Borders bSingle, double minSkip);

//Don't search for lower distance if minSkip reach
static double MinDistance2(double minSkip, const Borders &br1, const Borders &br2);






TH1 *GetFrame()
{
   // get first histogram in the list of primitives

   TH1 *hobj = nullptr;

   TIter next(gPad->GetListOfPrimitives());
   TObject *obj;
   while ((obj = next())) {
      if(obj->InheritsFrom(TH1::Class())) {
         hobj = (TH1*)obj;
         //hobj->DrawCopy("sameaxis");
            break;
      }
      if(obj->InheritsFrom(TMultiGraph::Class())) {
         TMultiGraph *mg = (TMultiGraph*)obj;
            hobj = mg ? mg->GetHistogram() : nullptr;
            //if (hobj) hobj->DrawCopy("sameaxis");
            break;
      }
      if(obj->InheritsFrom(TGraph::Class())) {
         TGraph *g = (TGraph*)obj;
            hobj = g ? g->GetHistogram() : nullptr;
         //hobj->DrawCopy("sameaxis");
            break;
      }
      if(obj->InheritsFrom(THStack::Class())) {
         THStack *hs = (THStack*)obj;
            hobj = hs ? hs->GetHistogram() : nullptr;
            //hobj->DrawCopy("sameaxis");
            break;
      }
   }
    if(!hobj) {cerr << "No frame created in active pad" << endl;}

   return hobj;
}

TAxis *GetXaxis() {
    TH1 *frame = GetFrame();
    return frame ? frame->GetXaxis() : nullptr;
}

TAxis *GetYaxis() {
    TH1 *frame = GetFrame();
    return frame ? frame->GetYaxis() : nullptr;
}

TAxis *GetZaxis() {
    TH1 *frame = GetFrame();
    return frame ? frame->GetZaxis() : nullptr;
}  





double PxFontToRel(double px)
{
    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double pxW = gPad->GetWw()*gPad->GetAbsWNDC();

    if(pxW < pxH) return px/pxW;
             else return px/pxH;

    //double pad_width  = gPad->XtoPixel(gPad->GetX2());
    //double pad_height = gPad->YtoPixel(gPad->GetY1()); 
    //if(pxW < pxH) return px/pad_width / corX;
             //else return px/pad_height / corY;
}


double RelFontToPx(double rel)
{
    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double pxW = gPad->GetWw()*gPad->GetAbsWNDC();
    if(pxW < pxH) return rel*pxW;
             else return rel*pxH;
}


double GetAxisFractionX()
{
    //return (gPad->GetUxmax() - gPad->GetUxmin())/(gPad->GetX2() - gPad->GetX1());
    return (1. - gPad->GetLeftMargin() - gPad->GetRightMargin());
}

double GetAxisFractionY()
{
    //return (gPad->GetUymax() - gPad->GetUymin())/(gPad->GetY2() - gPad->GetY1());
    return (1. - gPad->GetBottomMargin() - gPad->GetTopMargin());
}

double TickAbsToRelX(double tick)
{
    double nom = GetAxisFractionX() * gPad->GetAbsHNDC() * gPad->GetWh();
    return tick/nom;
}


double TickAbsToRelY(double tick)
{
    double nom =  GetAxisFractionY() * gPad->GetAbsWNDC() * gPad->GetWw();
    return tick/nom;
}



void SetFonts(double pxX, double pxY, double pxT)
{
    TH1 *frame = GetFrame();
    if(!frame) return;

    if(pxY < 0) pxY = pxX;
    if(pxT < 0) pxT = pxX;

    double relSizeX = PxFontToRel(pxX);
    double relSizeY = PxFontToRel(pxY);
    double relSizeT = PxFontToRel(pxT);

    frame->GetXaxis()->SetTitleSize(relSizeX);
    frame->GetXaxis()->SetLabelSize(relSizeX);

    frame->GetYaxis()->SetTitleSize(relSizeY);
    frame->GetYaxis()->SetLabelSize(relSizeY);

    frame->SetTitleSize(relSizeT);
}

void SetTicks(double tickX, double tickY)
{
    TH1 *frame = GetFrame();
    if(!frame) return;

    //gPad->Update();
    if(tickY < 0) tickY = tickX;
    frame->GetXaxis()->SetTickSize(TickAbsToRelX(tickX) );
    frame->GetYaxis()->SetTickSize(TickAbsToRelY(tickY) );
}

void SetLabelOffsetX(double off)
{
    TH1 *frame = GetFrame();
    if(!frame) return;

    double labSize = frame->GetXaxis()->GetLabelSize();
    double off0 = 0;
    if(gPad->GetLogx()) {
        off0 = -1.15;
        if(frame->GetXaxis()->GetNoExponent()) off0 += 0.33;
    }
    else {
        off0 = -0.8;
    }

    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double fact = RelFontToPx(labSize)/pxH;
    off *= fact *3/4.; //conversion to "1354" height


    off += off0 * labSize;
    frame->GetXaxis()->SetLabelOffset(off);
}




void SetTitleOffsetX(double off)
{
    TH1 *frame = GetFrame();
    if(!frame) return;

    TAxis *ax = frame->GetXaxis();
    off *= 3/4.;
    ax->SetTitleOffset(off* RelFontToPx(ax->GetTitleSize())/1.6 / ( gPad->GetWh()* ax->GetTitleSize()*gPad->GetAbsHNDC() ) );
}

void SetLabelOffsetY(double off)
{
    TH1 *frame = GetFrame();
    if(!frame) return;
    TAxis *ax = frame->GetYaxis();
    double labSize = ax->GetLabelSize();
    double pxW =  gPad->GetWw() * gPad->GetAbsWNDC() ;
    double fact = RelFontToPx(labSize)/pxW;

    double off0 = 0;
    if(gPad->GetLogy())
        off0 = -0.08;


    off *= 3/4.;
    ax->SetLabelOffset(off *  fact + off0*labSize );
}

void SetTitleOffsetY(double off)
{
    TH1 *frame = GetFrame();
    if(!frame) return;
    TAxis *ax = frame->GetYaxis();
    off *= 3/4.;//to vertical size of "0"
    ax->SetTitleOffset( off*  RelFontToPx(ax->GetTitleSize())/1.6 / ( gPad->GetWw()*ax->GetTitleSize()* gPad->GetAbsWNDC() ) );
}

void SetFontsTicks(double px, double tickX, double tickY)
{
    SetFonts(px);
    SetTicks(tickX, tickY);
}

void SetOffsets(double lX, double tX, double lY, double tY)
{
    SetLabelOffsetX(lX);
    SetTitleOffsetX(tX);
    SetLabelOffsetY(lY);
    SetTitleOffsetY(tY);
}

void SetFTO(vector<double> fonts, vector<double> ticks, vector<double> offsets)
{
    fonts.resize(3, -1);
    ticks.resize(2, -1);
    offsets.resize(4, 0);

    SetFonts(fonts[0], fonts[1], fonts[2]);
    SetTicks(ticks[0], ticks[1]);
    SetOffsets(offsets[0], offsets[1], offsets[2], offsets[3]);
}





void DrawLatex(TVirtualPad *pad1, TVirtualPad *pad2, double x, double y, TString text, double fSize, TString style)
{
    TVirtualPad *padOrg = gPad;
    assert(pad1->GetCanvas() == pad2->GetCanvas());
    TCanvas *can = pad1->GetCanvas();

    //Setting of style
    TLatex *tex = new TLatex();

    int hAlign = 2;
    int vAlign = 2;

    double angle;
    if(style.Contains('>')) {
        if(style.Contains('l')) vAlign = 1;
        if(style.Contains('r')) vAlign = 3;
        if(style.Contains('b')) hAlign = 1;
        if(style.Contains('t')) hAlign = 3;
        angle = 90;
    }
    else if(style.Contains('<')) {
        if(style.Contains('l')) vAlign = 3;
        if(style.Contains('r')) vAlign = 1;
        if(style.Contains('b')) hAlign = 3;
        if(style.Contains('t')) hAlign = 1;
        angle = 270;
    }
    else if(style.Contains('^')) {
        if(style.Contains('l')) hAlign = 3;
        if(style.Contains('r')) hAlign = 1;
        if(style.Contains('b')) vAlign = 3;
        if(style.Contains('t')) vAlign = 1;
        angle = 180;
    }
    else {
        if(style.Contains('l')) hAlign = 1;
        if(style.Contains('r')) hAlign = 3;
        if(style.Contains('b')) vAlign = 1;
        if(style.Contains('t')) vAlign = 3;
        angle = 0;
    }

    tex->SetTextAlign(10*hAlign + vAlign);
    tex->SetTextAngle(angle);
    tex->SetTextFont(42);

    double l[2], r[2], b[2], t[2];

    TVirtualPad *pads[] = {pad1, pad2};

    for(int i = 0; i < 2; ++i) {
        l[i] = pads[i]->GetAbsXlowNDC() + pads[i]->GetAbsWNDC()*pads[i]->GetLeftMargin();
        r[i] = pads[i]->GetAbsXlowNDC() + pads[i]->GetAbsWNDC()*(1-pads[i]->GetRightMargin());
        b[i] = pads[i]->GetAbsYlowNDC() + pads[i]->GetAbsHNDC()*pads[i]->GetBottomMargin();
        t[i] = pads[i]->GetAbsYlowNDC() + pads[i]->GetAbsHNDC()*(1-pads[i]->GetTopMargin());
    }

    double left  = min(l[0], l[1]);
    double right = max(r[0], r[1]);
    double bottom= min(b[0], b[1]);
    double top   = max(t[0], t[1]);

    double xGlob = left   + (right-left) *x;
    double yGlob = bottom + (top-bottom) *y;


    auto isBtw = [](double low, double x, double high) {return low < x && x < high;};
    bool isInside = false;
    for(int i = 0; (i < 2 && pads[0] != pads[1]) || (i<1); ++i) {
        if(isBtw(l[i],xGlob,r[i]) && isBtw(b[i],yGlob,t[i]) ) {
            pads[i]->cd();
            if(fSize < 0) {
                TH1 *frame = GetFrame();
                fSize = frame ? RelFontToPx(frame->GetTitleSize()) : 12;
            }
            tex->SetTextSize(PxFontToRel(fSize));

            double xFactor = (r[i] - l[i]) / (right - left);
            double yFactor = (t[i] - b[i]) / (top - bottom);
            assert(x / xFactor < 1);
            assert(y / yFactor < 1);


            double xLoc = pads[i]->GetLeftMargin() + x/xFactor *
                           (1 - pads[i]->GetLeftMargin() - pads[i]->GetRightMargin());
            double yLoc = pads[i]->GetBottomMargin() + y/yFactor *
                           (1 - pads[i]->GetBottomMargin() - pads[i]->GetTopMargin());

            //TLine *l = new TLine();
            //l->SetLineColor(kRed);
            //l->DrawLineNDC(xLoc, yLoc, xLoc + 0.1, yLoc);
            tex->DrawLatexNDC(xLoc, yLoc, text);
            isInside = true;
        }
    }

    if(!isInside) {
        if(fSize < 0) {
            pads[0]->cd();
            TH1 *frame = GetFrame();
            fSize = frame ? RelFontToPx(frame->GetTitleSize()) : 12;
        }
        can->cd();
        tex->SetTextSize(PxFontToRel(fSize));
        tex->DrawLatexNDC(xGlob, yGlob, text);
    }

    gPad->Update();
    padOrg->cd();
}


void DrawLatex(TVirtualPad *pad, double x, double y, TString text, double fSize, TString style)
{
    DrawLatex(pad, pad, x, y, text, fSize, style);
}


void DrawLatex(double x, double y, TString text, double fSize, TString style)
{
    DrawLatex(gPad, x, y, text, fSize, style);
}


static void DrawLatexLRTB(TVirtualPad *pad1, TVirtualPad *pad2, double Offset, TString text, double fSize, TString style)
{
    TVirtualPad *padOrg = gPad;
    if(fSize < 0) {
        pad1->cd();
        TH1 *frame = GetFrame();
        fSize = frame ? RelFontToPx(frame->GetTitleSize()) : 12;
        padOrg->cd();
    }
    auto Close = [](double x, double val) {return abs(x-1000*val) <1000;};

    double x = 0.5, y = 0.5;


    double b[2], t[2], l[2], r[2];

    TVirtualPad *pads[] = {pad1, pad2};
    for(int i = 0; i < 2; ++i) {
        l[i] = pads[i]->GetAbsXlowNDC() + pads[i]->GetAbsWNDC()*pads[i]->GetLeftMargin();
        r[i] = pads[i]->GetAbsXlowNDC() + pads[i]->GetAbsWNDC()*(1-pads[i]->GetRightMargin());
        b[i] = pads[i]->GetAbsYlowNDC() + pads[i]->GetAbsHNDC()*pads[i]->GetBottomMargin();
        t[i] = pads[i]->GetAbsYlowNDC() + pads[i]->GetAbsHNDC()*(1-pads[i]->GetTopMargin());
    }

    double left  = min(l[0], l[1]);
    double right = max(r[0], r[1]);
    double bottom= min(b[0], b[1]);
    double top   = max(t[0], t[1]);

    if(Close(Offset,2) || Close(Offset, 8)) {
        if(style.Contains('l')) x = 0.0;
        if(style.Contains('r')) x = 1.0;
        double unit = (fSize * 3./4) / ( pad1->GetWh() * (top - bottom) );

        if(Close(Offset,2)) y = 1 + unit*(Offset - 2000);
        else                y = 0 - unit*(Offset - 8000);

    }
    else if(Close(Offset,4) || Close(Offset, 6)) {
        if(style.Contains('b')) y = 0.0;
        if(style.Contains('t')) y = 1.0;
        double unit = (fSize * 3./4) / ( pad1->GetWw() * (right - left) );

        if(Close(Offset,6)) x = 1 + unit*(Offset - 6000);
        else                x = 0 - unit*(Offset - 4000);
    }
    else
        assert(0);

    DrawLatex(pad1, pad2, x, y, text, fSize, style);
}

void DrawLatexUp(TVirtualPad *pad1, TVirtualPad *pad2, double Offset, TString text, double fSize, TString style) {
    DrawLatexLRTB(pad1, pad2, 2000 + Offset, text, fSize, style);
}

void DrawLatexDown(TVirtualPad *pad1,TVirtualPad *pad2, double Offset, TString text, double fSize, TString style) {
    DrawLatexLRTB(pad1, pad2, 8000 + Offset, text, fSize, style);
}

void DrawLatexRight(TVirtualPad *pad1, TVirtualPad *pad2, double Offset, TString text, double fSize, TString style) {
    DrawLatexLRTB(pad1, pad2, 6000 + Offset, text, fSize, style);
}

void DrawLatexLeft(TVirtualPad *pad1, TVirtualPad *pad2, double Offset, TString text, double fSize, TString style) {
    DrawLatexLRTB(pad1, pad2, 4000 + Offset, text, fSize, style);
}


void DrawLatexUp(TVirtualPad *pad, double Offset, TString text, double fSize, TString style) {
    DrawLatexUp(pad, pad, Offset, text, fSize, style);
}

void DrawLatexDown(TVirtualPad *pad, double Offset, TString text, double fSize, TString style) {
    DrawLatexDown(pad, pad, Offset, text, fSize, style);
}

void DrawLatexRight(TVirtualPad *pad, double Offset, TString text, double fSize, TString style) {
    DrawLatexRight(pad, pad, Offset, text, fSize, style);
}

void DrawLatexLeft(TVirtualPad *pad, double Offset, TString text, double fSize, TString style) {
    DrawLatexLeft(pad, pad, Offset, text, fSize, style);
}


void DrawLatexUp(double Offset, TString text, double fSize, TString style) {
    DrawLatexUp(gPad, Offset, text, fSize, style);
}
void DrawLatexDown(double Offset, TString text, double fSize, TString style) {
    DrawLatexDown(gPad, Offset, text, fSize, style);
}
void DrawLatexRight(double Offset, TString text, double fSize, TString style) {
    DrawLatexRight(gPad, Offset, text, fSize, style);
}
void DrawLatexLeft(double Offset, TString text, double fSize, TString style) {
    DrawLatexLeft(gPad, Offset, text, fSize, style);
}







TString SetLayout(unsigned pos)
{
    return to_string(pos);
}


static unsigned SimplifyPos(unsigned pos)
{
    if(pos & kPos5) return kPos5;
    if(pos & kPos2) pos &= !kPos1 & !kPos3;
    if(pos & kPos4) pos &= !kPos1 & !kPos7;
    if(pos & kPos6) pos &= !kPos3 & !kPos9;
    if(pos & kPos8) pos &= !kPos7 & !kPos9;
    return pos;
}


RectangleNDC GetNDC(TLatex *lat)
{

    int hAlign = lat->GetTextAlign() / 10 - 1;
    int vAlign = lat->GetTextAlign() % 10 - 1;
    if(vAlign == -1) vAlign = 0;

    RectangleNDC rTitle;

    rTitle.fHeight = lat->GetYsize() / (gPad->GetY2()-gPad->GetY1());
    rTitle.fWidth = lat->GetXsize()  / (gPad->GetX2()-gPad->GetX1());
    rTitle.fX = lat->GetX();
    rTitle.fY = lat->GetY();


    if(lat->GetTextAngle() == 0) {
        rTitle.fX -= hAlign*rTitle.fWidth/2.;
        rTitle.fY -= vAlign*rTitle.fHeight/2.;
    }
    else {
        swap(rTitle.fWidth, rTitle.fHeight);
        double rat = gPad->GetWh() / double(gPad->GetWw());
        rat /= gPad->GetAbsWNDC() / double(gPad->GetAbsHNDC());
        rTitle.fWidth *= rat;
        rTitle.fHeight *= 1./rat;

        if(lat->GetTextAngle() == 90) {
            rTitle.fY -= (hAlign)*rTitle.fHeight/2.;
            vAlign = 2-vAlign;
            rTitle.fX -=1.*vAlign*rTitle.fWidth/2.;
        }
        else if(lat->GetTextAngle() == 270) {
            hAlign = 2-hAlign;
            rTitle.fY -= (hAlign)*rTitle.fHeight/2.;
            rTitle.fX -=1.*vAlign*rTitle.fWidth/2.;
        }
    }
    rTitle.lat = lat;
    return rTitle;
}

TLegend *newLegend(unsigned pos, int nCols)
{
        TLegend *leg = new TLegend(0., 0., 0., 0.);
        leg->SetName(SetLayout(pos));

        TAxis *axY = GetYaxis();
        if(axY == nullptr) {
            cerr << "There is no frame created, legend can't be plotted." << endl;
            assert(0);
        }
        leg->SetTextSize(axY->GetTitleSize());
        leg->SetNColumns(nCols);
        return leg;
}

void GetLegendSizes(TLegend *leg, double &SizeX, double &SizeY, double &SizeYroot)
{

    double lineSeparation = 1.0;
    double markerSize = 1.5;
    double columnSeparation = 0;

    //double fontSize = RelFontToPx(GetYaxis()->GetTitleSize());
    double fontSize = RelFontToPx(leg->GetTextSize());

    gPad->Update();
    //cout <<"There is just start " <<  gPad->GetUymax() << " "<< gPad->GetUymin() << endl;

    leg->SetBorderSize(0);
    //leg->SetLineStyle(2);
    leg->SetFillStyle(0);
    leg->SetTextSize(PxFontToRel(fontSize));

    double fSizeNDCy = fontSize / (gPad->GetWh() * gPad->GetAbsHNDC());
    double fSizeNDCx = fontSize / (gPad->GetWw() * gPad->GetAbsWNDC());

    int nHeaders = 0;
    int nLegItems = 0;

    int nCols = leg->GetNColumns();
    vector<double> maxC(nCols, 0);
    double headerW = 0;
    int colId = 0;
    for(const auto &&entry : *leg->GetListOfPrimitives()) {
        TString lab = dynamic_cast<TLegendEntry *>(entry)->GetLabel();
        TString opt = dynamic_cast<TLegendEntry *>(entry)->GetOption();
        //cout << "Label "<< leg->GetNRows()<<" " << lab << endl;
        TLatex *lat = new TLatex(0.5, 0.5, lab);
        lat->SetTextSize(leg->GetTextSize());
        lat->SetTextFont(leg->GetTextFont());

        double textW = GetNDC(lat).fWidth;
        if(opt == "h") {
            headerW = max(headerW, textW);
            ++nHeaders;
            colId = -1;
        }
        else {
            maxC[colId] = max(maxC[colId], textW);
            ++nLegItems;
        }
        colId = (colId != nCols-1) ? colId + 1 : 0;
        delete lat;
    }
    double maxW = accumulate(maxC.begin(),maxC.end(),0.);

    int nRows = nHeaders + (nLegItems+nCols-1)/nCols;
    //cout << "MyTag nRows " << nRows << endl;
    SizeY = lineSeparation*fSizeNDCy*nRows;

    headerW += 0.1*fSizeNDCx*markerSize;

    SizeX = max(nCols*fSizeNDCx*markerSize +
               (nCols-1)*fSizeNDCx*columnSeparation + maxW, headerW);
    leg->SetMargin( nCols*fSizeNDCx*markerSize / SizeX);

    leg->SetColumnSeparation((nCols-1)*fSizeNDCx*columnSeparation / SizeX);


    SizeYroot = lineSeparation*fSizeNDCy*leg->GetNRows();

}

void PlaceLegends(vector<TLegend*> legs, bool keepRange)
{
    int nScaleSteps = keepRange ? 1 : 20;

    vector<double> sizesX, sizesY, sizesYroot;

    for(unsigned i = 0; i < legs.size(); ++i) {
        double SizeX, SizeY, SizeYroot;
        GetLegendSizes(legs[i], SizeX, SizeY, SizeYroot);
        sizesX.push_back(SizeX);
        sizesY.push_back(SizeY);
        sizesYroot.push_back(SizeYroot);
    }

    PLACER placer;
    gPad->Update();

    placer.init(legs, sizesX, sizesY);

    vector<double> xx, yy;
    double scaleUp, scaleDn;
    tie(scaleUp, scaleDn) = placer.GetSolution(xx, yy, nScaleSteps);
    //return;
    
    for(unsigned i = 0; i < legs.size(); ++i) {
        legs[i]->SetX1(xx[i]);
        legs[i]->SetY1(yy[i] + sizesY[i] - sizesYroot[i]);
        legs[i]->SetX2(xx[i] + sizesX[i]);
        legs[i]->SetY2(yy[i] + sizesY[i]);
    }

    
    TH1 *frameNow = GetFrame();
    if(gPad->GetLogy()) {
        //double Max = frameNow->GetMaximum();
        //double Min = frameNow->GetMinimum();
        double Max = pow(10,gPad->GetUymax());
        double Min = pow(10,gPad->GetUymin());

        frameNow->SetMaximum(Min * pow(Max/Min, scaleUp));
        frameNow->SetMinimum(Max / pow(Max/Min, scaleDn));
    }
    else {
        double Max = gPad->GetUymax();
        double Min = gPad->GetUymin();

        frameNow->SetMaximum(Min + (Max-Min)*scaleUp);
        frameNow->SetMinimum(Max - (Max-Min)*scaleDn);
    }

    /*
    for(unsigned i = 0; i < legs.size(); ++i) {
        TLine *l = new TLine;
        l->SetNDC();
        l->DrawLineNDC(xx[i], yy[i], xx[i]+sizesX[i], yy[i]);
        l->DrawLineNDC(xx[i], yy[i]+sizesY[i], xx[i]+sizesX[i], yy[i]+sizesY[i]);
        l->DrawLineNDC(xx[i], yy[i], xx[i], yy[i]+sizesY[i]);
        l->DrawLineNDC(xx[i]+sizesX[i], yy[i], xx[i]+sizesX[i], yy[i]+sizesY[i]);
    }
    */


}

void DrawLegends(vector<TLegend*> legs, bool keepRange)
{
    PlaceLegends(legs, keepRange);
    for(auto & leg : legs)
        leg->Draw();
}


    bool PosIterator::Iterate() {
        int last = nSteps-1;
        int i=0, j=0;
        //cout << iSave <<" "<< jSave <<" "<< nSteps<< endl;
        for(i = iSave; i < nSteps; ++i)
        for(j = (jSave+1)*(i==iSave); j < nSteps; ++j) {
            if(pos & kPos5)
                goto after;
            if((pos & kPos9)  && i==0 && j==last)
                goto after;
            if((pos & kPos7)  && i==0 && j==0)
                goto after;
            if((pos & kPos1)  && i==last && j==0)
                goto after;
            if((pos & kPos3)  && i==last && j==last)
                goto after;

            if((pos & kPos8c)  && i==0 && j==last/2)
                goto after;
            if((pos & kPos4c)  && i==last/2 && j==0)
                goto after;
            if((pos & kPos6c)  && i==last/2 && j==last)
                goto after;
            if((pos & kPos2c)  && i==last && j==last/2)
                goto after;

            if((pos & kPos8)  && i==0)
                goto after;
            if((pos & kPos2)  && i==last)
                goto after;
            if((pos & kPos4)  && j==0)
                goto after;
            if((pos & kPos6)  && j==last)
                goto after;

        }
        after:
        iSave = i;
        jSave = j;
        //cout << "myTag2 " << i << " "<< j << endl;
        if(i > last)
            return false;
        else
            return true;
    }






    //Initalize layOuts, dims, legBorders, borders
    void PLACER::init(vector<TLegend *> legs, vector<double> &sizesX, vector<double> &sizesY) {
        nLeg = legs.size();
        for(auto & leg : legs) {
            unsigned layOut = atoi(leg->GetName());

            vector<pair<int,int>> pos;

            PosIterator iter(nSteps, layOut);
            while(iter.Iterate()) {
               pos.push_back(make_pair(iter.iSave, iter.jSave));
            }
            layOuts.push_back(pos);
        }

        dims.resize(layOuts.size());
        for(unsigned i = 0; i < dims.size(); ++i)
            dims[i] = layOuts[i].size();
        SizesX = sizesX;
        SizesY = sizesY;
        GetLegendsPositions();

    }

    pair<double,vector<int>> PLACER::iterate() {
        vector<int> idxs(dims.size());
        vector<double> distsNow(dims.size());
        vector<double> distsBest(dims.size());
        vector<int> bestLayout;

        double maxDist = 0;

        while (1) {
            // Print
            double dist = analyze(idxs, distsNow);

            if(dist >= maxDist) {
                bool state = true;
                for(int i = 0; i < nLeg; ++i) {
                    state = state && distsNow[i] >= distsBest[i];
                }
                if(dist > maxDist || (dist == maxDist && state)) {
                    bestLayout = idxs;
                    distsBest = distsNow;
                }
                maxDist = dist;
            }

            // Update
            unsigned j;
            for(j = 0; j < dims.size(); ++j) {
                idxs[j]++;
                if (idxs[j] < static_cast<int>(dims[j])) break;
                idxs[j] = 0;
            }
            if (j == dims.size()) break;
        }
        return make_pair(maxDist, bestLayout);
    }


    void PLACER::GetLegendsPositions() {

        LoadHistoBorders(borders);

        legBorders.resize(nLeg);

        double fontSize = RelFontToPx(GetYaxis()->GetTitleSize());
        minSepar = 0.5*fontSize; //inPixels

        TH1 *frameNow = GetFrame();
        double ytickLowNDC = frameNow->GetYaxis()->GetTickLength() * GetAxisFractionY();
        double ytickHighNDC = ytickLowNDC * gPad->GetTicky();
        double xtickLowNDC = frameNow->GetXaxis()->GetTickLength() * GetAxisFractionX();
        double xtickHighNDC = xtickLowNDC * gPad->GetTickx();

        double fSizeNDCy = minSepar / (gPad->GetWh() * gPad->GetAbsHNDC());
        double fSizeNDCx = minSepar / (gPad->GetWw() * gPad->GetAbsWNDC());


        for(int k = 0; k < nLeg; ++k) {

            double SizeX = SizesX[k];
            double SizeY = SizesY[k];

            double xMin =  gPad->GetLeftMargin() + ytickLowNDC + fSizeNDCx;
            double xMax =  1 - gPad->GetRightMargin() - ytickHighNDC - SizeX - fSizeNDCx;
            double yMax =  1 - gPad->GetTopMargin() - xtickHighNDC - SizeY - fSizeNDCy;
            double yMin =  gPad->GetBottomMargin() + xtickLowNDC  + fSizeNDCy;


            legBorders[k].resize(dims[k]);

            for(unsigned l = 0; l < dims[k]; ++l) {
                int i = layOuts[k][l].first;
                int j = layOuts[k][l].second;
                
                double xx = xMin + (xMax-xMin)/(nSteps-1) * j;
                double yy = yMax - (yMax-yMin)/(nSteps-1) * i;


                //Legend borders
                legBorders[k][l].recs.push_back({xx, yy, SizeX, SizeY});
                legBorders[k][l].FromNDC2px();

            }
        }
    }


    void PLACER::GetDistancesPx(double scaleUp, double scaleDn) {
        auto bordersPx = borders;
        for(auto &b : bordersPx)
            b.FromAbs2px(scaleUp, scaleDn);

        distToHists.resize(nLeg);

        for(int i = 0; i < nLeg; ++i) {
            distToHists[i].resize(dims[i]);
            for(unsigned l = 0; l < dims[i]; ++l) 
                distToHists[i][l] = MinDistanceSingle(bordersPx, legBorders[i][l], 0.99*minSepar);
        }
    }


    pair<double,double> PLACER::GetSolution(vector<double> &xx, vector<double> &yy,
                                                         int nScaleSteps) {
        
        double scaleUp=1., scaleDn=1.;

        vector<int> bestLayout;

        for(int sum = 0; sum < nScaleSteps; ++sum)
        for(int iUp = sum; iUp >= 0; --iUp) {
                int iDn = sum - iUp;
                if(!gPad->GetLogy() && iDn != 0) continue;
                scaleUp = pow(4, iUp/10.);
                scaleDn = pow(4, iDn/10.);

                GetDistancesPx(scaleUp, scaleDn);
                //double dist = iterate(&bestLayout);
                double dist;
                tie(dist, bestLayout) = iterate();

                if(dist > minSepar)
                    goto gotoAfterScaleLoop;
        }
        cerr << "No solution without overlaps found for legends" << endl;
        
        gotoAfterScaleLoop:

        xx.resize(nLeg);
        yy.resize(nLeg);
        for(int i = 0; i < nLeg; ++i) {
            Point p;
            p.x = legBorders[i][bestLayout[i]].recs[0].fX;
            p.y = legBorders[i][bestLayout[i]].recs[0].fY;
            p = Px2NDC(p);
            xx[i] = p.x;
            yy[i] = p.y;
        }

        return {scaleUp, scaleDn};
        //cout << "done " << maxDist << endl;
    }




    void PLACER::LoadHistoBorders(vector<Borders> &borders)
    {
        //Load histograms
        vector<TObject *> hists;
        for(const auto &&prim : *gPad->GetListOfPrimitives()) {
            //cout << prim->GetName() <<" "<< prim->ClassName() <<  endl;
            if(strcmp(prim->GetName(),"hframe") && strcmp(prim->ClassName(),"TH1F"))
                if(dynamic_cast<TH1*>(prim)) 
                    hists.push_back(prim);
        }


        //GetDistance
        if(hists.size() == 0) {
            gPad->Modified();
            return;
        }

        for(unsigned i = 0; i < hists.size(); ++i) {
            Borders br;
            br.GetHistBorders(dynamic_cast<TH1*>(hists[i]));
            borders.push_back(br);
        }

    }


    double PLACER::analyze(const vector<int> &indx, vector<double> &dists) 
    {
        double minDist = 1e40;
        //Distances to histograms
        for(unsigned k = 0; k < indx.size(); ++k) {
            //cout << "BBB " << distToHists[k].size()<<" "<<  indx[k] << endl;
            //cout << "MinDist " << minDist <<" "<< distToHists[k][indx[k]] << endl;
            minDist = min(minDist, distToHists[k][indx[k]]);
            dists[k] = distToHists[k][indx[k]];
            if(minDist < minSepar)
                return minDist;
        }

        for(unsigned k = 0;   k < indx.size(); ++k) 
        for(unsigned l = k+1; l < indx.size(); ++l) {
            double dist = MinDistance2(0.99*minSepar,
                           legBorders[k][indx[k]], legBorders[l][indx[l]]);
            minDist = min(minDist, dist);
            dists[k] = min(dists[k], dist);
            if(minDist < minSepar)
                return minDist;
        }


        return minDist;

    }



Point Abs2Px(Point p, double scaleUp, double scaleDn)
{
    double valXmin = gPad->GetX1();
    double valXmax = gPad->GetX2();

    double valYmin = gPad->GetY2() - scaleDn*(gPad->GetY2()-gPad->GetY1());
    double valYmax = gPad->GetY1() + scaleUp*(gPad->GetY2()-gPad->GetY1());


    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double pxW = gPad->GetWw()*gPad->GetAbsWNDC();


    if(gPad->GetLogx()) p.x = log10(p.x);
    if(gPad->GetLogy()) p.y = log10(p.y);

    p.x =  (p.x - valXmin)/(valXmax-valXmin) * pxW;
    p.y =  (p.y - valYmin)/(valYmax-valYmin) * pxH;

    //cout << p.x <<" "<<  p.y << endl;
    return p;
}

Point Px2NDC(Point p)
{
    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double pxW = gPad->GetWw()*gPad->GetAbsWNDC();
    p.x = p.x/pxW;
    p.y = p.y/pxH;
    return p;
}



static double MinDistanceSingle(vector<Borders> &bor, double minSkip, double x, double y, double w, double h)
{
    Borders bS;
    bS.recs.push_back( {x, y, w, h} );
    bS.FromNDC2px();

    double minDist = 1e40;
    for(Borders &b : bor) {
        double d = MinDistance2(0.99*minSkip, b, bS);
        minDist = min(minDist, d);
        if(minDist <= minSkip) return minDist;
    }
    return sqrt(minDist);
}


static double MinDistanceSingle(vector<Borders> &bor, Borders bSingle, double minSkip)
{
    double minDist = 1e40;
    for(Borders &b : bor) {
        double d = MinDistance2(0.99*minSkip, b, bSingle);
        minDist = min(minDist, d);
        if(minDist <= minSkip) return minDist;
    }
    return sqrt(minDist);
}



static double MinDistance2(double minSkip, const Borders &br1, const Borders &br2)
{
    double minDist = 1e40;
    for(const auto &r1 : br1.recs)
        for(const auto &r2 : br2.recs) {
            double d = Borders::Distance2(r1, r2);
            minDist = min(minDist, d);
            if(minDist <= minSkip) return minDist;
        }
    return minDist;

}


void Borders::FromNDC2px()
{
    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double pxW = gPad->GetWw()*gPad->GetAbsWNDC();

    for(Rectangle &r : recs) { 
        r.fX *= pxW;
        r.fY *= pxH;
        r.fWidth  *= pxW;
        r.fHeight *= pxH;
    }
}

/*
void Borders::FromPx2NDC()
{
    double pxH = gPad->GetWh()*gPad->GetAbsHNDC();
    double pxW = gPad->GetWw()*gPad->GetAbsWNDC();

    for(Rectangle &r : recs) { 
        r.fX /= pxW;
        r.fY /= pxH;
        r.fWidth  /= pxW;
        r.fHeight /= pxH;
    }
}
*/



void Borders::FromAbs2px(double scaleUp, double scaleDn)
{
    for(Rectangle &r : recs) { 
        Point p1(r.fX, r.fY);
        Point p2(r.fX+r.fWidth, r.fY+r.fHeight);

        p1 = Abs2Px(p1, scaleUp, scaleDn);
        p2 = Abs2Px(p2, scaleUp, scaleDn);
        r.fX = p1.x;
        r.fY = p1.y;
        r.fWidth  = p2.x-p1.x;
        r.fHeight = p2.y-p1.y;
    }
}

void Borders::GetHistBorders(TH1 *h)
{
    for(int i = 1; i <= h->GetNbinsX(); ++i) {
        double xMin = h->GetBinLowEdge(i);
        double xMax = h->GetBinLowEdge(i) + h->GetBinWidth(i);
        double yMin = h->GetBinContent(i)-h->GetBinError(i);
        double yMax = h->GetBinContent(i)+h->GetBinError(i);

        const double lim  = 1e-30;

        if(gPad->GetLogx()) {
            xMin = max(lim, xMin);
            xMax = max(lim, xMax);
        }
        if(gPad->GetLogy()) {
            yMin = max(lim, yMin);
            yMax = max(lim, yMax);
        }
        recs.push_back({xMax, yMin, xMax-xMin, yMax-yMin});

        TString drawOpt = h->GetDrawOption();
        if(drawOpt.Contains("hist") && i > 1) {
            double yMinLeft = h->GetBinContent(i-1)-h->GetBinError(i-1);
            double yMaxLeft = h->GetBinContent(i-1)+h->GetBinError(i-1);
            if(gPad->GetLogy()) {
                yMinLeft = max(lim, yMinLeft);
                yMaxLeft = max(lim, yMaxLeft);
            }
            double yMinNow = min(yMin, yMinLeft);
            double yMaxNow = max(yMax, yMaxLeft);
            recs.push_back({xMin, yMinNow, 0., yMaxNow-yMinNow});
        }
    }
}






static double hypot2(double x, double y) {return x*x+y*y;}

double Borders::Distance2(const Rectangle &r1, const Rectangle &r2)
{
    double x1  = r1.fX;
    double x1b = r1.fX + r1.fWidth;
    double x2  = r2.fX;
    double x2b = r2.fX + r2.fWidth;

    double y1  = r1.fY;
    double y1b = r1.fY + r1.fHeight;
    double y2  = r2.fY;
    double y2b = r2.fY + r2.fHeight;

    bool left = x2b < x1;
    bool right = x1b < x2;
    bool bottom = y2b < y1;
    bool top = y1b < y2;
    if(top && left)
        return hypot2(x2b-x1, y2-y1b);
    else if(left && bottom)
        return hypot2(x2b-x1, y2b-y1);
    else if(bottom && right)
        return hypot2(x2-x1b, y2b-y1);
    else if(right && top)
        return hypot2(x2-x1b, y2-y1b);
    else if(left)
        return hypot2(x1 - x2b,0.);
    else if(right)
        return hypot2(x2 - x1b,0.);
    else if(bottom)
        return hypot2(y1 - y2b,0.);
    else if(top)
        return hypot2(y2 - y1b,0.);
    else
        return 0.;
}




void UpdateFrame()
{
    gPad->Update();
    gPad->RedrawAxis();
    TFrame *fr = gPad->GetFrame();
    if(fr) {
        fr->SetFillStyle(0);
        fr->Draw();
    }
    else
        cerr << "No frame at active pad" << endl;
    gPad->Update();
}


void CalcYaxisRange()
{
    TH1 *hFrame = GetFrame();
    if(!hFrame) return;
    TAxis *ax = hFrame->GetXaxis();

    int iFirst = ax->GetFirst();
    int iLast  = ax->GetLast();

    double xMin = ax->GetBinLowEdge(iFirst);
    double xMax = ax->GetBinLowEdge(iLast) + ax->GetBinWidth(iLast);


    double widthMin=0,  widthMax=0;
    double centerMin=0, centerMax=0;
    //return ;
    double yMin = 1e100, yMax = -1e100;
    for(auto && obj : *gPad->GetListOfPrimitives()) {

        if(obj->InheritsFrom(TH1::Class()))
            ((TH1*)obj)->GetXaxis()->SetRangeUser(xMin, xMax);
        else if(obj->InheritsFrom(TMultiGraph::Class()))
            ((TMultiGraph*)obj)->GetXaxis()->SetRangeUser(xMin, xMax);
        else if(obj->InheritsFrom(TGraph::Class()))
            ((TGraph*)obj)->GetXaxis()->SetRangeUser(xMin, xMax);
        else if(obj->InheritsFrom(THStack::Class()))
            ((THStack*)obj)->GetXaxis()->SetRangeUser(xMin, xMax);


        if(obj->InheritsFrom(TH1::Class()) ||
            obj->InheritsFrom(TMultiGraph::Class()) ||
            obj->InheritsFrom(TGraph::Class())  ||
            obj->InheritsFrom(THStack::Class()) ) {

            obj->Paint();
            //double zoom = gPad->GetUymax() - gPad->GetUymin();
            double yMinNow = gPad->GetUymin();
            double yMaxNow = gPad->GetUymax();

            if(yMinNow < yMin) {
                yMin = yMinNow;
                widthMin = yMaxNow - yMinNow;
                centerMin = (yMaxNow + yMinNow)/2.;
            }
            if(yMaxNow > yMax) {
                yMax = yMaxNow;
                widthMax = yMaxNow - yMinNow;
                centerMax = (yMaxNow + yMinNow)/2.;
            }
        }
    }


    double width = yMax - yMin;


    double zoomMin = width / widthMin;
    double zoomMax = width / widthMax;
    
    if(yMin >= 0. && !gPad->GetLogy())
        yMin = max(0., centerMin - zoomMin * widthMin/2.);
    else
        yMin =  centerMin - zoomMin * widthMin/2.;
    yMax = centerMax + zoomMax * widthMax/2.;
    

    if(gPad->GetLogy()) {
        hFrame->SetMinimum(pow(10,yMin));
        hFrame->SetMaximum(pow(10,yMax));
    }
    else {
        hFrame->SetMinimum(yMin);
        hFrame->SetMaximum(yMax);
    }
}

void SetLeftRight(double lMargin, double rMargin)
{
    gPad->SetLeftMargin(0);
    gPad->SetRightMargin(0);
    gPad->SetLeftMargin(lMargin);
    gPad->SetRightMargin(rMargin);
}

void SetTopBottom(double tMargin, double bMargin)
{
    gPad->SetTopMargin(0);
    gPad->SetBottomMargin(0);
    gPad->SetTopMargin(tMargin);
    gPad->SetBottomMargin(bMargin);
}



void DividePad(vector<double> xDivs, vector<double> yDivs)
{
    TVirtualPad *orgPad = gPad;

    double lMag = orgPad->GetLeftMargin();
    double rMag = orgPad->GetRightMargin();
    double tMag = orgPad->GetTopMargin();
    double bMag = orgPad->GetBottomMargin();

    int nx = xDivs.size();
    int ny = yDivs.size();

    double Nx = accumulate(xDivs.begin(), xDivs.end(), 0.);
    double Ny = accumulate(yDivs.begin(), yDivs.end(), 0.);
    vector<double> xPos(nx+1), yPos(ny+1);
    xPos[0] = yPos[0] = 0;
    for(int i = 1; i <= nx; ++i)
        xPos[i] = xPos[i-1] + xDivs[i-1]/Nx * (1-lMag-rMag);
    for(int i = 1; i <= ny; ++i)
        yPos[i] = yPos[i-1] + yDivs[i-1]/Ny * (1-tMag-bMag);

    
    for(int ix = 0; ix < nx; ++ix)
    for(int iy = 0; iy < ny; ++iy) {
        double xl = (ix == 0)    ? 0 : lMag+xPos[ix];
        double xr = (ix == nx-1) ? 1 : lMag+xPos[ix+1];

        double yt = (iy == 0)    ? 1 : 1-tMag-yPos[iy];
        double yb = (iy == ny-1) ? 0 : 1-tMag-yPos[iy+1];

        int id = iy*nx+ix+1;
        TPad *pad = new TPad(SF("%s_%d", orgPad->GetName(), id), "", xl, yb, xr, yt);


        double lNew =  (ix == 0) ? lMag/(xr - xl) : 0;
        double rNew =  (ix == nx-1) ? rMag/(xr - xl) : 0;

        double tNew =  (iy == 0) ? tMag/(yt - yb) : 0;
        double bNew =   (iy == ny-1) ? bMag/(yt - yb) : 0;




        pad->cd();
        SetLeftRight(lNew, rNew);
        SetTopBottom(tNew, bNew);
        orgPad->cd();
        
//        if(ix == nx-1) {
//            cout << "Hela : " <<  lMag + xPos[nx-1] << endl;
//            cout << "lMag rMag : " <<lMag <<" "<<  rMag << endl;
//            cout  << "Ratio " << rMag / (1-lMag-xPos[nx-1]) << endl;
//        }

        pad->SetNumber(id);
        pad->Draw();
    }
}




void DivideTransparent(vector<double> divX, vector<double> divY, bool useMargins)
{

    TVirtualPad *orgPad = gPad;

    if(divX.size() % 2 != 1 || int(divX.size()) < (3-2*useMargins) ) {
        cerr << "Wrong divX= " << divX.size() << endl;
        return;
    }
    if(divY.size() % 2 != 1 || int(divY.size()) < (3-2*useMargins) ) {
        cerr << "Wrong divY= " << divY.size() << endl;
        return;
    }



    double sumX = accumulate(divX.begin(), divX.end(), 0.0);
    double sumY = accumulate(divY.begin(), divY.end(), 0.0);

    if(useMargins == true) {
        double l = orgPad->GetLeftMargin();
        double r = orgPad->GetRightMargin();
        double t = orgPad->GetTopMargin();
        double b = orgPad->GetBottomMargin();
        

        vector<double> newX, newY;
        newX.push_back(l * sumX/(1-l-r));
        newX.insert(newX.end(), divX.begin(), divX.end());
        newX.push_back(r * sumX/(1-l-r));

        newY.push_back(t * sumY/(1-t-b));
        newY.insert(newY.end(), divY.begin(), divY.end());
        newY.push_back(b * sumY/(1-t-b));

        DivideTransparent(newX, newY, false);
        return;
    }



    vector<double> edgesX(divX.size()+1);
    vector<double> edgesY(divY.size()+1);

    edgesX[0] = edgesY[0] = 0;
    for(unsigned i = 1; i < edgesX.size(); ++i)
        edgesX[i] = edgesX[i-1] + divX[i-1]/sumX;
    for(unsigned i = 1; i < edgesY.size(); ++i)
        edgesY[i] = edgesY[i-1] + divY[i-1]/sumY;

    int nPadsX = (divX.size()-1)/2;
    //int nPadsY = (divY.size()-1)/2;

    int kStart = 1;
    while(orgPad->GetPad(kStart))
        ++kStart;
    --kStart;


    int i = 1;
    //for(int x = 1; x < edgesX.size()-1; x+=2)
    for(int y = 1; y < int(edgesY.size())-1; y+=2) 
    for(int x = edgesX.size()-3; x >= 1; x-=2) {
        //i = (nPadsY-1-(y-1)/2) * nPadsX + (nPadsX-1-(x-1)/2) + 1; 
        i = ((y-1)/2) * nPadsX + ((x-1)/2) + 1; 
        
        TPad *pad = new TPad(TString::Format("%s_%d", orgPad->GetName(), kStart+i), "", 0.0, 0.0, 1, 1);
        pad->SetFillStyle(0);

        
        double l = max(0.,edgesX[x]);
        double r = max(0.,1-edgesX[x+1]);
        double t = max(0.,edgesY[y]);
        double b = max(0.,1-edgesY[y+1]);

        //cout <<"LeftRight " << l <<" "<<  r <<" "<< (1-l-r) <<" "<< i<< endl;

        pad->cd();
        SetLeftRight(l, r);
        SetTopBottom(t, b);
        orgPad->cd();


        pad->SetNumber(kStart+i);
        pad->Draw();
        ++i;
    }
}

vector<double> merge(vector<double> v1, vector<double> v2, vector<double> v3, vector<double> v4, vector<double> v5, vector<double> v6, vector<double> v7)
{
    vector<vector<double>> v = {v1, v2, v3, v4, v5, v6, v7};
    vector<double> res;
    for(unsigned i = 0; i < v.size(); ++i)
        res.insert(res.end(), v[i].begin(), v[i].end());
    return res;
}

vector<double> repeat(vector<double> x, int n)
{
    vector<double> res = x;
    for(int i = 1; i < n; ++i)
        res.insert(res.end(), x.begin(), x.end());
    return res;
}

vector<double> group(double frame, double space, int n)
{
    vector<double> res;
    for(int i = 0; i < n-1; ++i) {
        res.push_back(frame);
        res.push_back(space);
    }
    res.push_back(frame);
    return res;
}







}

//dummy function
void plottingHelper()
{
}