TRTCalib_makeplots.cxx File Reference

#include "CxxUtils/checker_macros.h"
#include <fstream>
#include <sstream>
#include <iomanip>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <iostream>
#include <exception>
#include <TNtuple.h>
#include <TFile.h>
#include <TKey.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TGraphErrors.h>
#include <TF1.h>
#include <TStyle.h>
#include <TCanvas.h>
#include <THStack.h>
#include <TLine.h>
#include <TLegend.h>
#include <TLegendEntry.h>
#include <TEventList.h>
#include <TPad.h>
#include <TPaveText.h>
#include <TPaveStats.h>
#include <TPaletteAxis.h>
#include <TProfile.h>
#include <TROOT.h>
#include <TError.h>
#include <TVectorD.h>
#include <map>
#include <string>
#include <vector>
#include <stdexcept>

Go to the source code of this file.

Classes
class	TextPage
class	NHitStack
class	HitStatistics
class	XYMaps
class	T0CalTypeXY
class	T0CalibTypeXY
class	ChipVariations
class	BoardVariations
class	BoardVariationsDiff
class	BoardVariationsOldT0
class	BoardVariationsRes
class	BoardVariationsTRes1
class	BoardVariationsTRes
class	DvGraph
class	DGraph
class	RtGraphs
class	XYMapsEC
class	RtColor
class	ResidualPlots
class	TRTPlots
class	TBinnedRes
class	RtBinning
class	RresTbin
class	FirstPage
class	SettingsInfo
class	TrackTupleInfo
class	PtDependence
class	TBDependence
class	ToTDependence
class	SinDependence

Functions
void	SetZAxis (TH2F *reshist0)
void	ResizePalette (TH2 *hist)
string	trim (string s)
TGraphErrors *	GetMean (TH2F *histo)
TGraphErrors *	GetMeanE (TH2F *histo)
TGraphErrors *	GetPn (TH2F *histo)
TGraphErrors *	GetWidth (TH2F *histo)
TGraphErrors *	GetEntries (TH2F *histo)
TGraphErrors *	GetPWidth (TH2F *histo)
int	itersum (int argc, char *argv[])
int	tt_remove (int, char *argv[])
int	main (int argc, char *argv[])

Variables
	ATLAS_NO_CHECK_FILE_THREAD_SAFETY
bool	do_expert = false
char	detlet [3] = {'C', '-', 'A'}

Function Documentation

GetEntries()

TGraphErrors* GetEntries

(

TH2F *

histo

)

Definition at line 4019 of file TRTCalib_makeplots.cxx.

{
    if (!histo)
        return nullptr;
    int const nxbins = histo->GetNbinsX();
    TGraphErrors *Means = new TGraphErrors(nxbins);
    float mean = 0;
    float rms = 0;
    TF1 *ff = new TF1("ff", "gaus");
    for (int i = 0; i < nxbins; i++)
    {
        TH1D *slice = histo->ProjectionY("slice", i + 1, i + 1);
        mean = slice->GetEntries();
        rms = sqrt(mean);
        float x = histo->GetBinCenter(i + 1);
        Means->SetPoint(i, x, mean);
        Means->SetPointError(i, 0.5 * histo->GetBinWidth(i), rms);
        delete slice;
    }
    delete ff;
    return Means;
}

GetMean()

TGraphErrors* GetMean

(

TH2F *

histo

)

Definition at line 3907 of file TRTCalib_makeplots.cxx.

{
 
    if (!histo)
        return nullptr;
    int const nxbins = histo->GetNbinsX();
    TGraphErrors *Means = new TGraphErrors(nxbins);
    float mean = 0;
    float rms = 0;
    TF1 *ff = new TF1("ff", "gaus");
    for (int i = 0; i < nxbins; i++)
    {
        TH1D *slice = histo->ProjectionY("slice", i + 1, i + 1);
        mean = slice->GetMean();
        rms = slice->GetRMS();
        ff->SetParameter(0, slice->GetEntries());
        ff->SetParameter(1, mean);
        ff->SetParameter(2, rms);
        mean = ff->GetParameter(1);
        rms = ff->GetParameter(2);
        float x = histo->GetBinCenter(i + 1);
        Means->SetPoint(i, x, mean);
        Means->SetPointError(i, 0.5 * histo->GetBinWidth(i), ff->GetParError(1));
        delete slice;
    }
    delete ff;
    return Means;
}

GetMeanE()

TGraphErrors* GetMeanE

(

TH2F *

histo

)

Definition at line 3936 of file TRTCalib_makeplots.cxx.

{
 
    if (!histo)
        return nullptr;
    int const nxbins = histo->GetNbinsX();
    TGraphErrors *Means = new TGraphErrors(nxbins);
    float mean = 0;
    // float rms = 0;
    TF1 *ff = new TF1("ff", "gaus");
    for (int i = 0; i < nxbins; i++)
    {
        TH1D *slice = histo->ProjectionY("slice", i + 1, i + 1);
        mean = slice->GetMean();
        // rms = slice->GetRMS();
        float x = histo->GetBinCenter(i + 1);
        Means->SetPoint(i, x, mean);
        Means->SetPointError(i, 0.5 * histo->GetBinWidth(i), ff->GetParError(1));
        delete slice;
    }
    delete ff;
    return Means;
}

GetPn()

TGraphErrors* GetPn

(

TH2F *

histo

)

Definition at line 3960 of file TRTCalib_makeplots.cxx.

{
 
    if (!histo)
        return nullptr;
    int const nxbins = histo->GetNbinsX();
    TGraphErrors *Means = new TGraphErrors(nxbins);
    float mean = 0;
    // float rms = 0;
    TF1 *ff = new TF1("ff", "gaus");
    for (int i = 0; i < nxbins; i++)
    {
        TH1D *slice = histo->ProjectionY("slice", i + 1, i + 1);
        mean = slice->GetEntries();
        float x = histo->GetBinCenter(i + 1);
        Means->SetPoint(i, x, mean);
        Means->SetPointError(i, 0.5 * histo->GetBinWidth(i), ff->GetParError(1));
        delete slice;
    }
    delete ff;
    return Means;
}

GetPWidth()

TGraphErrors* GetPWidth

(

TH2F *

histo

)

Definition at line 4042 of file TRTCalib_makeplots.cxx.

{
    if (!histo)
        return nullptr;
    int const nxbins = histo->GetNbinsX();
    TGraphErrors *Means = new TGraphErrors(nxbins);
    float mean = 0;
    float rms = 0;
    TF1 *ff = new TF1("ff", "gaus");
    for (int i = 0; i < nxbins; i++)
    {
        TH1D *slice = histo->ProjectionY("slice", i + 1, i + 1);
        mean = slice->GetMean();
        rms = slice->GetRMS();
        ff->SetParameter(0, slice->GetEntries());
        ff->SetParameter(1, mean);
        ff->SetParameter(2, rms);
        // int fitresult = slice->Fit("ff", "QR", "", -2.5, +2.5);
        mean = ff->GetParameter(1);
        rms = ff->GetParameter(2);
        // fitresult = slice->Fit("ff", "QR", "", -2.5, 2.5);
        mean = ff->GetParameter(1);
        rms = ff->GetParameter(2);
        // fitresult = slice->Fit("ff", "QR", "", -2.5, 2.5);
        float x = histo->GetBinCenter(i + 1);
        Means->SetPoint(i, x, rms);
        Means->SetPointError(i, 0.5 * histo->GetBinWidth(i), ff->GetParError(2));
        delete slice;
    }
    delete ff;
    return Means;
}

GetWidth()

TGraphErrors* GetWidth

(

TH2F *

histo

)

Definition at line 3983 of file TRTCalib_makeplots.cxx.

{
    if (!histo)
        return nullptr;
    int const nxbins = histo->GetNbinsX();
    TGraphErrors *Means = new TGraphErrors(nxbins);
    float mean = 0;
    float rms = 0;
    TF1 *ff = new TF1("ff", "gaus");
    for (int i = 0; i < nxbins; i++)
    {
        TH1D *slice = histo->ProjectionY("slice", i + 1, i + 1);
        mean = slice->GetMean();
        rms = slice->GetRMS();
        ff->SetParameter(0, slice->GetEntries());
        ff->SetParameter(1, mean);
        ff->SetParameter(2, rms);
        // int fitresult = slice->Fit("ff", "QR", "", mean - 1.5 * rms, mean + 1.5 * rms);
        mean = ff->GetParameter(1);
        rms = ff->GetParameter(2);
        for (int j = 0; j < 6; j++)
        {
            // fitresult = slice->Fit("ff", "QR", "", mean - 1.5 * rms, mean + 1.5 * rms);
            mean = ff->GetParameter(1);
            rms = ff->GetParameter(2);
        }
        // fitresult = slice->Fit("ff", "QR", "", mean - 1.5 * rms, mean + 1.5 * rms);
        float x = histo->GetBinCenter(i + 1);
        Means->SetPoint(i, x, rms);
        Means->SetPointError(i, 0.5 * histo->GetBinWidth(i), ff->GetParError(2));
        delete slice;
    }
    delete ff;
    return Means;
}

itersum()

int itersum	(	int	argc,
		char *	argv[]
	)

Definition at line 5113 of file TRTCalib_makeplots.cxx.

{
 
    string inputfile = string(argv[2]);
    TFile *datafile = new TFile(argv[2]);
    if (datafile->IsZombie())
    {
        cout << "ERROR! INPUT FILE DOES NOT EXIST!" << endl;
        exit(-1);
    }
 
    bool isAr = false;
    if (datafile->FindKey("TRT_Ar_all"))
    {
        isAr = true;
        cout << " This run contains straws with Argon" << endl;
    }
    if (!datafile->FindKey("Chip_Artuple"))
    {
        isAr = false;
        cout << " This run contains does not have Argon ntuples" << endl;
    }
 
    // Here we have to do the fix, because the trees are duplicated
 
    TFile *refdatafile;
    bool useref = false;
    if (argc > 4)
    {
        useref = true;
        refdatafile = new TFile(argv[4]);
        if (refdatafile->IsZombie())
        {
            cout << "INPUT REFERENCE FILE DOES NOT EXIST! RUNNING WITHOUT IT!" << endl;
            useref = false;
        }
        else
            cout << "INPUT REFERENCE FILE OK!" << endl;
    }
 
    // First page on Shifter report, general information
    cout << "MAKING FirstPage" << endl;
    FirstPage *firstpage = nullptr;
    try
    {
        firstpage = new FirstPage(argv[2], datafile);
    }
    catch (string e)
    {
        cout << e << endl;
    }
 
    // Add a page with the settings:
    cout << "MAKING Settings" << endl;
    SettingsInfo *settings = nullptr;
    // if (argv[3]) try { settings = new SettingsInfo(argv[3]); } catch (string e) { cout << e << endl; }
 
    // Tracktuple info
    cout << "MAKING TracktupleInfo" << endl;
    TrackTupleInfo *tracktupleinfo = nullptr;
    try
    {
        tracktupleinfo = new TrackTupleInfo(datafile);
    }
    catch (string e)
    {
        cout << e << endl;
    }
 
    // Hit statistics
    HitStatistics *hitstat = nullptr;
    cout << "MAKING HitStatistics" << endl;
    hitstat = new HitStatistics(argv[2]);
 
    HitStatistics *hitstatAr = nullptr;
    if (isAr)
    {
        cout << "MAKING Ar HitStatistics" << endl;
        hitstatAr = new HitStatistics(argv[2], true);
    }
 
    // TRT Global Results:
    cout << "MAKING TRTPlots" << endl;
    // SERGI - What is the purpose of the lines commented below? (TRTPlots *TRTresplots and *TRTresplotsAr are not used at anywhere)
    // TRTPlots *TRTresplots = nullptr;
    // try
    // {
    //     TRTresplots = new TRTPlots(datafile);
    // }
    // catch (string e)
    // {
    //     cout << e << endl;
    // }
    // TRTPlots *TRTresplotsAr = nullptr;
    if (isAr)
        // try
        // {
        //     TRTresplotsAr = new TRTPlots(datafile, true);
        // }
        // catch (string e)
        // {
        //     cout << e << endl;
        // }
 
    // Residual and time residual (TRT and both barrels)
    cout << "MAKING ResidualPlots" << endl;
    ResidualPlots *resplots = nullptr;
    try
    {
        resplots = new ResidualPlots(datafile);
    }
    catch (string e)
    {
        cout << e << endl;
    }
    ResidualPlots *resplotsAr = nullptr;
    if (isAr)
        try
        {
            resplotsAr = new ResidualPlots(datafile, true);
        }
        catch (string e)
        {
            cout << e << endl;
        }
 
    // Do t0 calibration type:
    cout << "MAKING T0CalibTypeXY" << endl;
    T0CalibTypeXY *hitstatxy = new T0CalibTypeXY(argv[2]);
    T0CalibTypeXY *hitstatxyAr = nullptr;
    if (isAr)
        hitstatxyAr = new T0CalibTypeXY(argv[2], true);
 
    // Do hits plots:
    cout << "MAKING XYMaps(nt0)" << endl;
    XYMaps *nhits = new XYMaps(argv[2], "nt0");
    XYMaps *nhitsAr = nullptr;
    if (isAr)
        nhitsAr = new XYMaps(argv[2], "nt0", true);
    // Do res plot:
    cout << "MAKING XYMaps(res)" << endl;
    XYMaps *resxy0 = new XYMaps(argv[2], "res");
    XYMaps *resxy0Ar = nullptr;
    if (isAr)
        resxy0Ar = new XYMaps(argv[2], "res", true);
    // Do residual center plot:
    cout << "MAKING XYMaps(resmean)" << endl;
    XYMaps *resxy = new XYMaps(argv[2], "abs(resMean)");
    XYMaps *resxyAr = nullptr;
    if (isAr)
        resxyAr = new XYMaps(argv[2], "abs(resMean)", true);
    // Do t0s plots:
    cout << "MAKING XYMaps(t0)" << endl;
    XYMaps *xymap = new XYMaps(argv[2], "t0");
    XYMaps *xymapAr = nullptr;
    if (isAr)
        xymapAr = new XYMaps(argv[2], "t0", true);
    // Do Oldt0plots:
    cout << "MAKING XYMaps(oldt0)" << endl;
    XYMaps *oldt0 = new XYMaps(argv[2], "oldt0");
    XYMaps *oldt0Ar = nullptr;
    if (isAr)
        oldt0Ar = new XYMaps(argv[2], "oldt0", true);
    // Do t0 diff:
    cout << "MAKING XYMaps(t0-oldt0)" << endl;
    XYMaps *oldt01 = new XYMaps(argv[2], "abs(t0-oldt0)");
    XYMaps *oldt01Ar = nullptr;
    if (isAr)
        oldt01Ar = new XYMaps(argv[2], "abs(t0-oldt0)", true); // changed from t0-old-t0
    // Do t0 diff mean:
    cout << "MAKING XYMaps(tresMean)" << endl;
    XYMaps *oldt0111 = new XYMaps(argv[2], "abs(tresMean)");
    XYMaps *oldt0111Ar = nullptr;
    if (isAr)
        oldt0111Ar = new XYMaps(argv[2], "abs(tresMean)", true);
    // Do t0 width:
    cout << "MAKING XYMaps(tres)" << endl;
    XYMaps *oldt011 = new XYMaps(argv[2], "(tres)");
    XYMaps *oldt011Ar = nullptr;
    if (isAr)
        oldt011Ar = new XYMaps(argv[2], "(tres)", true);
 
    // Add the plot for Chip T0 (board offset) variations
    ChipVariations *chipgraphA = nullptr;
    ChipVariations *chipgraphC = nullptr;
    if (datafile->FindKey("TRT_all"))
    {
        cout << "MAKING ChipVariations" << endl;
        chipgraphA = new ChipVariations(argv[2], 1);
        chipgraphC = new ChipVariations(argv[2], -1);
    }
 
    // Add the plot for Board T0 variations
    BoardVariationsOldT0 *refboardgraphA = nullptr;
    BoardVariationsOldT0 *refboardgraphC = nullptr;
    BoardVariationsDiff *boarddiffgraphA = nullptr;
    BoardVariationsDiff *boarddiffgraphC = nullptr;
    if (useref)
    {
        cout << "MAKING BoardVariationsOldT0" << endl;
        refboardgraphA = new BoardVariationsOldT0(argv[4], 1);
        refboardgraphC = new BoardVariationsOldT0(argv[4], -1);
        refboardgraphA->SetLineColor(2);
        refboardgraphC->SetLineColor(2);
        cout << "MAKING BoardVariationsDiff" << endl;
        boarddiffgraphA = new BoardVariationsDiff(argv[2], argv[4], 1);
        boarddiffgraphC = new BoardVariationsDiff(argv[2], argv[4], -1);
    }
    // Add the plot for Board T0 variations
    cout << "MAKING BoardVariations" << endl;
    BoardVariations *boardgraphA = new BoardVariations(argv[2], 1);
    BoardVariations *boardgraphC = new BoardVariations(argv[2], -1);
    // Add the plot for the residual
    cout << "MAKING BoardVariationsRes" << endl;
    BoardVariationsRes *boardgraphA1 = new BoardVariationsRes(argv[2], 1);
    BoardVariationsRes *boardgraphC1 = new BoardVariationsRes(argv[2], -1);
    // Add the plot for the Time residual
    cout << "MAKING BoardVariationsTRes" << endl;
    BoardVariationsTRes *boardgraphA2 = new BoardVariationsTRes(argv[2], 1);
    BoardVariationsTRes *boardgraphC2 = new BoardVariationsTRes(argv[2], -1);
    // Add the plot for the sigma Time residual
    cout << "MAKING BoardVariationsTRes1" << endl;
    BoardVariationsTRes1 *boardgraphA3 = new BoardVariationsTRes1(argv[2], 1);
    BoardVariationsTRes1 *boardgraphC3 = new BoardVariationsTRes1(argv[2], -1);
 
    // RtGraphs* rtrelation11=nullptr;
    RtGraphs *rtrelation_bar = nullptr;
    RtGraphs *rtrelation21 = nullptr;
    RtGraphs *rtrelation31 = nullptr;
    RtGraphs *rtrelation41 = nullptr;
    RtGraphs *rtrelation51 = nullptr;
    RtBinning *rtbinning_bar = nullptr;
    RtBinning *rtbinning1 = nullptr;
    RtBinning *rtbinning2 = nullptr;
    RtBinning *rtbinning3 = nullptr;
    RtBinning *rtbinning4 = nullptr;
    if (datafile->FindKey("TRT_all"))
    {
        cout << "MAKING RtGraphs" << endl;
        TDirectory *trt = (TDirectory *)datafile->FindKey("TRT_all")->ReadObj();
 
        if (trt->FindKey("WholeBarrel_1"))
        {
            try
            {
                rtrelation_bar = new RtGraphs(argv[2], "WholeBarrel_1");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
        if (trt->FindKey("Detector_-1"))
        {
            try
            {
                rtrelation21 = new RtGraphs(argv[2], "Detector_-1");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
        if (trt->FindKey("Detector_1"))
        {
            try
            {
                rtrelation31 = new RtGraphs(argv[2], "Detector_1");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
        if (trt->FindKey("Detector_-2"))
        {
            try
            {
                rtrelation41 = new RtGraphs(argv[2], "Detector_-2");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
        if (trt->FindKey("Detector_2"))
        {
            try
            {
                rtrelation51 = new RtGraphs(argv[2], "Detector_2");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
        // r plots for each t-bin
        cout << "MAKING Rt binning" << endl;
 
        // No Xenon for Barrel in Run3
        // rtbinning_bar=new RtBinning(trt,"WholeBarrel_1");
        // cout << "MAKING Rt binning for Detector_-1" << endl;
        // rtbinning1=new RtBinning(trt,"Detector_-1");
        // cout << "MAKING Rt binning for Detector_1" << endl;
        // rtbinning2=new RtBinning(trt,"Detector_1");
        cout << "MAKING Rt binning for Detector_-2" << endl;
        rtbinning3 = new RtBinning(trt, "Detector_-2");
        cout << "MAKING Rt binning for Detector_2" << endl;
        rtbinning4 = new RtBinning(trt, "Detector_2");
    }
 
    // Binned residual plots
    RresTbin *binres_bar = nullptr;
    RresTbin *binres1 = nullptr;
    RresTbin *binres2 = nullptr;
    RresTbin *binres3 = nullptr;
    RresTbin *binres4 = nullptr;
    TBinnedRes *tbinnedres_bar = nullptr;
    TBinnedRes *tbinnedres1 = nullptr;
    TBinnedRes *tbinnedres2 = nullptr;
    TBinnedRes *tbinnedres3 = nullptr;
    TBinnedRes *tbinnedres4 = nullptr;
 
    cout << "MAKING Binned Residual" << endl;
    // No Xenon hists for Barrel in Run3
    // binres_bar=new RresTbin(datafile,"WholeBarrel_1",4);
    // tbinnedres_bar=new TBinnedRes(datafile,binres_bar->reshists);
    // cout << "MAKING Binned Residual for Detector_-1" << endl;
    // binres1=new RresTbin(datafile,"Detector_-1",-1);
    // tbinnedres1=new TBinnedRes(datafile,binres1->reshists);
    // cout << "MAKING Binned Residual for Detector_1" << endl;
    // binres2=new RresTbin(datafile,"Detector_1",1);
    // tbinnedres2=new TBinnedRes(datafile,binres2->reshists);
    cout << "MAKING Binned Residual for Detector_-2" << endl;
    binres3 = new RresTbin(datafile, "Detector_-2", -2);
    tbinnedres3 = new TBinnedRes(datafile, binres3->reshists);
    cout << "MAKING Binned Residual for Detector_2" << endl;
    binres4 = new RresTbin(datafile, "Detector_2", 2);
    tbinnedres4 = new TBinnedRes(datafile, binres4->reshists);
 
    RtColor *rtcol = nullptr;
    RtColor *rtcol1 = nullptr;
    RtColor *rtcol2 = nullptr;
    RtColor *rtcol3 = nullptr;
    RtColor *rtcol4 = nullptr;
    RtColor *rtcol5 = nullptr;
    // Rt relation, default plot
    cout << "MAKING RtColor" << endl;
 
    if (datafile->FindKey("TRT_all"))
    {
        cout << "    found TRT_all " << endl;
 
        // no Xenon RtColor plot for entire TRT
        // rtcol= new RtColor(argv[2],"");
 
        TDirectory *trt = (TDirectory *)datafile->FindKey("TRT_all")->ReadObj();
 
        // No Xenon Rt plots for barrel in Run3
        /*
        if (trt->FindKey("WholeBarrel_1")){
        cout << "    MAKING RtColor WholeBarrel" << endl;
        try {rtcol1= new RtColor(argv[2],"WholeBarrel_1");}
        catch (string e){cout << e << endl;}
        }
 
 
        if (trt->FindKey("Detector_-1")){
          cout << "    MAKING RtColor Detector_-1" << endl;
          try {rtcol2= new RtColor(argv[2],"Detector_-1");}
          catch (string e){cout << e << endl;}
        }
 
        if (trt->FindKey("Detector_1")){
          cout << "    MAKING RtColor Detector_1" << endl;
          try {rtcol3= new RtColor(argv[2],"Detector_1");}
          catch (string e){cout << e << endl;}
        }
        */
 
        if (trt->FindKey("Detector_-2"))
        {
            cout << "    MAKING RtColor Detector_-2" << endl;
            try
            {
                rtcol4 = new RtColor(argv[2], "Detector_-2");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
 
        if (trt->FindKey("Detector_2"))
        {
            cout << "    MAKING RtColor Detector_2" << endl;
            try
            {
                rtcol5 = new RtColor(argv[2], "Detector_2");
            }
            catch (string e)
            {
                cout << e << endl;
            }
        }
    }
    // ARGON!!
    // SERGI - Is this actually used for something????
    // RtGraphs *rtArrelation_bar = nullptr;
    // RtGraphs *rtArrelation21 = nullptr;
    // RtGraphs *rtArrelation31 = nullptr;
    // RtGraphs *rtArrelation41 = nullptr;
    // RtGraphs *rtArrelation51 = nullptr;
    // RtBinning *rtArbinning_bar = nullptr;
    // RtBinning *rtArbinning1 = nullptr;
    // RtBinning *rtArbinning2 = nullptr;
    // RtBinning *rtArbinning3 = nullptr;
    // RtBinning *rtArbinning4 = nullptr;
    // if (datafile->FindKey("TRT_Ar_all"))
    // {
    //     cout << "MAKING AR RtGraphs" << endl;
    //     TDirectory *trtAr = (TDirectory *)datafile->FindKey("TRT_Ar_all")->ReadObj();
 
    //     if (trtAr->FindKey("Detector_Ar_-1/binhist"))
    //     {
    //         cout << "    Found Detector_Ar_-1/binhist" << endl;
    //         rtArbinning1 = new RtBinning(trtAr, "Detector_Ar_-1");
    //         try
    //         {
    //             rtArrelation21 = new RtGraphs(argv[2], "Detector_Ar_-1", true);
    //         }
    //         catch (string e)
    //         {
    //             cout << e << endl;
    //         }
    //     }
 
    //     if (trtAr->FindKey("Detector_Ar_1/binhist"))
    //     {
    //         cout << "    Found Detector_Ar_1/binhist" << endl;
    //         rtArbinning2 = new RtBinning(trtAr, "Detector_Ar_1");
    //         try
    //         {
    //             rtArrelation31 = new RtGraphs(argv[2], "Detector_Ar_1", true);
    //         }
    //         catch (string e)
    //         {
    //             cout << e << endl;
    //         }
    //     }
 
    //     if (trtAr->FindKey("Detector_Ar_-2/binhist"))
    //     {
    //         cout << "    Found Detector_Ar_-2/binhist" << endl;
    //         rtArbinning3 = new RtBinning(trtAr, "Detector_Ar_-2");
    //         try
    //         {
    //             rtArrelation41 = new RtGraphs(argv[2], "Detector_Ar_-2", true);
    //         }
    //         catch (string e)
    //         {
    //             cout << e << endl;
    //         }
    //     }
    //     if (trtAr->FindKey("Detector_Ar_2/binhist"))
    //     {
 
    //         TDirectory *test = (TDirectory *)(((TDirectory *)trtAr->Get("Detector_Ar_2")));
    //         if (test->FindKey("binhist"))
    //         {
    //             cout << "    Found Detector_Ar_2/binhist" << endl;
    //             rtArbinning4 = new RtBinning(trtAr, "Detector_Ar_2");
    //             try
    //             {
    //                 rtArrelation51 = new RtGraphs(argv[2], "Detector_Ar_2", true);
    //             }
    //             catch (string e)
    //             {
    //                 cout << e << endl;
    //             }
    //         }
    //     }
    //     // r plots for each t-bin
    //     cout << "       MAKING AR Rt binning" << endl;
    // }
 
    // Binned residual plots
    // RresTbin *binresAr_bar_bar = nullptr;
    // RresTbin *binresAr_bar1 = nullptr;
    // RresTbin *binresAr_bar2 = nullptr;
    // RresTbin *binresAr_bar3 = nullptr;
    // RresTbin *binresAr_bar4 = nullptr;
    // TBinnedRes *tbinnedArres_bar = nullptr;
    // TBinnedRes *tbinnedArres1 = nullptr;
    // TBinnedRes *tbinnedArres2 = nullptr;
    // TBinnedRes *tbinnedArres3 = nullptr;
    // TBinnedRes *tbinnedArres4 = nullptr;
 
    cout << "MAKING RT Binned Residual for Ar" << endl;
 
    TDirectory *trtAr = (TDirectory *)datafile->FindKey("TRT_Ar_all")->ReadObj();
    // if (trtAr->FindKey("WholeBarrel_Ar_1"))       binresAr_bar_bar        =       new RresTbin(datafile,"WholeBarrel_Ar_1",4);
    // if (trtAr->FindKey("Detector_Ar_-1"))
    //     binresAr_bar1 = new RresTbin(datafile, "Detector_Ar_-1", -1);
    // if (trtAr->FindKey("Detector_Ar_1"))
    //     binresAr_bar2 = new RresTbin(datafile, "Detector_Ar_1", 1);
    // if (trtAr->FindKey("Detector_Ar_-2"))
    //     binresAr_bar3 = new RresTbin(datafile, "Detector_Ar_-2", -2);
    // if (trtAr->FindKey("Detector_Ar_2"))
    //     binresAr_bar4 = new RresTbin(datafile, "Detector_Ar_2", 2);
 
    cout << "MAKING RT Binned Abs Residual for Ar" << endl;
 
    // tbinnedArres_bar      =       new TBinnedRes(datafile,binresAr_bar_bar->reshists);
    // tbinnedArres1 = new TBinnedRes(datafile, binresAr_bar1->reshists);
    // tbinnedArres2 = new TBinnedRes(datafile, binresAr_bar2->reshists);
    // tbinnedArres3 = new TBinnedRes(datafile, binresAr_bar3->reshists);
    // tbinnedArres4 = new TBinnedRes(datafile, binresAr_bar4->reshists);
 
    // RtColor *rtArcol = nullptr;
    // RtColor *rtArcol1 = nullptr;
    RtColor *rtArcol2 = nullptr;
    RtColor *rtArcol3 = nullptr;
    RtColor *rtArcol4 = nullptr;
    RtColor *rtArcol5 = nullptr;
    // Rt relation, default plot
    // if (datafile->FindKey("TRT_Ar_all/rt-relation"))
    // {
    //     cout << "MAKING AR RtColor all TRT" << endl;
    //     try
    //     {
    //         rtArcol = new RtColor(argv[2], "", true);
    //     }
    //     catch (string e)
    //     {
    //         cout << e << endl;
    //     }
    // }
 
    if (trtAr->FindKey("Detector_Ar_-1"))
    {
        cout << "    MAKING AR RtColor det -1" << endl;
        try
        {
            rtArcol2 = new RtColor(argv[2], "Detector_Ar_-1", true);
        }
        catch (string e)
        {
            cout << e << endl;
        }
    }
    if (trtAr->FindKey("Detector_Ar_1"))
    {
        cout << "    MAKING AR RtColor det 1" << endl;
        try
        {
            rtArcol3 = new RtColor(argv[2], "Detector_Ar_1", true);
        }
        catch (string e)
        {
            cout << e << endl;
        }
    }
    if (trtAr->FindKey("Detector_Ar_-2"))
    {
        cout << "    MAKING AR RtColor det -2" << endl;
        try
        {
            rtArcol4 = new RtColor(argv[2], "Detector_Ar_-2", true);
        }
        catch (string e)
        {
            cout << e << endl;
        }
    }
    if (trtAr->FindKey("Detector_Ar_2"))
    {
        cout << "    MAKING AR RtColor det 2" << endl;
        try
        {
            rtArcol5 = new RtColor(argv[2], "Detector_Ar_2", true);
        }
        catch (string e)
        {
            cout << e << endl;
        }
    }
    // Add the plot for Board T0 variations
    BoardVariationsOldT0 *refboardECgraphA = nullptr;
    BoardVariationsOldT0 *refboardECgraphC = nullptr;
    BoardVariationsDiff *boarddiffECgraphA = nullptr;
    BoardVariationsDiff *boarddiffECgraphC = nullptr;
    if (useref)
    {
        cout << "MAKING BoardVariationsOldT0 for Ar" << endl;
        refboardECgraphA = new BoardVariationsOldT0(argv[4], 2);
        refboardECgraphC = new BoardVariationsOldT0(argv[4], -2);
        cout << "MAKING BoardVariationsDiff Ar" << endl;
        boarddiffECgraphA = new BoardVariationsDiff(argv[2], argv[4], 2);
        boarddiffECgraphC = new BoardVariationsDiff(argv[2], argv[4], -2);
        boarddiffECgraphA->SetLineColor(2);
        boarddiffECgraphC->SetLineColor(2);
    }
    // Add the plot for Board T0 variations
    cout << "MAKING BoardVariations Ar" << endl;
    BoardVariations *boardECgraphA = new BoardVariations(argv[2], 2);
    BoardVariations *boardECgraphC = new BoardVariations(argv[2], -2);
    // Add the plot for the residual
    cout << "MAKING BoardVariationsRes Ar" << endl;
    BoardVariationsRes *boardECgraphA1 = new BoardVariationsRes(argv[2], 2);
    BoardVariationsRes *boardECgraphC1 = new BoardVariationsRes(argv[2], -2);
    // Add the plot for the Time residual
    cout << "MAKING BoardVariationsTRes Ar" << endl;
    BoardVariationsTRes *boardECgraphA2 = new BoardVariationsTRes(argv[2], 2);
    BoardVariationsTRes *boardECgraphC2 = new BoardVariationsTRes(argv[2], -2);
    // Add the plot for the sigma Time residual
    cout << "MAKING BoardVariationsTRes1" << endl;
    BoardVariationsTRes1 *boardECgraphA3 = new BoardVariationsTRes1(argv[2], 2);
    BoardVariationsTRes1 *boardECgraphC3 = new BoardVariationsTRes1(argv[2], -2);
 
    cout << " Start printing itersum.ps" << endl;
 
    TCanvas *textpage;
 
    TCanvas *c1 = new TCanvas();
    c1->Print("itersum.ps[");
    c1->cd();
 
    if (firstpage)
        firstpage->Print("itersum.ps");
    c1->Clear();
    if (settings)
        settings->Print("itersum.ps");
    c1->Clear();
    if (tracktupleinfo)
        tracktupleinfo->Print("itersum.ps");
    c1->Clear();
    if (hitstat)
        hitstat->Print("itersum.ps");
    c1->Clear();
    if (hitstatAr)
        hitstatAr->Print("itersum.ps");
    c1->Clear();
 
    gStyle->SetOptStat(0);
    if (resplots)
        resplots->Print("itersum.ps");
    c1->Clear();
    if (resplotsAr)
        resplotsAr->Print("itersum.ps");
    c1->Clear();
 
    textpage = new TextPage(" BARREL PLOTS ");
    textpage->Print("itersum.ps");
    c1->Clear();
 
    hitstatxy->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        hitstatxyAr->Print("itersum.ps");
    c1->Clear();
    nhits->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        nhitsAr->Print("itersum.ps");
    c1->Clear();
    resxy0->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        resxy0Ar->Print("itersum.ps");
    c1->Clear();
    resxy->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        resxyAr->Print("itersum.ps");
    c1->Clear();
    xymap->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        xymapAr->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
    {
        oldt0->Print("itersum.ps");
        c1->Clear();
        if (isAr)
            oldt0Ar->Print("itersum.ps");
        c1->Clear();
    }
    oldt01->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        oldt01Ar->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
    {
        oldt0111->Print("itersum.ps");
        c1->Clear();
        if (isAr)
            oldt0111Ar->Print("itersum.ps");
        c1->Clear();
    }
    oldt011->Print("itersum.ps");
    c1->Clear();
    if (isAr)
        oldt011Ar->Print("itersum.ps");
    c1->Clear();
 
    //  textpage = new TextPage(" T0 PLOTS "); textpage->Print("itersum.ps"); c1->Clear();
 
    double lowe = -3.5, upe = 3.5;
    if (do_expert)
        if (chipgraphA && chipgraphC)
        {
            chipgraphA->GetYaxis()->SetRangeUser(lowe, upe);
            chipgraphC->GetYaxis()->SetRangeUser(lowe, upe);
            c1->cd();
            c1->Divide(1, 2, 0.01, 0.01);
            c1->cd(1);
            chipgraphA->Draw();
            chipgraphA->DrawLines(lowe, upe);
            c1->cd(2);
            chipgraphC->Draw();
            chipgraphC->DrawLines(lowe, upe);
            c1->Print("itersum.ps");
            c1->Clear();
        }
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardgraphA->Draw("apl");
    boardgraphA->DrawLines();
    if (refboardgraphA)
        refboardgraphA->Draw("pl");
    TLegend *leg = new TLegend(0.8, 0.8, 0.98, 0.95);
    leg->AddEntry(boardgraphA, "data", "l");
    if (refboardgraphA)
        leg->AddEntry(refboardgraphA, "ref (input to 1st it)", "l");
    leg->SetTextSize(0.03);
    leg->Draw();
    c1->cd(2);
    boardgraphC->Draw("apl");
    boardgraphC->DrawLines();
    if (refboardgraphC)
        refboardgraphC->Draw("pl");
    c1->Print("itersum.ps");
    c1->Clear();
 
    // Add the plot for Board T0 variations differenses
    if (useref)
    {
        c1->cd();
        c1->Divide(1, 2, 0.01, 0.01);
        c1->cd(1);
        boarddiffgraphA->Draw("ap");
        boarddiffgraphA->DrawLines();
 
        c1->cd(2);
        boarddiffgraphC->Draw("ap");
        boarddiffgraphC->DrawLines();
        if (do_expert)
            c1->Print("itersum.ps");
        c1->Clear();
    }
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardgraphA1->Draw("apl");
    boardgraphA1->DrawLines();
    c1->cd(2);
    boardgraphC1->Draw("apl");
    boardgraphC1->DrawLines();
    c1->Print("itersum.ps");
    c1->Clear();
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardgraphA2->Draw("apl");
    boardgraphA2->DrawLines();
    c1->cd(2);
    boardgraphC2->Draw("apl");
    boardgraphC2->DrawLines();
    c1->Print("itersum.ps");
    c1->Clear();
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardgraphA3->Draw("apl");
    boardgraphA3->DrawLines();
    c1->cd(2);
    boardgraphC3->Draw("apl");
    boardgraphC3->DrawLines();
    c1->Print("itersum.ps");
    c1->Clear();
 
    // ################################################################                   ADD PLOTS FOR ENDCAPS:
 
    c1->Clear();
    textpage = new TextPage("ENDCAP PLOTS");
    textpage->Print("itersum.ps");
    c1->Clear();
 
    cout << "MAKING PLOTS FOR ENDCAPS" << endl;
 
    // Do hits fit type:
    XYMapsEC *ntypeEC = new XYMapsEC(argv[2], "ftype");
    ntypeEC->Print("itersum.ps");
    XYMapsEC *ntypeECAr = nullptr;
    if (isAr)
    {
        ntypeECAr = new XYMapsEC(argv[2], "ftype", true);
        ntypeECAr->Print("itersum.ps");
    }
 
    // Do hits plots:
    XYMapsEC *nhitsEC = new XYMapsEC(argv[2], "nt0");
    nhitsEC->Print("itersum.ps");
    XYMapsEC *nhitsECAr = nullptr;
    if (isAr)
    {
        nhitsECAr = new XYMapsEC(argv[2], "nt0", true);
        nhitsECAr->Print("itersum.ps");
    }
    // Do res plot:
    XYMapsEC *resxy0EC = new XYMapsEC(argv[2], "res");
    resxy0EC->Print("itersum.ps");
    XYMapsEC *resxy0ECAr = nullptr;
    if (isAr)
    {
        resxy0ECAr = new XYMapsEC(argv[2], "res", true);
        resxy0ECAr->Print("itersum.ps");
    }
 
    XYMapsEC *resxyM0EC = new XYMapsEC(argv[2], "abs(resMean)");
    resxyM0EC->Print("itersum.ps");
    XYMapsEC *resxyM0ECAr = nullptr;
    if (isAr)
    {
        resxyM0ECAr = new XYMapsEC(argv[2], "abs(resMean)", true);
        resxyM0ECAr->Print("itersum.ps");
    }
 
    // Do t0s plots:
    XYMapsEC *xymapEC = new XYMapsEC(argv[2], "t0");
    xymapEC->Print("itersum.ps");
    XYMapsEC *xymapECAr = nullptr;
    if (isAr)
    {
        xymapECAr = new XYMapsEC(argv[2], "t0", true);
        xymapECAr->Print("itersum.ps");
    }
 
    // Do Oldt0plots
    XYMapsEC *oldt0EC = nullptr;
    if (do_expert)
        oldt0EC = new XYMapsEC(argv[2], "oldt0");
    if (do_expert)
        oldt0EC->Print("itersum.ps");
    XYMapsEC *oldt0ECAr = nullptr;
    if (do_expert)
    {
        if (isAr)
        {
            oldt0ECAr = new XYMapsEC(argv[2], "oldt0", true);
            oldt0ECAr->Print("itersum.ps");
        }
    }
 
    // Do t0 diff:
    XYMapsEC *oldt01EC = new XYMapsEC(argv[2], "abs(t0-oldt0)");
    oldt01EC->Print("itersum.ps");
    XYMapsEC *oldt01ECAr = nullptr;
    if (isAr)
    {
        oldt01ECAr = new XYMapsEC(argv[2], "abs(t0-oldt0)", true);
        oldt01ECAr->Print("itersum.ps");
    }
 
    // Do t0 widht:
 
    XYMapsEC *oldt0111EC = nullptr;
    if (do_expert)
        oldt0111EC = new XYMapsEC(argv[2], "abs(tresMean)");
    if (do_expert)
        oldt0111EC->Print("itersum.ps");
    XYMapsEC *oldt0111ECAr = nullptr;
    if (do_expert)
    {
        if (isAr)
        {
            oldt0111ECAr = new XYMapsEC(argv[2], "abs(tresMean)", true);
            oldt0111ECAr->Print("itersum.ps");
        }
    }
    // Do t0 widht:
    XYMapsEC *oldt011EC = new XYMapsEC(argv[2], "tres");
    oldt011EC->Print("itersum.ps");
    XYMapsEC *oldt011ECAr = nullptr;
    if (isAr)
    {
        oldt011ECAr = new XYMapsEC(argv[2], "tres", true);
        oldt011ECAr->Print("itersum.ps");
    }
 
    // Do board variations for Ar
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardECgraphA->Draw("apl");
    boardECgraphA->DrawLines();
    if (refboardECgraphA)
        refboardECgraphA->Draw("pl");
    TLegend *legAr = new TLegend(0.8, 0.8, 0.98, 0.95);
    legAr->AddEntry(boardECgraphA, "data", "l");
    if (refboardECgraphA)
        leg->AddEntry(refboardECgraphA, "ref (input to 1st it)", "l");
    legAr->SetTextSize(0.03);
    legAr->Draw();
    c1->cd(2);
    boardECgraphC->Draw("apl");
    boardECgraphC->DrawLines();
    if (refboardECgraphC)
        refboardECgraphC->Draw("pl");
    c1->Print("itersum.ps");
    c1->Clear();
 
    // Add the plot for Board T0 variations differenses
    if (useref)
    {
        c1->cd();
        c1->Divide(1, 2, 0.01, 0.01);
        c1->cd(1);
        boarddiffECgraphA->Draw("ap");
        boarddiffECgraphA->DrawLines();
        c1->cd(2);
        boarddiffECgraphC->Draw("ap");
        boarddiffECgraphC->DrawLines();
        if (do_expert)
            c1->Print("itersum.ps");
        c1->Clear();
    }
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardECgraphA1->Draw("apl");
    boardECgraphA1->DrawLines();
    c1->cd(2);
    boardECgraphC1->Draw("apl");
    boardECgraphC1->DrawLines();
    c1->Print("itersum.ps");
    c1->Clear();
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardECgraphA2->Draw("apl");
    boardECgraphA2->DrawLines();
    c1->cd(2);
    boardECgraphC2->Draw("apl");
    boardECgraphC2->DrawLines();
    c1->Print("itersum.ps");
    c1->Clear();
 
    c1->cd();
    c1->Divide(1, 2, 0.01, 0.01);
    c1->cd(1);
    boardECgraphA3->Draw("apl");
    boardECgraphA3->DrawLines();
    c1->cd(2);
    boardECgraphC3->Draw("apl");
    boardECgraphC3->DrawLines();
    c1->Print("itersum.ps");
    c1->Clear();
 
    // ###################################      RT PLOTS: ########################################################
 
    textpage = new TextPage(" RT PLOTS ");
    textpage->Print("itersum.ps");
    c1->Clear();
 
    gStyle->SetOptStat(1);
    gStyle->SetOptFit(0);
    if (do_expert)
        if (rtrelation_bar)
            rtrelation_bar->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtbinning_bar)
            rtbinning_bar->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtrelation21)
            rtrelation21->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtbinning1)
            rtbinning1->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtrelation31)
            rtrelation31->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtbinning2)
            rtbinning2->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtrelation41)
            rtrelation41->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtbinning3)
            rtbinning3->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtrelation51)
            rtrelation51->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtbinning4)
            rtbinning4->Print("itersum.ps");
    c1->Clear();
 
    if (do_expert)
        if (binres_bar)
            binres_bar->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (tbinnedres_bar)
            tbinnedres_bar->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (binres1)
            binres1->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (tbinnedres1)
            tbinnedres1->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (binres2)
            binres2->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (tbinnedres2)
            tbinnedres2->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
            binres3->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (tbinnedres3)
            tbinnedres3->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
            binres4->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (tbinnedres4)
            tbinnedres4->Print("itersum.ps");
    c1->Clear();
 
    gStyle->SetOptStat(0);
    if (do_expert)
        if (rtcol)
            rtcol->Print("itersum.ps");
    c1->Clear();
    if (do_expert)
        if (rtcol1)
            rtcol1->Print("itersum.ps");
    c1->Clear();
    if (rtcol2)
        rtcol2->Print("itersum.ps");
    c1->Clear();
    if (isAr && rtArcol2)
        rtArcol2->Print("itersum.ps");
    c1->Clear();
    if (rtcol3)
        rtcol3->Print("itersum.ps");
    c1->Clear();
    if (isAr && rtArcol3)
        rtArcol3->Print("itersum.ps");
    c1->Clear();
    if (rtcol4)
        rtcol4->Print("itersum.ps");
    c1->Clear();
    if (isAr && rtArcol4)
        rtArcol4->Print("itersum.ps");
    c1->Clear();
    if (rtcol5)
        rtcol5->Print("itersum.ps");
    c1->Clear();
    if (isAr && rtArcol5)
        rtArcol5->Print("itersum.ps");
    c1->Clear();
 
    // Plot all RTs together....
 
    DGraph *dgraph0 = nullptr; // trt
    DGraph *dgraph1 = nullptr; // -1
    DGraph *dgraph2 = nullptr; // 1
    DGraph *dgraph3 = nullptr; // -2
    DGraph *dgraph4 = nullptr; // 2
    DGraph *dgraph5 = nullptr; // whole barrel
    bool isinverted = false;
    if (datafile->FindKey("TRT_all"))
    {
        TDirectory *trt = (TDirectory *)datafile->FindKey("TRT_all")->ReadObj();
        cout << "MAKING DGraphs" << endl;
        c1->cd();
        c1->SetGrid();
        dgraph0 = new DGraph(argv[2], "-2,-1", "", -2, -1, isinverted);
        if (trt->FindKey("WholeBarrel_1"))
        {
            dgraph5 = new DGraph(argv[2], "-2,-1", "WholeBarrel_1", -1, -1, isinverted);
        }
        else
        {
            cout << " did not find WholeBarrel_1" << endl;
            if (trt->FindKey("Detector_1"))
                dgraph1 = new DGraph(argv[2], "-2,-1", "Detector_1", 1, -1, isinverted);
            if (trt->FindKey("Detector_-1"))
                dgraph2 = new DGraph(argv[2], "-2,-1", "Detector_-1", 1, -1, isinverted);
        }
        if (trt->FindKey("Detector_2"))
            dgraph3 = new DGraph(argv[2], "-2,-1", "Detector_2", 1, -1, isinverted);
        if (trt->FindKey("Detector_-2"))
            dgraph4 = new DGraph(argv[2], "-2,-1", "Detector_-2", 1, -1, isinverted);
 
        
        TLegend *leg = new TLegend(0.8, 0.8, 0.98, 0.95);
        if (dgraph0 != nullptr)
        { 
            dgraph0->GetXaxis()->SetRangeUser(-5, 45);
            cout << " found TRT_all" << endl;
            dgraph0->SetLineWidth(3);
            dgraph0->SetLineColor(1);
            dgraph0->SetTitle("r(t)");
           
            dgraph0->GetXaxis()->SetTitle("t/ns");
           
            dgraph0->GetYaxis()->SetTitle("R / (mm)");
           
            if (dgraph0->rtgraph)
                dgraph0->Draw("apl");
            if (dgraph0->rtgraph)
                leg->AddEntry(dgraph0, "Whole TRT", "l");
        }
        if (dgraph1 != nullptr)
        {
            cout << " found Detector_1" << endl;
            dgraph1->SetLineWidth(3);
            dgraph1->SetLineColor(3);
            if (dgraph1->rtgraph)
                dgraph1->Draw("pl");
            if (dgraph1->rtgraph)
                leg->AddEntry(dgraph1, "Barrel C Side", "l");
        }
 
        if (dgraph2 != nullptr)
        {
            cout << " found Detector_-1" << endl;
            dgraph2->SetLineWidth(3);
            dgraph2->SetLineColor(2);
            if (dgraph2->rtgraph)
                dgraph2->Draw("pl");
            if (dgraph2->rtgraph)
                leg->AddEntry(dgraph2, "Barrel A Side", "l");
        }
 
        if (dgraph3 != nullptr)
        {
            dgraph3->SetLineWidth(3);
            cout << " found Detector_2" << endl;
            dgraph3->SetLineColor(6);
            if (dgraph3->rtgraph)
                dgraph3->Draw("pl");
            if (dgraph3->rtgraph)
                leg->AddEntry(dgraph3, "Endcap C side", "l");
        }
 
        if (dgraph4 != nullptr)
        {
            cout << " found Detector_-2" << endl;
            dgraph4->SetLineWidth(3);
            dgraph4->SetLineColor(7);
            if (dgraph4->rtgraph)
                dgraph4->Draw("pl");
            if (dgraph4->rtgraph)
                leg->AddEntry(dgraph4, "Endcap A side", "l");
        }
        if (dgraph5 != nullptr)
        {
            cout << " found WholeBarrel_1" << endl;
            dgraph5->SetLineWidth(3);
            dgraph5->SetLineColor(8);
            if (dgraph5->rtgraph)
                dgraph5->Draw("pl");
            if (dgraph5->rtgraph)
                leg->AddEntry(dgraph5, "Whole Barrel", "l");
        }
 
        leg->SetTextSize(0.03);
        leg->Draw();
        c1->Print("itersum.ps");
        c1->Clear();
    }
 
    // Plot drift velocity:
    DvGraph *dvgraph0 = nullptr; // trt
    DvGraph *dvgraph1 = nullptr; // -1
    DvGraph *dvgraph2 = nullptr; // 1
    DvGraph *dvgraph3 = nullptr; // -2
    DvGraph *dvgraph4 = nullptr; // 2
    DvGraph *dvgraph5 = nullptr; // whole barrel
    if (do_expert)
    {
        //  bool isinverted=false;
        if (datafile->FindKey("TRT_all"))
        {
            cout << " do_expert: found TRT_all" << endl;
            TDirectory *trt = (TDirectory *)datafile->FindKey("TRT_all")->ReadObj();
            cout << "MAKING DvGraphs" << endl;
            c1->cd();
            c1->SetGrid();
            dvgraph0 = new DvGraph(argv[2], "-2,-1", "", -2, -1, isinverted);
            if (trt->FindKey("WholeBarrel_1"))
                dvgraph5 = new DvGraph(argv[2], "-2,-1", "WholeBarrel_1", -1, -1, isinverted);
            else
            {
                if (trt->FindKey("Detector_1"))
                    dvgraph1 = new DvGraph(argv[2], "-2,-1", "Detector_1", 1, -1, isinverted);
                if (trt->FindKey("Detector_-1"))
                    dvgraph2 = new DvGraph(argv[2], "-2,-1", "Detector_-1", 1, -1, isinverted);
            }
            if (trt->FindKey("Detector_2"))
                dvgraph3 = new DvGraph(argv[2], "-2,-1", "Detector_2", 1, -1, isinverted);
            if (trt->FindKey("Detector_-2"))
                dvgraph4 = new DvGraph(argv[2], "-2,-1", "Detector_-2", 1, -1, isinverted);
 
            
            TLegend *leg = new TLegend(0.8, 0.8, 0.98, 0.95);
            if (dvgraph0 != nullptr)
            {
                dvgraph0->GetXaxis()->SetRangeUser(0, 2);
                cout << " do_expert: found -2-1" << endl;
                dvgraph0->SetLineWidth(3);
                dvgraph0->SetLineColor(1);
                if (isinverted)
                    dvgraph0->SetTitle("dt/dr");
                else
                    dvgraph0->SetTitle("dr/dt");
                dvgraph0->GetXaxis()->SetTitle("r/mm");
                if (isinverted)
                    dvgraph0->GetYaxis()->SetTitle("dt/dr / (ns/mm)");
                else
                    dvgraph0->GetYaxis()->SetTitle("dr/dt / (mm/ns)");
                if (dvgraph0->rtgraph)
                    dvgraph0->Draw("apl");
                if (dvgraph0->rtgraph)
                    leg->AddEntry(dvgraph0, "Whole TRT", "l");
            }
            if (dvgraph1 != nullptr)
            {
                cout << " do_expert: found Detector_1" << endl;
                dvgraph1->SetLineWidth(3);
                dvgraph1->SetLineColor(3);
                if (dvgraph1->rtgraph)
                    dvgraph1->Draw("pl");
                if (dvgraph1->rtgraph)
                    leg->AddEntry(dvgraph1, "Barrel C Side", "l");
            }
 
            if (dvgraph2 != nullptr)
            {
                dvgraph2->SetLineWidth(3);
                dvgraph2->SetLineColor(2);
                if (dvgraph2->rtgraph)
                    dvgraph2->Draw("pl");
                if (dvgraph2->rtgraph)
                    leg->AddEntry(dvgraph2, "Barrel A Side", "l");
            }
 
            if (dvgraph3 != nullptr)
            {
                dvgraph3->SetLineWidth(3);
                dvgraph3->SetLineColor(6);
                if (dvgraph3->rtgraph)
                    dvgraph3->Draw("pl");
                if (dvgraph3->rtgraph)
                    leg->AddEntry(dvgraph3, "Endcap C side", "l");
            }
 
            if (dvgraph4 != nullptr)
            {
                dvgraph4->SetLineWidth(3);
                dvgraph4->SetLineColor(7);
                if (dvgraph4->rtgraph)
                    dvgraph4->Draw("pl");
                if (dvgraph4->rtgraph)
                    leg->AddEntry(dvgraph4, "Endcap A side", "l");
            }
            if (dvgraph5 != nullptr)
            {
                dvgraph5->SetLineWidth(3);
                dvgraph5->SetLineColor(8);
                if (dvgraph5->rtgraph)
                    dvgraph5->Draw("pl");
                if (dvgraph5->rtgraph)
                    leg->AddEntry(dvgraph5, "Whole Barrel", "l");
            }
 
            leg->SetTextSize(0.03);
            leg->Draw();
            c1->Print("itersum.ps");
            c1->Clear();
        }
    }
 
    // ###################################   ADD PLOTS FOR TRACKING   #######################################33
    c1->Clear();
    textpage = new TextPage("Track plots: Only for Experts!!!");
    textpage->Print("itersum.ps");
    c1->Clear();
 
    bool istracktuple = false;
    TNtuple *Tracktuple = nullptr;
    if (datafile->FindKey("tracktuple"))
    {
        Tracktuple = (TNtuple *)datafile->Get("tracktuple");
        istracktuple = true;
    }
 
    cout << "MAKING TRACK PLOTS" << endl;
    c1->Clear();
    if (istracktuple)
    {
        // first Residuals:
        if (Tracktuple->GetListOfBranches()->FindObject("trackres"))
        {
            c1->cd();
            c1->Divide(2, 1, 0.01, 0.01);
            c1->cd(1);
            Tracktuple->Draw("trackres>>histRes(100,0,1.5)");
            TH1F *histRes = (TH1F *)gPad->GetPrimitive("histRes");
            histRes->SetTitle("Residual on track");
            histRes->GetXaxis()->SetTitle("Residual (mm)");
            histRes->Draw();
 
            c1->cd(2);
            Tracktuple->Draw("trackres:t-ttrack-t0>>histRes2d(100,-12,12,100,0,1)", "", "colz");
            TH2F *histRes2d = (TH2F *)gPad->GetPrimitive("histRes2d");
            histRes2d->SetTitle("Track time residual VS track residual");
            histRes2d->GetXaxis()->SetTitle("Time residual (ns)");
            histRes2d->GetYaxis()->SetTitle("Track Residual (mm)");
            histRes2d->Draw("colz");
            TProfile *res2d = histRes2d->ProfileX();
            res2d->Draw("same");
 
            c1->Print("itersum.ps");
            c1->Clear();
        }
 
        // first pt:
        if (Tracktuple->GetListOfBranches()->FindObject("pt"))
        {
            c1->cd();
            c1->Divide(2, 1, 0.01, 0.01);
            c1->cd(1);
            Tracktuple->Draw("pt/1000>>histPt(100,0,20)");
            TH1F *histPt = (TH1F *)gPad->GetPrimitive("histPt");
            histPt->SetTitle("Transverse momentum on track");
            histPt->GetXaxis()->SetTitle("Pt (GeV)");
            histPt->Draw();
 
            c1->cd(2);
            Tracktuple->Draw("trackres:pt/1000>>histPt2d(100,0,20,100,0,1.5)", "", "colz");
            TH2F *histPt2d = (TH2F *)gPad->GetPrimitive("histPt2d");
            histPt2d->SetTitle("Transverse momentum on track VS track residual");
            histPt2d->GetXaxis()->SetTitle("Pt (GeV)");
            histPt2d->GetYaxis()->SetTitle("Track Residual (mm)");
            histPt2d->Draw("COLZ");
            TProfile *pt2d = histPt2d->ProfileX();
            pt2d->Draw("same");
            c1->Print("itersum.ps");
            c1->Clear();
        }
        // first theta:
        if (Tracktuple->GetListOfBranches()->FindObject("theta"))
        {
            c1->cd();
            c1->Divide(2, 1, 0.01, 0.01);
            c1->cd(1);
            Tracktuple->Draw("theta>>histTheta(100,0,4)");
            TH1F *histTheta = (TH1F *)gPad->GetPrimitive("histTheta");
            histTheta->SetTitle("Theta distribution on track");
            histTheta->GetXaxis()->SetTitle("Theta (rad)");
            histTheta->Draw();
 
            c1->cd(2);
            Tracktuple->Draw("trackres:theta>>histTheta2d(100,0,4,100,0,1.5)", "", "colz");
            TH2F *histTheta2d = (TH2F *)gPad->GetPrimitive("histTheta2d");
            histTheta2d->SetTitle("Theta distrib. on track VS track residual");
            histTheta2d->GetXaxis()->SetTitle("Theta (rad)");
            histTheta2d->GetYaxis()->SetTitle("Track Residual (mm)");
            histTheta2d->Draw("COLZ");
            TProfile *theta2d = histTheta2d->ProfileX();
            theta2d->Draw("same");
            c1->Print("itersum.ps");
            c1->Clear();
        }
        // first phi:
        if (Tracktuple->GetListOfBranches()->FindObject("phi"))
        {
            c1->cd();
            c1->Divide(2, 1, 0.01, 0.01);
            c1->cd(1);
            Tracktuple->Draw("phi>>histPhi(100,-3.5,0)");
            TH1F *histPhi = (TH1F *)gPad->GetPrimitive("histPhi");
            histPhi->SetTitle("Phi distribution on track");
            histPhi->GetXaxis()->SetTitle("Phi (rad)");
            histPhi->Draw();
 
            c1->cd(2);
            Tracktuple->Draw("trackres:phi>>histPhi2d(100,-3.5,0,100,0,1.5)", "", "colz");
            TH2F *histPhi2d = (TH2F *)gPad->GetPrimitive("histPhi2d");
            histPhi2d->SetTitle("Phi distrib. on track VS track residual");
            histPhi2d->GetXaxis()->SetTitle("Phi (rad)");
            histPhi2d->GetYaxis()->SetTitle("Track Residual (mm)");
            histPhi2d->Draw("COLZ");
            TProfile *phi2d = histPhi2d->ProfileX();
            phi2d->Draw("same");
            c1->Print("itersum.ps");
            c1->Clear();
        }
        // first d0:
        if (Tracktuple->GetListOfBranches()->FindObject("d0"))
        {
            c1->cd();
            c1->Divide(2, 1, 0.01, 0.01);
            c1->cd(1);
            Tracktuple->Draw("d0>>histD0(100,-5,5)");
            TH1F *histD0 = (TH1F *)gPad->GetPrimitive("histD0");
            histD0->SetTitle("D0 distribution on track");
            histD0->GetXaxis()->SetTitle("D0 (mm)");
            histD0->Draw();
 
            c1->cd(2);
            Tracktuple->Draw("trackres:d0>>histD02d(100,-5,5,100,0,1.5)", "", "colz");
            TH2F *histD02d = (TH2F *)gPad->GetPrimitive("histD02d");
            histD02d->SetTitle("D0 distrib. on track VS track residual");
            histD02d->GetXaxis()->SetTitle("D0 (rad)");
            histD02d->GetYaxis()->SetTitle("Track Residual (mm)");
            histD02d->Draw("COLZ");
            TProfile *d02d = histD02d->ProfileX();
            d02d->Draw("same");
            c1->Print("itersum.ps");
            c1->Clear();
        }
    }
 
    // ###################################   ADD PLOTS FOR Pulls and Errors   #######################################33
 
    // Skip all this for now (PH)
    cout << " Skipping plots for Pulls and Errors " << endl;
 
    // SERGI - Another block not used :). Firewalls below previously commented... useless block of code
    // bool iserrors = false;
    // TDirectory *errors = nullptr;
    // if (datafile->FindKey("Errors"))
    // {
    //     errors = (TDirectory *)datafile->FindKey("Errors")->ReadObj();
    //     if (errors != nullptr)
    //         iserrors = true;
    // }
 
    c1->Clear();
    /*
    textpage = new TextPage(" Error Plots and Pt dependence. Only for Experts!!!");
    textpage->Print("itersum.ps");
    c1->Clear();
 
    cout << "Making Error/Pt plots:" << endl;
    c1->Clear();
    if (iserrors){
      //first Residuals:
        cout << "Start with Pt plots:" << endl;
      errors->cd();
 
      PtDependence* ptstuff = new PtDependence(datafile);
      ptstuff->Print("itersum.ps");
 
      TBDependence* tbstuff = new TBDependence(datafile);
      tbstuff->Print("itersum.ps");
 
 
 
    }
 
 
    */
 
    // ###################################   ADD PLOTS FOR ToT and HT   #######################################33
 
    // Skip all this for now (PH)
    cout << " Skipping plots for ToT and HT " << endl;
 
    // SERGI - Firewalls below previously commented... useless block of code
    // bool iscorrections = false;
    // TDirectory *corrections = nullptr;
    // if (datafile->FindKey("Correction"))
    // {
    //     corrections = (TDirectory *)datafile->FindKey("Correction")->ReadObj();
    //     if (corrections != nullptr)
    //         iscorrections = true;
    // }
 
    c1->Clear();
    textpage = new TextPage(" ToT Corrections and HT corrections: ");
    textpage->Print("itersum.pdf");
    c1->Clear();
 
    cout << "Making ToT / HT Plots" << endl;
    c1->Clear();
    /*
    if (iscorrections){
      //first Residuals:
      cout << "Start with ToT plots:" << endl;
      corrections->cd();
 
      ToTDependence* totstuff = new ToTDependence(datafile, true);  // Barrels:
      totstuff->Print("itersum.ps");
 
      ToTDependence* totstuff2 = new ToTDependence(datafile, false);    // Barrels:
      totstuff2->Print("itersum.ps");
 
      cout << "Start with HT plots:" << endl;
 
      ToTDependence* htstuff = new ToTDependence(datafile, true, true );    // Barrels:
      htstuff->Print("itersum.ps");
 
      ToTDependence* htstuff2 = new ToTDependence(datafile, false, true);   // Barrels:
      htstuff2->Print("itersum.ps");
 
      cout << "Start with sin(theta) / p  plots:" << endl;
 
      SinDependence* sinstuff = new SinDependence(datafile, true);  // Barrels:
      sinstuff->Print("itersum.ps");
 
      SinDependence* sinstuff2 = new SinDependence(datafile, false);    // Barrels:
      sinstuff2->Print("itersum.ps");
 
      cout << "Start with cos(theta) / p  plots:" << endl;
 
      SinDependence* cosstuff = new SinDependence(datafile, true, true);    // Barrels:
      cosstuff->Print("itersum.ps");
 
      SinDependence* cosstuff2 = new SinDependence(datafile, false, true);  // Barrels:
      cosstuff2->Print("itersum.ps");
 
 
    }
 
 
    */
 
    // ###################################   ADD PLOTS FOR ToT and HT  ARGON  #######################################33
 
    // bool iscorrectionsAr = false;
    // TDirectory *correctionsAr = nullptr;
    // if (datafile->FindKey("CorrectionAr"))
    // {
    //     correctionsAr = (TDirectory *)datafile->FindKey("CorrectionAr")->ReadObj();
    //     if (correctionsAr != nullptr)
    //         iscorrectionsAr = true;
    // }
 
    /*
    if (iscorrectionsAr){
      c1->Clear();
      textpage = new TextPage(" ToT Corrections and HT corrections: ARGON");
      textpage->Print("itersum.ps");
      c1->Clear();
 
      cout << "Making ToT / HT Plots ARGON" << endl;
      c1->Clear();
      //first Residuals:
          cout << "Start with ToT plots:" << endl;
          corrections->cd();
 
          ToTDependence* totstuff = new ToTDependence(datafile, true, false, true);       // Barrels:
          totstuff->Print("itersum.ps");
 
          ToTDependence* totstuff2 = new ToTDependence(datafile, false, false, true);     // Barrels:
          totstuff2->Print("itersum.ps");
 
          cout << "Start with HT plots:" << endl;
 
          ToTDependence* htstuff = new ToTDependence(datafile, true, true, true );        // Barrels:
          htstuff->Print("itersum.ps");
 
          ToTDependence* htstuff2 = new ToTDependence(datafile, false, true, true);       // Barrels:
          htstuff2->Print("itersum.ps");
 
          cout << "Start with sin(theta) / p  plots:" << endl;
 
          SinDependence* sinstuff = new SinDependence(datafile, true, false, true);       // Barrels:
          sinstuff->Print("itersum.ps");
 
  //      SinDependence* sinstuff2 = new SinDependence(datafile, false, false, true);     // Barrels:
  //      sinstuff2->Print("itersum.ps");
 
          cout << "Start with cos(theta) / p  plots:" << endl;
 
  //      SinDependence* cosstuff = new SinDependence(datafile, true, true, true);        // Barrels:
  //      cosstuff->Print("itersum.ps");
 
          SinDependence* cosstuff2 = new SinDependence(datafile, false, true, true);      // Barrels:
          cosstuff2->Print("itersum.ps");
 
 
  }
 
    c1->Print("itersum.ps]");
  */
 
    datafile->Close();
    if (useref)
        refdatafile->Close();
 
    //   cout << "RDIFF -1 ";
    //   for (map<double,double>::iterator rtpoint = rtrelation21->rtmap.begin(); rtpoint !=  rtrelation21->rtmap.end(); rtpoint++){
    //     cout << binres1->resmap[rtpoint->second] << " ";
    //   }
    //   cout << endl;
    //   cout << "RDIFF 1 ";
    //   for (map<double,double>::iterator rtpoint = rtrelation31->rtmap.begin(); rtpoint !=  rtrelation31->rtmap.end(); rtpoint++){
    //     cout << binres2->resmap[rtpoint->second] << " ";
    //   }
    //   cout << endl;
 
    //   cout << "RDIFF -2 ";
    //   for (map<double,double>::iterator rtpoint = rtrelation41->rtmap.begin(); rtpoint !=  rtrelation41->rtmap.end(); rtpoint++){
    //     cout << binres3->resmap[rtpoint->second] << " ";
    //   }
    //   cout << endl;
 
    //   cout << "RDIFF 2 ";
    //   for (map<double,double>::iterator rtpoint = rtrelation51->rtmap.begin(); rtpoint !=  rtrelation51->rtmap.end(); rtpoint++){
    //     cout << binres4->resmap[rtpoint->second] << " ";
    //   }
    //   cout << endl;
 
    // add some extra info to each page
    if (settings && firstpage)
    {
        string fixfloat, fieldonoff;
        if (settings->set["UsePol0"].find("True") != string::npos)
            fixfloat = " - floating";
        else
            fixfloat = " - fixed";
        if (settings->set["RtRelation"].find("binned") != string::npos)
            fixfloat = "";
        if (settings->set["Solenoid"].find("True") != string::npos)
            fieldonoff = "ON";
        else
            fieldonoff = "OFF";
 
        string pmarking =
            string("/Helvetica-Bold findfont 36 scalefont setfont 40 2190 moveto (Run:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 240 2190 moveto (%i) show ", (int)firstpage->runnumber)) +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 40 2150 moveto (Iteration:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 240 2150 moveto (%02i) show ", firstpage->iter)) +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 40 2110 moveto (Rt relation:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 240 2110 moveto (%s%s) show ", settings->set["RtRelation"].data(), fixfloat.data())) +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 540 2190 moveto (Rt binning:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 740 2190 moveto (%s) show ", settings->set["RtBinning"].data())) +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 540 2150 moveto (Rt level:) show ") +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 540 2110 moveto (T0 level:) show ") +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 1040 2190 moveto (Solenoid:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 1260 2190 moveto (%s) show ", fieldonoff.data())) +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 1040 2150 moveto (SW release:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 1260 2150 moveto (%s) show ", settings->set["ReleaseRec"].data())) +
 
            string("/Helvetica-Bold findfont 36 scalefont setfont 1040 2110 moveto (T0 Offset:) show ") +
            string(Form("/Helvetica findfont 36 scalefont setfont 1260 2110 moveto (%s) show ", settings->set["T0Offset"].data())) +
 
            string("/Helvetica-Bold findfont 30 scalefont setfont 40 2060 moveto (Data:) show ") +
            string(Form("/Helvetica findfont 30 scalefont setfont 240 2060 moveto (%s) show ", settings->set["Inputdir"].data())) +
 
            string("/Helvetica-Bold findfont 30 scalefont setfont 40 2020 moveto (Start const:) show ") +
            string(Form("/Helvetica findfont 30 scalefont setfont 240 2020 moveto (%s) show ", settings->set["StartConst"].data()));
        system((string("sed -i 's?showpage?" + pmarking + "showpage?g' itersum.ps")).data());
    }
 
    // Add some graphs in a new direcrory "analysis"
    datafile = new TFile(argv[2], "UPDATE");
    datafile->cd();
    if (datafile->FindKey("analysis"))
        datafile->rmdir("analysis");
    TDirectory *adir = datafile->mkdir("analysis", "analysis");
    adir->cd();
    if (chipgraphA)
        chipgraphA->Write();
    if (chipgraphC)
        chipgraphC->Write();
    boardgraphA->Write();
    boardgraphC->Write();
    if (refboardgraphA)
        refboardgraphA->Write();
    if (refboardgraphC)
        refboardgraphC->Write();
    if (dvgraph0)
        dvgraph0->Write();
    if (dvgraph1)
        dvgraph1->Write();
    if (dvgraph2)
        dvgraph2->Write();
    datafile->Write();
    datafile->Close();
 
    return 0;
}

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 6872 of file TRTCalib_makeplots.cxx.

{
 
    gErrorIgnoreLevel = kFatal; // Explicitly remove all messages
 
    if ((string(argv[1])).find("itersum") != std::string::npos)
    {
        cout << "GENERATING ITERATION SUMMARY PLOTS" << endl;
        itersum(argc, argv);
    }
 
    if ((string(argv[1])).find("restore") != std::string::npos)
    {
        cout << "REMOVING THE TRACKTUPLE, BINHIST AND ANALYSE DIRECTORY" << endl;
        tt_remove(argc, argv);
    }
 
    return 0;
}

ResizePalette()

void ResizePalette

(

TH2 *

hist

)

Definition at line 68 of file TRTCalib_makeplots.cxx.

{
    TPaletteAxis *palette = (TPaletteAxis *)hist->GetListOfFunctions()->FindObject("palette");
    palette->SetX2NDC(0.92);
    palette->Paint();
    palette->SetLabelSize(0.03);
}

SetZAxis()

void SetZAxis

(

TH2F *

reshist0

)

Definition at line 49 of file TRTCalib_makeplots.cxx.

{
    double zmin = 100000000;
    double zmax = -100000000;
    double temp = 0;
    for (int ix = 0; ix < reshist0->GetNbinsX(); ix++)
    {
        for (int iy = 0; iy < reshist0->GetNbinsY(); iy++)
        {
            temp = reshist0->GetBinContent(ix, iy);
            if (temp !=0){
              zmax = std::max(temp,zmax);
              zmin = std::min(temp,zmin);
            }
        }
    }
    reshist0->GetZaxis()->SetRangeUser(zmin, zmax);
}

trim()

string trim

(

string

s

)

Definition at line 76 of file TRTCalib_makeplots.cxx.

{
    const char * whitespace = " \n\r\t";
    s.erase(s.find_last_not_of(whitespace)+1);//rtrim
    s.erase(0,s.find_first_not_of(whitespace));//ltrim
    return s;
}

tt_remove()

int tt_remove	(	int	,
		char *	argv[]
	)

Definition at line 6849 of file TRTCalib_makeplots.cxx.

{
 
    TFile *itersumfile = new TFile(argv[2], "UPDATE");
    if (itersumfile->FindKey("tracktuple"))
    {
        itersumfile->Delete("tracktuple;*");
    }
    if (itersumfile->FindKey("binhist"))
    {
        itersumfile->rmdir("binhist");
    }
    if (itersumfile->FindKey("analysis"))
    {
        itersumfile->rmdir("analysis");
    }
 
    itersumfile->Write();
    itersumfile->Close();
 
    return 0;
}

Variable Documentation

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Definition at line 6 of file TRTCalib_makeplots.cxx.

detlet

char detlet[3] = {'C', '-', 'A'}

Definition at line 47 of file TRTCalib_makeplots.cxx.

do_expert

bool do_expert = false

Definition at line 45 of file TRTCalib_makeplots.cxx.