style.h

#include <TStyle.h>
#include <TColor.h>
#include <TH2D.h>
#include <TH1D.h>
#include <TCanvas.h>
#include <TRandom.h>
#include <TLatex.h>
#include <iostream>
#include <TROOT.h>

const Style_t font = 63; //fonts: 132 = serif, 62 = default
                         //133,63 = fonts with constant size, independent of the pad size
const double LEGEND_SIZE = 25;

const Int_t COLOR_NA61             = kAzure;
const Int_t COLOR_NA61_SYSTEMATIC  = 10006;
const Int_t MARKER_NA61 = kFullCircle;
const Int_t COLOR_NA49  = kRed;
const Int_t COLOR_NA49_SYSTEMATIC  = 10007;
const Int_t MARKER_NA49 = kFullSquare;

const Int_t COLOR_AU = kRed-7;

const double MARKER_SIZE = 0.8;
const double MARKER_BIGGER = 1.5*MARKER_SIZE;
// const double LEGEND_SIZE = 25;

const Int_t REACTION_MARKER[5] = {kFullTriangleDown, 34, kFullCircle, kFullTriangleUp, kFullSquare}; //34 == full cross
const Int_t REACTION_MARKER_OPEN[5] = {kOpenTriangleDown, 28, kOpenCircle, kOpenTriangleUp, kOpenSquare}; //28 == open cross
const Int_t REACTION_COLOR[7] = {kAzure-2, kCyan+2, kSpring-6, kOrange+7, kRed+2, COLOR_NA61, COLOR_NA49};
const Int_t REACTION_SYSTEMATIC_COLOR[5] = {10001, 10002, 10003, 10004, 10005};


const Double_t MINIMUM_ACCEPTANCE = 0.9; //minimum matched to MC ratio required in order to accept the bin

void set_style(int iPalette = 1) {
  gStyle->Reset();
  
  gStyle->SetCanvasDefH(550);
  gStyle->SetCanvasDefW(650);
  
  gStyle->SetTitleFont(font, "xyz");
  gStyle->SetTitleSize(LEGEND_SIZE, "xyz");
  gStyle->SetTitleOffset(0.7, "z");
  gStyle->SetLabelFont(font, "xyz");
  gStyle->SetLabelSize(LEGEND_SIZE, "xyz");
  
  
  //gStyle->SetTextFont(font);
  gStyle->SetTextSize(LEGEND_SIZE);
  gStyle->SetLegendFont(font);
  
  
  //dimensions
  gStyle->SetPadTopMargin(0.1);
  gStyle->SetPadBottomMargin(0.15);
  gStyle->SetPadLeftMargin(0.2);
  gStyle->SetPadRightMargin(0.2);
  
  //make all white:
  gStyle->SetFrameBorderMode(0);
  gStyle->SetFrameFillColor(0);
  gStyle->SetFrameFillStyle(0); //don't fill histogram interior
  gStyle->SetPadColor(0);
  gStyle->SetCanvasColor(0);
  gStyle->SetStatColor(0);
  gStyle->SetTitleFillColor(0);
  
  //statbox
  gStyle->SetOptStat(0);
  gStyle->SetOptFit(0);
  gStyle->SetStatX(0.90);
  gStyle->SetStatY(0.90);
  gStyle->SetStatW(0.12);
  gStyle->SetStatH(0.12);
  
  //number format for "text" drawing option
  gStyle->SetPaintTextFormat(".2f"); //number of decimal digits printed with "text" draw option
  
  //title
  gStyle->SetTitleBorderSize(0);
  gStyle->SetTitleX(0.2);
  gStyle->SetTitleY(0.975f);
  gStyle->SetTitleH(0.05f);
  
  //label
  gStyle->SetLegendBorderSize(1);
  gStyle->SetLegendFillColor(0); //does nothing?!
  gStyle->SetFillStyle(0);
  
  gStyle->SetNdivisions(505);
  
  
  //I don't know what is this
  //  gStyle->SetCanvasBorderMode(0);
  //  gStyle->SetPadBorderMode(0);
  
  //     gStyle->SetTitleW(0.8f);
  //    
  //  
  //  gStyle->SetStatBorderSize(1);
  // //    gStyle->SetOptTitle(0);
  
  //  gStyle->SetTitleXOffset(1);
  //  gStyle->SetTitleYOffset(1.5);
  //  gStyle->SetMarkerStyle(20);
  //  gStyle->SetMarkerSize(0.5);
  //  gStyle->SetFuncWidth(1.);
  
  
  //    gStyle->SetErrorX(0.); //no horizontal errorbars. I don't want this by default because I can miss empty bins this way
  
  
  //   gROOT->ForceStyle();
  
  
  static const Int_t nPalettes = 3;
  if(iPalette >= nPalettes) {
    cerr<<"Invalid palette number "<<iPalette<<endl;
    return;
  }
  static Int_t NCont[nPalettes];
  static Int_t NRGBs[nPalettes];
  static Int_t pal[nPalettes][1000];
  
  
  static Bool_t ArePalettesDefined = false;
  
  if(!ArePalettesDefined) {
    //Palette defining is time consuming and it occupies memory permanently
    //so it shouldn't be done more than once
    //https://sft.its.cern.ch/jira/browse/ROOT-177
    
    //palette with grey in the middle
    //     NCont[0]  = 999;
    //     NRGBs[0]  = 11;
    //     Double_t stops0[] = { 0.00, 0.02, 0.125,0.25, 0.375,0.50,0.625, 0.75, 0.875,0.98, 1.00 };
    //     Double_t red0[]   = { 0.90, 0.80, 0.40, 0.00, 0.25, 0.80, 0.87, 0.90, 1.00, 0.60, 0.31 };
    //     Double_t green0[] = { 0.90, 0.80, 0.50, 0.85, 1.00, 0.80, 1.00, 0.50, 0.20, 0.00, 0.00 };
    //     Double_t blue0[]  = { 1.00, 1.00, 1.00, 0.85, 0.25, 0.80, 0.12, 0.05, 0.00, 0.00, 0.00 };
    
//     NCont[0]  = 999;
//     NRGBs[0]  = 9;
//     
//     Double_t stops0[] = { 0.00, 0.02, 0.125,0.30, 0.50, 0.70, 0.875, 0.98, 1.00 };
//     Double_t red0[]   = { 0.90, 0.80, 0.40, 0.00, 0.80, 1.00, 1.00, 0.60, 0.31 };
//     Double_t green0[] = { 0.90, 0.80, 0.50, 0.85, 0.80, 0.85, 0.30, 0.00, 0.00 };
//     Double_t blue0[]  = { 1.00, 1.00, 1.00, 0.85, 0.80, 0.00, 0.00, 0.00, 0.00 };
    
    NCont[0]  = 999;
    NRGBs[0]  = 7;
    
    Double_t stops0[] = { 0.00, 0.20, 0.40, 0.50, 0.60, 0.80, 1.00 };
    Double_t red0[]   = { 0.80, 0.15, 0.70, 0.95, 0.80, 0.35, 0.10 };
    Double_t green0[] = { 0.20, 0.60, 0.70, 0.95, 0.90, 0.85, 0.20 };
    Double_t blue0[]  = { 0.80, 1.00, 0.90, 0.95, 0.80, 0.45, 0.00 };
    
//     Double_t red0[]   = { 0.05, 0.35, 0.75, 0.95, 0.70, 0.15, 0.80 };
//     Double_t green0[] = { 0.25, 0.95, 0.90, 0.95, 0.70, 0.60, 0.20 };
//     Double_t blue0[]  = { 0.01, 0.20, 0.80, 0.95, 0.90, 1.00, 0.80 };

    
    Int_t ind;
    
    ind = TColor::CreateGradientColorTable(NRGBs[0], stops0, red0, green0, blue0, NCont[0]);
    for (int i = 0; i < NCont[0]; i++)
      pal[0][i] = ind+i;
    
    
    //standard palette
    NCont[1]  = 999;
    NRGBs[1]  = 10;
    Double_t stops1[] = { 0.00, 0.02, 0.15, 0.30, 0.44, 0.58, 0.72, 0.86, 0.98, 1.00 };
    Double_t red1[]   = { 0.90, 0.80, 0.40, 0.00, 0.25, 0.87, 0.90, 1.00, 0.60, 0.31 };
    Double_t green1[] = { 0.90, 0.80, 0.50, 0.85, 1.00, 1.00, 0.50, 0.20, 0.00, 0.00 };
    Double_t blue1[]  = { 1.00, 1.00, 1.00, 0.85, 0.25, 0.12, 0.05, 0.00, 0.00, 0.00 };
    
    ind = TColor::CreateGradientColorTable(NRGBs[1], stops1, red1, green1, blue1, NCont[1]);
    for (int i = 0; i < NCont[1]; i++)
      pal[1][i] = ind+i;
    
    //acceptance palette
    NCont[2]  = 999;
    NRGBs[2]  = 10;
    Double_t stops2[] = { 0.00, 0.02, 0.20, 0.40, 0.60, 0.80, 0.99999*MINIMUM_ACCEPTANCE, MINIMUM_ACCEPTANCE,  0.98, 1.00 };
    Double_t red2[]   = { 0.90, 0.80, 0.40, 0.00, 0.25, 0.85, 0.95, 1.00, 0.60, 0.31 };
    Double_t green2[] = { 0.90, 0.80, 0.50, 0.85, 1.00, 0.95, 0.95, 0.20, 0.00, 0.00 };
    Double_t blue2[]  = { 1.00, 1.00, 1.00, 0.85, 0.25, 0.12, 0.05, 0.00, 0.00, 0.00 };
    
    ind = TColor::CreateGradientColorTable(NRGBs[2], stops2, red2, green2, blue2, NCont[2]);
    for (int i = 0; i < NCont[2]; i++)
      pal[2][i] = ind+i;
    
    ArePalettesDefined = true;
    
    //BEGIN prepare nice bright color versions for systematic error
   // TColor * cl[7];
    for(Int_t i = 0; i < 7; i++) { //5 colors for reaction + NA61 + NA49
      TColor * ctmp = gROOT->GetColor(REACTION_COLOR[i]);
      Float_t r, g, b;
      ctmp->GetRGB(r, g, b);
      
      const Double_t intensity = 0.8; //0-1
      const Double_t brightness = 0.9; //0-1
      const Double_t mean = (r + g + b)/3;
      
//       cout<<"Color check before:"<<i<<" "<<mean<<" "<<r<<" "<<g<<" "<<b<<endl;
      
      r = ((1-intensity) * mean + intensity * r) * (1-brightness) + brightness;
      g = ((1-intensity) * mean + intensity * g) * (1-brightness) + brightness;
      b = ((1-intensity) * mean + intensity * b) * (1-brightness) + brightness;
      
     // cl[i] = 
new TColor(10001+i, r, g, b, TString::Format("my_color_%d", i));
//       cout<<"Color check  after:"<<cl[i]<<" "<<i<<" "<<mean<<" "<<r<<" "<<g<<" "<<b<<endl;
    }
    //END prepare nice bright color versions for systematic error
  }
  
  gStyle->SetNumberContours(NCont[iPalette]);
  gStyle->SetPalette(NCont[iPalette], pal[iPalette]);
}

void set_style1D() {
  gStyle->SetTitleOffset(1.1, "xz");
  gStyle->SetTitleOffset(1.8, "y");
  //   gStyle->SetLabelOffset(0.005, "xyz");
  
  gStyle->SetPadTopMargin(0.05);
  gStyle->SetPadBottomMargin(0.1);
  gStyle->SetPadRightMargin(0.05);
}

void set_style2D() {
  gStyle->SetTitleOffset(1.1, "x");
  gStyle->SetTitleOffset(1.4, "y");
  gStyle->SetTitleOffset(1.2, "z");
  //   gStyle->SetLabelOffset(0.005, "xyz");
  
  gStyle->SetPadTopMargin(0.05);
  gStyle->SetPadBottomMargin(0.15);
  gStyle->SetPadLeftMargin(0.14);
  gStyle->SetPadRightMargin(0.2);
}

void LocaldrawTH2Hacked(TH2 * h1, Double_t min = -0.10, Double_t max = 0.10, float text = false, Bool_t draw_palette = true) {
  if(text) {
    gStyle->SetPaintTextFormat(TString::Format(".%df", (int)(text)));
  }
    
  
  TH2D * h = (TH2D*)(h1->Clone("drawTH2HackedTempH"));
  TH2D * h2 = (TH2D*)(h1->Clone("drawTH2HackedTempH2"));
  h2->Reset(); // we will use it only to draw the colour palette
  
  const Int_t nLevels = 999;
  Double_t levels[nLevels];
  for(int i = 1; i < nLevels; i++) {
    levels[i] = min + (max - min) / (nLevels - 1) * (i);
  }
  levels[0] = -1E6;
  
  for(int i = 1; i <= h->GetNbinsX(); ++i) { //push empty bins really low
    for(int j = 1; j <= h->GetNbinsY(); ++j) {
      if(h->GetBinContent(i, j) == 0
        && h->GetBinError(i, j) == 0
      )
        h->SetBinContent(i, j, levels[0]-1);
      
      h2->SetBinContent(i, j, levels[0]-1); //this is to prevent any possibility of the scatter plot being visible
    }
  }
  
  h->SetContour((sizeof(levels)/sizeof(Double_t)), levels);
  
  
  //draw colour palette
  
  if(draw_palette) {
    h2->SetContour((sizeof(levels)/sizeof(Double_t)), levels);
    h2->GetZaxis()->SetRangeUser(min, max); // ... set the range for the palette
    h2->DrawClone("z"); // draw the "color palette"
  }
  h->SetMarkerColor(kWhite); //white scatter plot invisible!
  h->GetZaxis()->SetRangeUser(levels[0]+1, -levels[0]-1); // ... set the range ...
  
  h->DrawClone("col same");
  
  if(text) {
    h->SetMarkerSize(LEGEND_SIZE*15);
    h->DrawCopy("text same");
  }
  
  h->Draw("sameaxis"); //prevents color bleeding into the axes (doesn't actually)
}

void style() {/*
  set_style();
  set_style2D();
  TCanvas * c = new TCanvas();
  TH2D h("h", "", 20, -1, 1, 20, 0, 20);
  TRandom r(0);
  for(int i = 0; i < 2000; i++) h.Fill(r.Gaus(0.1, 0.2), r.Poisson(5));
  h.GetXaxis()->SetNdivisions(505);
  h.SetXTitle("Gaussian distribution #mu=0.1 #sigma=0.2");
  h.SetYTitle("Poisson distribution #lambda=5");
  h.SetZTitle("entries");
  h.Draw("colz");
  TLatex tl(0.2, 0.9, "Style test");
  tl.SetNDC();
  tl.Draw();
  c->SaveAs("style.pdf");
  delete c;
  
  set_style(0);
  set_style2D();
  
  c = new TCanvas();
  for(int i = 0; i < 2000; i++) {
    h.Fill(r.Gaus(0.5, 0.2), 5+r.Poisson(5), -1);
  }
  for(int i = 0; i < 100000; i++) {
    h.Fill(r.Gaus(0.0, 5), r.Gaus(10, 50), r.Gaus(0, 0.5));
  }
  h.SetXTitle("abc");
  h.SetYTitle("def");
  h.SetZTitle("entries");
  LocaldrawTH2Hacked(&h, -60, 60, 0);
  tl.Draw();
  c->SaveAs("style2.pdf");
  delete c;*/
}