QGHistogram.cc

Go to the documentation of this file.

#include "QGHistogram.hh"
#include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <sstream>
#include <typeinfo>
#include "QChain.hh"
#include "QGCanvasWindow.hh"
#include "QGCutsFrame.hh"
#include "QGFileHandler.hh"
#include "QGHistogramEditWindow.hh"
#include "QGHistogramParametersFrame.hh"
#include "QGPlotFrame.hh"
#include "QGPlotStyleFrame.hh"
#include "QGTextFileKeys.hh"
#include "TCanvas.h"
#include "TRootEmbeddedCanvas.h"
#include "TString.h"
#include "TStyle.h"
#include "TPaveStats.h"
 
#ifdef WIN32
    #include <float.h>
    #define isfinite(x) _finite(x)
#else 
using std::isfinite;
#endif
 
ClassImp(QGHistogram)
 
using std::cout;
using std::endl;
using std::flush;
using std::list;
using std::set;
using std::string;
using std::stringstream;
using std::vector;
 
list<QGHistogram*> QGHistogram::fHistograms;
 
QGHistogram::QGHistogram() :
TH1D(), QGPlot(),
fAutoSetNumberOfBins(true), fAutoSetXMax(true), fAutoSetXMin(true),
fBinWidth(0), fIsBinWidthSet(false), fNumberOfUniqueDataPoints(0),
fStyleHistogram(new TH1D())
{
    this->SetLineColor(0);
    fHistograms.push_back(this);
    SetName();
    SetBit(kCanDelete, kFALSE);
    GetYaxis()->SetTitleOffset(1.35);
    MakeStylePlot();
}
 
QGHistogram::QGHistogram(const QGHistogram &histogram) :
TH1D(histogram), QGPlot(histogram),
fAutoSetNumberOfBins(histogram.fAutoSetNumberOfBins), fAutoSetXMax(histogram.fAutoSetXMax),
fAutoSetXMin(histogram.fAutoSetXMin), fBinWidth(histogram.fBinWidth),
fDataPoints(histogram.fDataPoints), fIsBinWidthSet(histogram.fIsBinWidthSet),
fNumberOfUniqueDataPoints(histogram.fNumberOfUniqueDataPoints), fStyleHistogram(new TH1D())
{
    fHistograms.push_back(this);
    SetName();
    SetBit(kCanDelete, kFALSE);
    MakeStylePlot();
}
 
QGHistogram::~QGHistogram()
{
    if (fPlotEditWindow) {
        fPlotEditWindow->CloseWindow();
        fPlotEditWindow = 0;
    }
    if (find(fHistograms.begin(), fHistograms.end(), this) != fHistograms.end()) {
        fHistograms.erase(find(fHistograms.begin(), fHistograms.end(), this));
    }
    delete fStyleHistogram;
}
 
void QGHistogram::AutoSetAxisParameters()
{
    if (fDataPoints.size() != 0) {
        if (fAutoSetXMin) {
            SetXMin(*min_element(fDataPoints.begin(), fDataPoints.end()) - 0.5);
            if (QGHistogramEditWindow *editWindow = dynamic_cast<QGHistogramEditWindow*>(fPlotEditWindow)) {
                editWindow->GetHistogramParametersFrame()->SetXMin(GetXMin());
            }
        }
        if (fAutoSetXMax) {
            SetXMax(*max_element(fDataPoints.begin(), fDataPoints.end()) + 0.5);
            if (QGHistogramEditWindow *editWindow = dynamic_cast<QGHistogramEditWindow*>(fPlotEditWindow)) {
                editWindow->GetHistogramParametersFrame()->SetXMax(GetXMax());
            }
        }
        if (fAutoSetNumberOfBins) {
            Double_t xRange = GetXMax() - GetXMin();
            if (fIsBinWidthSet && fBinWidth > 0) {
                SetNumberOfBins( (int) ceil(xRange / fBinWidth) );
            }
            else {
                Int_t xRangeIntPart = (Int_t) (GetXMax() - GetXMin());
                Double_t xRangeFracPart = xRange - xRangeIntPart;
                if (xRange < 1000.0 && xRangeFracPart == 0.0) {
                    SetNumberOfBins(xRangeIntPart);
                } else {
                    SetNumberOfBins(100);
                }
            }
            if (QGHistogramEditWindow *editWindow = dynamic_cast<QGHistogramEditWindow*>(fPlotEditWindow)) {
                editWindow->GetHistogramParametersFrame()->SetNumberOfBins(GetNumberOfBins());
            }
        }
    } else {
        if (fAutoSetXMin) {
            SetXMin(0);
        }
        if (fAutoSetXMax) {
            SetXMax(GetXMin() + 1);
        }
        if (fAutoSetNumberOfBins) {
            SetNumberOfBins(1);
        }
        if (QGHistogramEditWindow *editWindow = dynamic_cast<QGHistogramEditWindow*>(fPlotEditWindow)) {
            editWindow->GetHistogramParametersFrame()->SetXMin(GetXMin());
            editWindow->GetHistogramParametersFrame()->SetXMax(GetXMax());
            editWindow->GetHistogramParametersFrame()->SetNumberOfBins(GetNumberOfBins());
        }
    }
    fAutoSetXMin = false;
    fAutoSetXMax = false;
    fAutoSetNumberOfBins = false;
}
 
void QGHistogram::AutoSetStyle()
{
    SetFillStyle(1001); // solid
    Color_t color = 0; // white
    Color_t line_color = 1; //black
    set<Color_t> existingLineColors;
    list<QGHistogram*>::const_iterator histogramIter;
    for (histogramIter = fHistograms.begin(); histogramIter != fHistograms.end(); ++histogramIter) {
        existingLineColors.insert((*histogramIter)->GetLineColor());
    }
    //Insert colors that are too light to see
    existingLineColors.insert(10);
    existingLineColors.insert(5);
    while (existingLineColors.count(line_color) != 0)
        ++line_color;
    SetFillColor(color);
    SetLineColor(line_color);
    MakeStylePlot();
}
 
void QGHistogram::Display()
{
    Reset();
    AutoSetAxisParameters();
    
    // Set style
    if (fStyleHistogram) {
        fStyleHistogram->TAttFill::Copy(*this);
        fStyleHistogram->TAttLine::Copy(*this);
        fStyleHistogram->TAttMarker::Copy(*this);
        if (fPlotEditWindow) {
            fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
            fDrawOption = fStyleHistogram->GetDrawOption();
            if (fDrawOption.find("AH") == 0
             || fDrawOption.find("ah") == 0) {
                fDrawOption.erase(0, 2);
            }
            else if (fDrawOption.find("A") == 0
                  || fDrawOption.find("a") == 0) {
                fDrawOption.erase(0, 1);
            }
            if (fCanvasWindow) {
                fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
            }
        }
    }
    
    // Fill with data
    vector<Double_t>::const_iterator iter;
    for (iter = fDataPoints.begin(); iter != fDataPoints.end(); ++iter) {
        if (GetXMin() <= *iter && *iter < GetXMax()) {
            Fill(*iter);
        }
    }
 
    string xAxisLabel = GetXVariable();
    stringstream yAxisLabelStream;
    yAxisLabelStream.precision(4);
    yAxisLabelStream << "counts / " << (GetXMax()-GetXMin())/GetNumberOfBins() << flush;
    string yAxisLabel = yAxisLabelStream.str();
    if (GetXUnits() != "") {
        xAxisLabel += " (" + GetXUnits() + ")";
        yAxisLabel += " " + GetXUnits();
    }
    GetXaxis()->SetTitle(xAxisLabel.c_str());
    GetYaxis()->SetTitle(yAxisLabel.c_str());
    if (fCanvasWindow) {
        bool drawSuperimposed = false;
        if (fSuperimpose) {
            if (fCanvasWindow->GetDrawnPlots().size() != 0) {
                if (typeid(*fCanvasWindow->GetDrawnPlots().back()) == typeid(*this)) {
                    drawSuperimposed = true;
                }
            }
        }
        if (drawSuperimposed) {
            fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(this);
            string drawOption = fDrawOption + "sames";
            Draw(drawOption.c_str());
            
            fCanvasWindow->RemoveFromDrawnPlots(this);
            fCanvasWindow->AddToDrawnPlots(this);
        } else {
            Draw(fDrawOption.c_str());
            fCanvasWindow->ClearDrawnPlots();
            fCanvasWindow->AddToDrawnPlots(this);
        }
        if (gPad) {
            gPad->Update();
            if(drawSuperimposed) {
                 TPaveStats *s = (TPaveStats*) this->GetListOfFunctions()->FindObject("stats");
                 if(s) s->SetTextColor(this->GetLineColor());
                
            }
            gPad->Modified();
        }
    }
}
 
void QGHistogram::DisplayEditWindow()
{
    if (!fPlotEditWindow) {
        fPlotEditWindow = new QGHistogramEditWindow();
        fPlotEditWindow->SetPlot(this);
        
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->SetEditable(kTRUE);
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
        DrawStyleHistogram();
        fPlotEditWindow->GetPlotStyleFrame()->GetEmbeddedCanvas()->GetCanvas()->SetEditable(kFALSE);
    }
}
 
void QGHistogram::DrawStyleHistogram()
{
    MakeStylePlot();
    string drawOption = "A";
    if (fDrawOption.size() != 0) {
        drawOption += fDrawOption;
    }
    else {
        drawOption += "H";
    }
    fStyleHistogram->Draw(drawOption.c_str());
    if (gPad) {
        gPad->Update();
    }
}
 
void QGHistogram::Duplicate()
{
    QGHistogram *histogram = new QGHistogram(*this);
    histogram->AutoSetStyle();
    histogram->DisplayEditWindow();
}
 
void QGHistogram::Erase()
{
    if (fCanvasWindow) {
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->cd();
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->RecursiveRemove(this);
        fCanvasWindow->GetPlotFrame()->GetEmbeddedCanvas()->GetCanvas()->Update();
        fCanvasWindow->RemoveFromDrawnPlots(this);
        // check whether this was the first drawn plot and if so redraw remaining plots in order to have axes
    }
}
 
void QGHistogram::Generate(QChain *chain)
{
    Reset();
    fDataPoints.clear();
    if (chain == 0) {
        if (fCanvasWindow && fCanvasWindow->GetFileHandler()) {
            if (fCanvasWindow->GetFileHandler()->IsFileOpen()) {
                chain = fCanvasWindow->GetFileHandler()->GetQChain();
            } else {
                cout << "Cannot generate the histogram because there is no file open" << endl;
            }
        }
    }
    if (chain) {
        if (fXVariable == "") {
            cout << "Enter an x-axis variable for the histogram" << endl;
        } else {
            chain->SetEstimate(chain->GetEntries());
            chain->Draw(fXVariable.c_str(), fCutsString.c_str(), "goff");
            Long64_t N = chain->GetSelectedRows();
            if (N > 0) {
                Double_t *dataPoints = chain->GetV1();
                fDataPoints.reserve(N);
                Int_t numberNotFinite = 0;
                for (Int_t i = 0; i < N; ++i) {
                    if (isfinite(dataPoints[i])) {
                        fDataPoints.push_back(dataPoints[i]);
                    } else {
                        ++numberNotFinite;
                    }
                }
                if (numberNotFinite != 0) {
                    cout << "Warning: " << numberNotFinite << " Inf/NaN values found and ignored" << endl;
                }
            }
        }
    }
}
 
const char *QGHistogram::GetName() const
{
    return TH1D::GetName();
}
 
void QGHistogram::GetParametersFromEditWindow()
{
    if (fPlotEditWindow) {
        if (QGHistogramEditWindow *histogramEditWindow = dynamic_cast<QGHistogramEditWindow*>(fPlotEditWindow)) {
            SetXVariable(histogramEditWindow->GetHistogramParametersFrame()->GetXVariable());
            SetXUnits(histogramEditWindow->GetHistogramParametersFrame()->GetXUnits());
            if (histogramEditWindow->GetHistogramParametersFrame()->IsXMinSet()) {
                SetXMin(histogramEditWindow->GetHistogramParametersFrame()->GetXMin());
                fAutoSetXMin = false;
            } else {
                fAutoSetXMin = true;
            }
            if (histogramEditWindow->GetHistogramParametersFrame()->IsXMaxSet()) {
                SetXMax(histogramEditWindow->GetHistogramParametersFrame()->GetXMax());
                fAutoSetXMax = false;
            } else {
                fAutoSetXMax = true;
            }
            if (histogramEditWindow->GetHistogramParametersFrame()->IsNumberOfBinsSet()) {
                SetNumberOfBins(histogramEditWindow->GetHistogramParametersFrame()->GetNumberOfBins());
                fAutoSetNumberOfBins = false;
            } else {
                fAutoSetNumberOfBins = true;
            }
            fIsBinWidthSet = histogramEditWindow->GetHistogramParametersFrame()->IsBinWidthSet();
            if (fIsBinWidthSet) {
                fBinWidth = histogramEditWindow->GetHistogramParametersFrame()->GetBinWidth();
            }
            else {
                fBinWidth = 0;
            }
            SetSuperimpose(histogramEditWindow->GetHistogramParametersFrame()->IsSuperimposeSet());
        } else {
            cout << "QGHistogram::GetParametersFromEditWindow()        Warning:  dynamic_cast<QGHistogramEditWindow*> failed" << endl;
        }
    }
}
 
Double_t QGHistogram::GetXMin() const
{
    return GetXaxis()->GetXmin();
}
 
Double_t QGHistogram::GetXMax() const
{
    return GetXaxis()->GetXmax();
}
 
Int_t QGHistogram::GetNumberOfBins() const
{
    return GetXaxis()->GetNbins();
}
 
void QGHistogram::MakeStylePlot()
{
    fStyleHistogram->Reset();
    fStyleHistogram->SetBit(kCanDelete, kFALSE);
    fStyleHistogram->SetStats(kFALSE);
    fStyleHistogram->SetBins(5, 0, 5);
    fStyleHistogram->SetBinContent(1, 0);
    fStyleHistogram->SetBinContent(2, 2);
    fStyleHistogram->SetBinContent(3, 3);
    fStyleHistogram->SetBinContent(4, 1);
    fStyleHistogram->SetBinContent(5, 0);
    TAttFill::Copy(*fStyleHistogram);
    TAttLine::Copy(*fStyleHistogram);
    TAttMarker::Copy(*fStyleHistogram);
}
 
void QGHistogram::SetName(const char *name)
{
    if (name) {
        string oldName = TH1D::GetName();
        string newName = name;
        if (newName != oldName) {
            if (IsNameInUse(name)) {
                TH1D::SetName(GeneratePlotName(name).c_str());
            } else {
                TH1D::SetName(name);
            }
        }
    } else {
        TH1D::SetName(GeneratePlotName("Histogram").c_str());
    }
    string styleHistogramName = string(GetName()) + "_StyleHistogram";
    if (fStyleHistogram) {
        fStyleHistogram->SetName(styleHistogramName.c_str());
    }
}
 
void QGHistogram::SetNumberOfBins(Int_t numberOfBins)
{
    SetBins(numberOfBins, GetXMin(), GetXMax());
}
 
void QGHistogram::SetProperty(const string& key, const string& value)
{
    QGPlot::SetProperty(key, value);
    TString valueTString(value);
    if (key == MIN_KEY) {
        if (valueTString.IsFloat()) {
            SetXMin(valueTString.Atof());
            fAutoSetXMin = false;
        }
    }
    else if (key == MAX_KEY) {
        if (valueTString.IsFloat()) {
            SetXMax(valueTString.Atof());
            fAutoSetXMax = false;
        }
    }
    else if (key == NUMBER_OF_BINS_KEY) {
        if (valueTString.IsFloat()) {
            SetNumberOfBins(valueTString.Atoi());
            fAutoSetNumberOfBins = false;
        }
    }
    else if (key == BIN_WIDTH_KEY) {
        if (valueTString.IsFloat()) {
            SetBinWidth(valueTString.Atof());
            fAutoSetNumberOfBins = true;
        }
    }
    else if (key == FILL_COLOR_KEY) {
        if (valueTString.IsFloat()) {
            SetFillColor(valueTString.Atoi());
        }
    }
    else if (key == FILL_STYLE_KEY) {
        if (valueTString.IsFloat()) {
            SetFillStyle(valueTString.Atoi());
        }
    }
    else if (key == LINE_COLOR_KEY) {
        if (valueTString.IsFloat()) {
            SetLineColor(valueTString.Atoi());
        }
    }
    else if (key == LINE_STYLE_KEY) {
        if (valueTString.IsFloat()) {
            SetLineStyle(valueTString.Atoi());
        }
    }
    else if (key == LINE_WIDTH_KEY) {
        if (valueTString.IsFloat()) {
            SetLineWidth(valueTString.Atoi());
        }
    }
    else if (key == MARKER_COLOR_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerColor(valueTString.Atoi());
        }
    }
    else if (key == MARKER_SIZE_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerSize(valueTString.Atof());
        }
    }
    else if (key == MARKER_STYLE_KEY) {
        if (valueTString.IsFloat()) {
            SetMarkerStyle(valueTString.Atoi());
        }
    }
}
 
void QGHistogram::SetXMax(Double_t xMax)
{
    SetBins(GetNumberOfBins(), GetXMin(), xMax);
}
 
void QGHistogram::SetXMin(Double_t xMin)
{
    SetBins(GetNumberOfBins(), xMin, GetXMax());
}