tknuclear_chart.cpp

#include "tknuclear_chart.h"
#include <iostream>
 
#include "TLine.h"
#include "TLatex.h"
#include "TGraph.h"
#include "TStyle.h"
 
namespace tkn {
}
 
using namespace tkn;
 
tknuclear_chart::tknuclear_chart(const char *_title, int type, bool _autofit):
    mgrn(Form("%s_N",_title),""),
    mgrz(Form("%s_Z",_title),""),
    chart_title(_title),
    autofit(_autofit)
{
    cc = nullptr;
    ndivx = ndivy = 10;
    ndivz = 6;
 
    hzn.SetNameTitle(Form("%s_ZN",chart_title.Data()), chart_title.Data());
    hz.SetNameTitle(Form("%s_Z",chart_title.Data()), chart_title.Data());
    hn.SetNameTitle(Form("%s_N",chart_title.Data()), chart_title.Data());
 
    switch(type){
    case kAll:
        hzn.SetBins(201,-.5,200.5,121,-.5,120.5);
        hz.SetBins(100,0,1,121,-.5,120.5);
        hn.SetBins(201,-.5,200.5,100,0,1);
        break;
    case kEven :
        hzn.SetBins(80,1,161,55,1,111);
        hz.SetBins(100,0,1,55,1,111);
        hn.SetBins(80,1,161,100,0,1);
        break;
    case kOdd :
        hzn.SetBins(80,0,160,55,0,110);
        hz.SetBins(100,0,1,55,0,110);
        hn.SetBins(80,0,160,100,0,1);
        break;
    }
}
 
tknuclear_chart::tknuclear_chart(const char *_title, int type, double _min_val_histo, bool _autofit): tknuclear_chart(_title, type, _autofit)
{
    min_val_histo = _min_val_histo;
    hzn.SetMinimum(min_val_histo);
    fset_min_val = true;
}
 
void tknuclear_chart::fill(int _zz, int _nn, double _val)
{
    if(std::isnan(_val)) return;
    hzn.Fill(_nn,_zz,_val);
}
 
double tknuclear_chart::get_value(int _zz, int _nn)
{
    return hzn.GetBinContent(_nn,_zz);
}
 
void tknuclear_chart::set_value(int _zz, int _nn, double _val)
{
    if(std::isnan(_val)) return;
    if(_val==0.)_val=-9999999;
    hzn.SetBinContent(hzn.FindBin(_nn,_zz),_val);
}
 
void tknuclear_chart::calculate_projections()
{
    if(mgrz.GetListOfGraphs()) mgrz.GetListOfGraphs()->Clear();
    if(mgrn.GetListOfGraphs()) mgrn.GetListOfGraphs()->Clear();
 
    min_val = 9999999.;
    max_val = -9999999.;
    min_z = 9999999.;
    min_n = 9999999.;
    max_z = -9999999.;
    max_n = -9999999.;
 
    for(int i=1 ; i<=hzn.GetNbinsX() ; i++) {
        for(int j=1 ; j<=hzn.GetNbinsY() ; j++) {
            int _nn = hzn.GetXaxis()->GetBinCenter(i);
            int _zz = hzn.GetYaxis()->GetBinCenter(j);
            double _val = hzn.GetBinContent(i,j);
            if(_val==0 || _val==-9999999.) continue;
 
            if(_val>max_val) max_val = _val;
            if(_val<min_val) min_val = _val;
 
            if(_zz>max_z) max_z = _zz;
            if(_zz<min_z) min_z = _zz;
 
            if(_nn>max_n) max_n = _nn;
            if(_nn<min_n) min_n = _nn;
 
            TGraph* gg = nullptr;
            if(!mgrz.GetListOfGraphs()||!(gg = (TGraph*)mgrz.GetListOfGraphs()->FindObject(Form("%s_N%d",chart_title.Data(),_nn)))){
                gg = new TGraph;
                gg->SetNameTitle(Form("%s_N%d",chart_title.Data(),_nn),Form("%d",_nn));
                gg->SetMarkerStyle(7);
                gg->SetMarkerColor((_nn%2)?odd_col:even_col);
                gg->SetLineColor((_nn%2)?odd_col:even_col);
                mgrz.Add(gg,"lp");
            }
            gg->SetPoint(gg->GetN(),_val,_zz);
 
            gg = nullptr;
            if(!mgrn.GetListOfGraphs()||!(gg = (TGraph*)mgrn.GetListOfGraphs()->FindObject(Form("%s_Z%d",chart_title.Data(),_zz)))){
                gg = new TGraph;
                gg->SetNameTitle(Form("%s_Z%d",chart_title.Data(),_zz),Form("%d",_nn));
                gg->SetMarkerStyle(7);
                gg->SetMarkerColor((_zz%2)?odd_col:even_col);
                gg->SetLineColor((_zz%2)?odd_col:even_col);
                mgrn.Add(gg,"lp");
            }
            gg->SetPoint(gg->GetN(),_nn,_val);
        }
    }
    if(hzn.GetEntries()==0) {
        min_val=0;max_val=1.;
    }
 
//    if(min_val==(-9999999)) min_val=1;
}
 
void tknuclear_chart::reset()
{
    hzn.Reset();
}
 
void tknuclear_chart::draw(bool _update_only)
{
    gStyle->SetOptTitle(0);
    gStyle->SetOptStat(0);
 
    set_editables(true);
 
    calculate_projections();
    if(!_update_only) {
        draw_canvas();
 
        if(autofit && hzn.GetEntries()){
            hzn.GetXaxis()->SetRangeUser(min_n-2,max_n+2);
            hzn.GetYaxis()->SetRangeUser(min_z-2,max_z+2);
 
            hn.GetXaxis()->SetRangeUser(min_n-2,max_n+2);
            hz.GetYaxis()->SetRangeUser(min_z-2,max_z+2);
        }
    }
 
    p1->cd();
    hzn.Draw("col");
    set_axis_att(hzn.GetXaxis());
    set_axis_att(hzn.GetYaxis());
 
    draw_lines(2);
    draw_lines(8);
    draw_lines(20);
    draw_lines(28);
    draw_lines(50);
    draw_lines(82);
    draw_lines(126);
    hzn.Draw("col,same");
    if(!fset_min_val) hzn.GetZaxis()->SetRangeUser(min_val,max_val);
    else hzn.GetZaxis()->SetRangeUser(min_val_histo,max_val);
 
    p2->cd();
    hz.GetXaxis()->SetLimits(min_val*0.9,max_val*1.1);
 
    hz.Draw();
    TAxis* ax = hz.GetXaxis();
    double min = ax->GetXmin();
    double max = ax->GetXmax();
 
    draw_line(2, min, max);
    draw_line(8, min, max);
    draw_line(20, min, max);
    draw_line(28, min, max);
    draw_line(50, min, max);
    draw_line(82, min, max);
 
    mgrz.Draw("pl");
 
    ax = hz.GetYaxis();
    ax->SetTitle("proton number");
    ax->SetTitleOffset(1.2);
    set_axis_att(ax);
    ax->SetNdivisions(ndivy);
 
    ax = hz.GetXaxis();
    set_axis_att(ax);
 
    p3->cd();
    hn.GetYaxis()->SetLimits(min_val*0.9,max_val*1.1);
    hn.Draw();
 
    ax = hn.GetYaxis();
    min = ax->GetXmin();
    max = ax->GetXmax();
 
    draw_line(2, min, max,0);
    draw_line(8, min, max,0);
    draw_line(20, min, max,0);
    draw_line(28, min, max,0);
    draw_line(50, min, max,0);
    draw_line(82, min, max,0);
    draw_line(126, min, max,0);
 
    mgrn.Draw("pl");
 
    ax = hn.GetXaxis();
    ax->SetTitle("neutron number");
    ax->SetTitleOffset(.9);
    set_axis_att(ax);
    ax->SetNdivisions(ndivx);
 
    ax = hn.GetYaxis();
    set_axis_att(ax);
 
    p4->cd();
    draw_axes();
 
    delete ftitletex;
    ftitletex = new TLatex(0.625,0.98,chart_title);
    ftitletex->SetTextAlign(22);
    ftitletex->SetTextSize(.03);
    ftitletex->SetTextFont(42);
    ftitletex->Draw();
 
    if(cc&&p1&&p2&&p3){}
    else return;
 
    p1->Modified(); p1->Update();
    p2->Modified(); p2->Update();
    p3->Modified(); p3->Update();
    cc->Modified();
    cc->Update();
 
    set_editables(false);
}
 
void tknuclear_chart::set_log_scale(bool _log)
{
    if(cc&&p1&&p2&&p3){}
    else return;
 
    p1->SetLogz(_log);
    p2->SetLogx(_log);
    p3->SetLogy(_log);
}
 
 
void tknuclear_chart::draw_lines(int nz)
{
    double xxmin = hzn.GetXaxis()->GetBinLowEdge(hzn.GetXaxis()->GetFirst());
    double xxmax = hzn.GetXaxis()->GetBinUpEdge(hzn.GetXaxis()->GetLast());
    double yymin = hzn.GetYaxis()->GetBinLowEdge(hzn.GetYaxis()->GetFirst());
    double yymax = hzn.GetYaxis()->GetBinUpEdge(hzn.GetYaxis()->GetLast());
 
    if(nz>xxmax||nz<xxmin) {}
    else{
        TLine *ll = new TLine(nz,yymin,nz,yymax);
        ll->SetLineColor(kGray);
        ll->SetLineWidth(kLineWidth);
        ll->Draw();}
 
    if(nz>yymax||nz<yymin) {}
    else if(nz<120) {
        TLine *ll = new TLine(xxmin,nz,xxmax,nz);
        ll->SetLineColor(kGray);
        ll->SetLineWidth(kLineWidth);
        ll->Draw();
    }
}
 
void tknuclear_chart::draw_line(int nz, double min, double max, bool onx)
{
 
    TLine* ll = 0;
    if(onx) {
        double xxmin = hz.GetYaxis()->GetBinLowEdge(hzn.GetYaxis()->GetFirst());
        double xxmax = hz.GetYaxis()->GetBinUpEdge(hzn.GetYaxis()->GetLast());
        if(nz>xxmax||nz<xxmin) return;
 
        ll = new TLine(min,nz,max,nz);
        ll->SetLineColor(kGray);
        ll->SetLineWidth(kLineWidth);
        ll->Draw();
    }
    else {
        double xxmin = hn.GetXaxis()->GetBinLowEdge(hzn.GetXaxis()->GetFirst());
        double xxmax = hn.GetXaxis()->GetBinUpEdge(hzn.GetXaxis()->GetLast());
        if(nz>xxmax||nz<xxmin) return;
 
        ll = new TLine(nz,min,nz,max);
        ll->SetLineColor(kGray);
        ll->SetLineWidth(kLineWidth);
        ll->Draw();
    }
 
}
 
void tknuclear_chart::set_size(int _width, int _height)
{
    width = _width;
    height = _height;
    xratio = ((double)height)/((double)width);
    xoffset = 0.7 - (1-(1.-0.7-.08)*xratio-.08);
}
 
 
void tknuclear_chart::draw_canvas()
{
    if(cc&&p1&&p2&&p3){return;}
 
    cc = new TCanvas(Form("canvas_%s",chart_title.Data()),chart_title.Data(),width,height);
    cc->cd();
 
    p1 = new TPad(Form("chartzn_%s",chart_title.Data()),"chartzn",0,0,1,1);
    p1->SetFillStyle(0);
    p1->SetTickx();
    p1->SetTicky();
    p1->SetTopMargin(0.05);
    p1->SetRightMargin(0.05);
    p1->SetBottomMargin(0.3);
    p1->SetLeftMargin(0.3+xoffset);
    p1->SetBit(TObject::kCannotPick);
    p1->Draw();
 
    p2 = new TPad(Form("chartz_%s",chart_title.Data()),"chartz",0.,0,1,1);
    p2->SetFillStyle(0);
    p2->SetTickx();
    p2->SetTicky();
    p2->SetTopMargin(0.05);
    p2->SetBottomMargin(0.3);
    p2->SetRightMargin(0.7-xoffset);
    p2->SetLeftMargin(.08);
    p2->SetBit(TObject::kCannotPick);
    p2->Draw();
 
    p3 = new TPad(Form("chartn_%s",chart_title.Data()),"chartn",0.,0,1,1);
    p3->SetFillStyle(0);
    p3->SetTickx();
    p3->SetTicky();
    p3->SetTopMargin(0.7);
    p3->SetLeftMargin(0.3+xoffset);
    p3->SetRightMargin(.05);
    p3->SetBottomMargin(.08);
    p3->SetBit(TObject::kCannotPick);
    p3->Draw();
 
    p4 = new TPad(Form("control_%s",chart_title.Data()),"chartn",0.,0,1,1);
    p4->SetFillStyle(0);
    p4->SetBit(TObject::kCannotPick);
    p4->Draw();
}
 
void tknuclear_chart::draw_axes()
{
    delete axX;delete axY;delete axZn;delete axZz;
    axX=nullptr;axY=nullptr;axZn=nullptr;axZz=nullptr;
    if(hzn.GetEntries()==0) return;
 
    // X-axes
    axX = new TGaxis(.3+xoffset,0.08,.95,0.08,
                     hn.GetXaxis()->GetBinLowEdge(hn.GetXaxis()->GetFirst()),
                     hn.GetXaxis()->GetBinUpEdge(hn.GetXaxis()->GetLast()),
                     ndivx,"S");
    axX->SetTitle("neutron number");
    axX->SetName("axis1");
    style_axis(axX);
    axX->SetTitleOffset(.9);
    axX->Draw();
 
    axY = new TGaxis(.08,0.3,.08,0.95,
                     hz.GetYaxis()->GetBinLowEdge(hz.GetYaxis()->GetFirst()),
                     hz.GetYaxis()->GetBinUpEdge(hz.GetYaxis()->GetLast()),
                     ndivy,"S");
    axY->SetTitle("proton number");
    axY->SetName("axis2");
    style_axis(axY);
    axY->SetTitleOffset(1.2*xratio);
    axY->Draw();
 
    // Y-axes
    axZn = new TGaxis(.95,0.08,.95,0.3,
                      hn.GetYaxis()->GetBinLowEdge(hn.GetYaxis()->GetFirst()),
                      hn.GetYaxis()->GetBinUpEdge(hn.GetYaxis()->GetLast()),
                      ndivz,"+L");
    axZn->SetName("axis3");
    style_axis(axZn);
    axZn->Draw();
 
    axZz = new TGaxis(.08,0.95,.3+xoffset,0.95,
                      hz.GetXaxis()->GetBinLowEdge(hz.GetXaxis()->GetFirst()),
                      hz.GetXaxis()->GetBinUpEdge(hz.GetXaxis()->GetLast()),
                      ndivz,"-");
    axZz->SetName("axis4");
    axZz->SetLabelOffset(0.01/xratio);
    style_axis(axZz);
    axZz->Draw();
}
 
void tknuclear_chart::style_axis(TGaxis* _ax)
{
    _ax->SetTitleSize(.03);
    _ax->SetLabelSize(.025);
    _ax->SetTickLength(0);
    _ax->SetTickSize(0);
    _ax->SetTextFont(42);
    _ax->SetLabelFont(42);
 
}
 
void tknuclear_chart::set_axis_att(TAxis *_ax, bool _show_labels)
{
    _ax->SetNdivisions(4);
    _ax->SetTitleSize(.03);
    _ax->SetLabelSize(.025);
 
    _ax->SetAxisColor(kWhite);
 
    if(!_show_labels){ _ax->SetLabelColor(kWhite); _ax->SetLabelSize(0); _ax->SetTitle("");}
}
 
void tknuclear_chart::set_editables(bool _ed)
{
    if(cc) cc->SetEditable(_ed);
    if(p1) p1->SetEditable(_ed);
    if(p2) p2->SetEditable(_ed);
    if(p3) p3->SetEditable(_ed);
    if(p4) p4->SetEditable(_ed);
}
 
void tknuclear_chart::set_ndivisions_x(int _ndiv)
{
    ndivx = _ndiv;
    if(cc) {
        axX->SetNdivisions(ndivx);
        p3->Modified(); p3->Update();
    }
}
 
void tknuclear_chart::set_ndivisions_y(int _ndiv)
{
    ndivy = _ndiv;
    if(cc) {
        axY->SetNdivisions(ndivy);
        p2->Modified(); p2->Update();
    }
 
}
 
void tknuclear_chart::set_ndivisions_z(int _ndiv)
{
    ndivz = _ndiv;
    if(cc) {
        axZn->SetNdivisions(ndivz);
        axZz->SetNdivisions(ndivz);
        p2->Modified(); p2->Update();
        p3->Modified(); p3->Update();
    }
}
 
void tknuclear_chart::save_as(const char *file_name)
{
    if(cc) cc->SaveAs(file_name);
}
 
 
void tknuclear_chart::hide_empty_bins()
{
    for(int i=0 ; i<=hzn.GetNbinsX() ; i++) {
        for(int j=0 ; j<=hzn.GetNbinsY() ; j++) {
            if(hzn.GetBinContent(i,j) == -9999999.) {
                hzn.SetBinContent(i,j,0);
            }
            else if(hzn.GetBinContent(i,j) == 0) {
                hzn.SetBinContent(i,j,-9999999.);
            }
        }
    }
    update();
}
 
 
 
ClassImp(tknuclear_chart)