comp_multiFiles.C

Go to the documentation of this file.

#include <iostream>
#include <utility>
#include <algorithm>

using std::cout;
using std::endl;

//* comp_multiFiles.C is a macro to combine identical histograms or graphs from different files in combined histograms.
//* The macro needs an input file (default is "inputFiles.txt") which contains the following information
//* Per line: - file name (optional with complete path) as string which contains the histograms to combine
//*           - identifier used in TLegend of histograms as string
//*           - scaling of histograms as double (to overlay the histograms they can be scaled to match to the same basis)
//*                                             (the macro takes the maximum number and scales all other histograms with maxScale/individualScale)
//* The second input parameter of the macro is the number of histograms to be shown on one canvas (default 9). The position of the canvas is the automatically calculated
//* and new canvasses are automatically created

TCanvas* createCanvas(int picpercan){
        double division = TMath::Sqrt((double)picpercan);
        int first = ceil(division);
        int second = round(division);
        cout << "createCanvas: " << picpercan << " : " << first << "/" << second << endl;
        TCanvas* newCan = new TCanvas();
        newCan->Divide(second, first);
        return newCan;
}

int GetMaxHisto(std::vector<TH1*> histos){
        int index = -1;
        int oldMax = 0;
        for (int i = 0; i < histos.size(); i++){
                if (histos[i]->GetMaximum() > oldMax){
                        oldMax = histos[i]->GetMaximum();
                        index = i;
                }
        }
        return index;
}

struct fileData {
        fileData(std::string fileName, std::string parameter, double scaling) : fFileName(fileName), fParameter(parameter), fScalingFactor(scaling) {};
        std::string fFileName;
        std::string fParameter;
        double fScalingFactor;
};

std::vector<fileData> GetFileNames(std::string inputFile)
{
        std::vector<fileData> listOfFiles;
        std::string fileName;
        std::string parameter;
        double scalingFactor;

        std::ifstream in(inputFile);
        while(in >> fileName >> parameter >> scalingFactor){
                listOfFiles.push_back(fileData(fileName, parameter, scalingFactor));
        }
        return listOfFiles;
}

int comp_multiFiles(std::string listOfFiles_File = "inputFiles.txt", int picpercan = 9) {

        std::vector<TCanvas*> canvasses;
        std::string filter = "";

        std::vector<fileData> fileNames = GetFileNames(listOfFiles_File);
        std::vector<TFile*> files;
        for (auto name : fileNames){
                files.push_back(new TFile(name.fFileName.c_str(), "READ"));
        }

        auto maxScalingFactor = std::max_element(fileNames.begin(), fileNames.end(), [](fileData const& lhs, fileData  const& rhs){return lhs.fScalingFactor < rhs.fScalingFactor;});
        double maxScaling = maxScalingFactor->fScalingFactor;

        std::cout << "Max Scaling Factor: " << maxScalingFactor->fScalingFactor << std::endl;
        if (files.size() < 2)
                return 1;
        TFile *f = files[0];
        if (!f->IsZombie()) {
                TKey *key;
                TIter next(f->GetListOfKeys());

                int failcount = 0;
                Int_t yy = 0;
                Int_t actualCanvas = 0;
                Int_t actualPad = 0;
                Int_t i = 0;
                while ((key = (TKey*) next())) {

                        TObject *obj = key->ReadObj();
                        TString name = obj->GetName();
                        std::cout << name << std::endl;
                        if (!name.Contains(filter.c_str())) continue;

                        actualCanvas = TMath::Floor((double)yy / picpercan);
                        actualPad = (yy % picpercan) + 1;
                        cout << yy << " : " << actualCanvas << "/" << actualPad << endl;
                        if (!(canvasses.size() > actualCanvas)){
                                cout << "New canvas" << endl;
                                canvasses.push_back(createCanvas(picpercan));
                        }
                        canvasses[actualCanvas]->cd(actualPad);
                        yy++;

                        // only check TH1Fs
                        if (obj->InheritsFrom("TH1")){
                                TH1* h = (TH1*) obj;
                                h->Scale(maxScaling/fileNames[0].fScalingFactor);
                                h->SetLineWidth(2);
                                std::vector<TH1*> histos;
                                histos.push_back(h);
                                for (int i = 1; i < files.size(); i++){
                                        TH1* currentHisto = (TH1*)files[i]->Get(name);
                                        currentHisto->Scale(maxScaling/fileNames[i].fScalingFactor);
                                        histos.push_back(currentHisto);
                                        currentHisto->SetLineColor(i);
                                        currentHisto->SetLineWidth(2);
                                }
                                int maxHisto = GetMaxHisto(histos);
                                if (maxHisto > -1){
                                        TLegend* theLegend = new TLegend(0.5,0.55,0.9,0.75);
                                        histos[maxHisto]->Draw();
                                        theLegend->AddEntry(histos[maxHisto], fileNames[maxHisto].fParameter.c_str(),"l");
                                        for (int j = 0; j < histos.size(); j++){
                                                if (j != maxHisto){
                                                        histos[j]->Draw("same");
                                                        theLegend->AddEntry(histos[j], fileNames[j].fParameter.c_str(),"l");
                                                }
                                        }
                                        theLegend->Draw();
                                }
                        }
                        if (obj->InheritsFrom("TGraph")){
                                TString name = obj->GetName();
                                TLegend* aLegend = new TLegend(0.5,0.55,0.9,0.75);
                                TGraph* g = (TGraph*)obj;
                                g->SetMarkerStyle(6);
                                g->Draw("AL");
                                aLegend->AddEntry(g, fileNames[0].fParameter.c_str(),"l");
                                std::vector<TGraph*> graphs;
                                graphs.push_back(g);
                                for (int i = 1; i < files.size(); i++){
                                        TGraph* currentGraph = (TGraph*)files[i]->Get(name);
                                        graphs.push_back(currentGraph);
                                        currentGraph->SetMarkerStyle(6);
                                        currentGraph->SetMarkerColor(i+1);
                                        currentGraph->SetLineColor(i+1);
                                        currentGraph->Draw("L");
                                        aLegend->AddEntry(currentGraph, fileNames[i].fParameter.c_str(),"l");
                                }

                        }
                }
        }
        return 0;
}