TBDependence Class Reference

Inheritance diagram for TBDependence:

Collaboration diagram for TBDependence:

Public Member Functions
	TBDependence (TFile *)

Private Attributes
TDirectory *	errors

Detailed Description

Definition at line 4288 of file TRTCalib_makeplots.cxx.

Constructor & Destructor Documentation

TBDependence()

TBDependence::TBDependence

(

TFile *

file

)

Definition at line 4297 of file TRTCalib_makeplots.cxx.

{
    errors = (TDirectory *)file->FindKey("Errors")->ReadObj();
    if (!errors)
        throw(string("No errors folder!!!!!!!!!!!!!!!"));
    if (errors->GetNkeys() > 19)
    {
        this->Divide(2, 3, 0.01, 0.01);
 
        // Read the histos:
 
        TH2F *pull_vs_tb_trt = (TH2F *)errors->FindKey("pull_vs_tb_trt")->ReadObj();
        TH2F *pull_vs_tb_ba = (TH2F *)errors->FindKey("pull_vs_tb_ba")->ReadObj();
        TH2F *pull_vs_tb_bc = (TH2F *)errors->FindKey("pull_vs_tb_bc")->ReadObj();
        TH2F *pull_vs_tb_ea = (TH2F *)errors->FindKey("pull_vs_tb_ea")->ReadObj();
        TH2F *pull_vs_tb_ec = (TH2F *)errors->FindKey("pull_vs_tb_ec")->ReadObj();
 
        TH2F *errors_vs_tb_trt = (TH2F *)errors->FindKey("errors_vs_tb_trt")->ReadObj();
        TH2F *errors_vs_tb_ba = (TH2F *)errors->FindKey("errors_vs_tb_ba")->ReadObj();
        TH2F *errors_vs_tb_bc = (TH2F *)errors->FindKey("errors_vs_tb_bc")->ReadObj();
        TH2F *errors_vs_tb_ea = (TH2F *)errors->FindKey("errors_vs_tb_ea")->ReadObj();
        TH2F *errors_vs_tb_ec = (TH2F *)errors->FindKey("errors_vs_tb_ec")->ReadObj();
 
        TH2F *residual_vs_tb_trt = (TH2F *)errors->FindKey("residual_vs_tb_trt")->ReadObj();
        TH2F *residual_vs_tb_ba = (TH2F *)errors->FindKey("residual_vs_tb_ba")->ReadObj();
        TH2F *residual_vs_tb_bc = (TH2F *)errors->FindKey("residual_vs_tb_bc")->ReadObj();
        TH2F *residual_vs_tb_ea = (TH2F *)errors->FindKey("residual_vs_tb_ea")->ReadObj();
        TH2F *residual_vs_tb_ec = (TH2F *)errors->FindKey("residual_vs_tb_ec")->ReadObj();
 
        TH2F *trackerrors_vs_tb_trt = (TH2F *)errors->FindKey("trackerrors_vs_tb_trt")->ReadObj();
        TH2F *trackerrors_vs_tb_ba = (TH2F *)errors->FindKey("trackerrors_vs_tb_ba")->ReadObj();
        TH2F *trackerrors_vs_tb_bc = (TH2F *)errors->FindKey("trackerrors_vs_tb_bc")->ReadObj();
        TH2F *trackerrors_vs_tb_ea = (TH2F *)errors->FindKey("trackerrors_vs_tb_ea")->ReadObj();
        TH2F *trackerrors_vs_tb_ec = (TH2F *)errors->FindKey("trackerrors_vs_tb_ec")->ReadObj();
 
        this->cd(1);
        // Pull widht Vs Pt:
        TGraphErrors *tresTRT = GetPWidth(pull_vs_tb_trt);
        TGraphErrors *tresBA = GetPWidth(pull_vs_tb_ba);
        tresBA->SetLineColor(kRed);
        tresBA->SetMarkerColor(kRed);
        TGraphErrors *tresBC = GetPWidth(pull_vs_tb_bc);
        tresBC->SetLineColor(kBlue);
        tresBC->SetMarkerColor(kBlue);
        TGraphErrors *tresEA = GetPWidth(pull_vs_tb_ea);
        tresEA->SetLineColor(kGreen);
        tresEA->SetMarkerColor(kGreen);
        TGraphErrors *tresEC = GetPWidth(pull_vs_tb_ec);
        tresEC->SetLineColor(kYellow);
        tresEC->SetMarkerColor(kYellow);
 
        tresTRT->SetTitle("Pull Width VS Drift Time. Pt>2GeV");
        tresTRT->GetXaxis()->SetTitle("Drift Time ");
        tresTRT->GetYaxis()->SetTitle("   ");
        tresTRT->GetYaxis()->SetRangeUser(0.7, 1.3);
        tresTRT->Draw("ALP");
        tresBA->Draw("LP");
        tresBC->Draw("LP");
        tresEA->Draw("LP");
        tresEC->Draw("LP");
 
        this->cd(2);
        TGraphErrors *errorsTRT = GetMeanE(errors_vs_tb_trt);
        TGraphErrors *errorsBA = GetMeanE(errors_vs_tb_ba);
        errorsBA->SetLineColor(kRed);
        errorsBA->SetMarkerColor(kRed);
        TGraphErrors *errorsBC = GetMeanE(errors_vs_tb_bc);
        errorsBC->SetLineColor(kBlue);
        errorsBC->SetMarkerColor(kBlue);
        TGraphErrors *errorsEA = GetMeanE(errors_vs_tb_ea);
        errorsEA->SetLineColor(kGreen);
        errorsEA->SetMarkerColor(kGreen);
        TGraphErrors *errorsEC = GetMeanE(errors_vs_tb_ec);
        errorsEC->SetLineColor(kYellow);
        errorsEC->SetMarkerColor(kYellow);
        errorsTRT->SetTitle("Error VS Drift Time");
        errorsTRT->GetXaxis()->SetTitle("Drift Time");
        errorsTRT->GetYaxis()->SetTitle("mm");
        errorsTRT->GetYaxis()->SetRangeUser(0.05, 0.24);
        errorsTRT->Draw("ALP");
        errorsBA->Draw("LP");
        errorsBC->Draw("LP");
        errorsEA->Draw("LP");
        errorsEC->Draw("LP");
 
        this->cd(3);
        TGraphErrors *ntresBA = GetPn(pull_vs_tb_ba);
        ntresBA->SetLineColor(kRed);
        ntresBA->SetMarkerColor(kRed);
        TGraphErrors *ntresBC = GetPn(pull_vs_tb_bc);
        ntresBC->SetLineColor(kBlue);
        ntresBC->SetMarkerColor(kBlue);
        TGraphErrors *ntresEA = GetPn(pull_vs_tb_ea);
        ntresEA->SetLineColor(kGreen);
        ntresEA->SetMarkerColor(kGreen);
        TGraphErrors *ntresEC = GetPn(pull_vs_tb_ec);
        ntresEC->SetLineColor(kYellow);
        ntresEC->SetMarkerColor(kYellow);
        ntresEA->SetTitle("Number of hits VS Drift Time. Pt>2GeV");
        ntresEA->GetXaxis()->SetTitle("Drift Time");
        ntresEA->GetYaxis()->SetTitle(" hits  ");
        ntresEA->Draw("ALP");
        ntresEC->Draw("LP");
        ntresBA->Draw("LP");
        ntresBC->Draw("LP");
 
        this->cd(4);
        TGraphErrors *terrorsTRT = GetMean(trackerrors_vs_tb_trt);
        TGraphErrors *terrorsBA = GetMean(trackerrors_vs_tb_ba);
        terrorsBA->SetLineColor(kRed);
        terrorsBA->SetMarkerColor(kRed);
        TGraphErrors *terrorsBC = GetMean(trackerrors_vs_tb_bc);
        terrorsBC->SetLineColor(kBlue);
        terrorsBC->SetMarkerColor(kBlue);
        TGraphErrors *terrorsEA = GetMean(trackerrors_vs_tb_ea);
        terrorsEA->SetLineColor(kGreen);
        terrorsEA->SetMarkerColor(kGreen);
        TGraphErrors *terrorsEC = GetMean(trackerrors_vs_tb_ec);
        terrorsEC->SetLineColor(kYellow);
        terrorsEC->SetMarkerColor(kYellow);
        terrorsTRT->SetTitle("Track Error VS Drift Time");
        terrorsTRT->GetXaxis()->SetTitle("Drift Time");
        terrorsTRT->GetYaxis()->SetTitle("mm");
        terrorsTRT->GetYaxis()->SetRangeUser(0.0, 0.07);
        terrorsTRT->Draw("ALP");
        terrorsBA->Draw("LP");
        terrorsBC->Draw("LP");
        terrorsEA->Draw("LP");
        terrorsEC->Draw("LP");
 
        this->cd(5);
        TGraphErrors *residualTRT = GetWidth(residual_vs_tb_trt);
        TGraphErrors *residualBA = GetWidth(residual_vs_tb_ba);
        residualBA->SetLineColor(kRed);
        residualBA->SetMarkerColor(kRed);
        TGraphErrors *residualBC = GetWidth(residual_vs_tb_bc);
        residualBC->SetLineColor(kBlue);
        residualBC->SetMarkerColor(kBlue);
        TGraphErrors *residualEA = GetWidth(residual_vs_tb_ea);
        residualEA->SetLineColor(kGreen);
        residualEA->SetMarkerColor(kGreen);
        TGraphErrors *residualEC = GetWidth(residual_vs_tb_ec);
        residualEC->SetLineColor(kYellow);
        residualEC->SetMarkerColor(kYellow);
        residualTRT->SetTitle("Residual VS Drift Time. Pt > 2GeV");
        residualTRT->GetXaxis()->SetTitle("Drift Time ");
        residualTRT->GetYaxis()->SetTitle("mm");
        residualTRT->GetYaxis()->SetRangeUser(0.05, 0.24);
        residualTRT->Draw("ALP");
        residualBA->Draw("LP");
        residualBC->Draw("LP");
        residualEA->Draw("LP");
        residualEC->Draw("LP");
 
        this->cd(6);
 
        TH2F *residual_trt = (TH2F *)errors->FindKey("tresidual_trt")->ReadObj();
        TH2F *residual_ba = (TH2F *)errors->FindKey("tresidual_ba")->ReadObj();
        TH2F *residual_bc = (TH2F *)errors->FindKey("tresidual_bc")->ReadObj();
        TH2F *residual_ea = (TH2F *)errors->FindKey("tresidual_ea")->ReadObj();
        TH2F *residual_ec = (TH2F *)errors->FindKey("tresidual_ec")->ReadObj();
 
        TH2F *residual_trtP = (TH2F *)errors->FindKey("tresidual_trtP")->ReadObj();
        TH2F *residual_baP = (TH2F *)errors->FindKey("tresidual_baP")->ReadObj();
        TH2F *residual_bcP = (TH2F *)errors->FindKey("tresidual_bcP")->ReadObj();
        TH2F *residual_eaP = (TH2F *)errors->FindKey("tresidual_eaP")->ReadObj();
        TH2F *residual_ecP = (TH2F *)errors->FindKey("tresidual_ecP")->ReadObj();
 
        TGraphErrors *residualTRT1 = GetEntries(residual_trt);
        TGraphErrors *residualBA1 = GetEntries(residual_ba);
        residualBA1->SetLineColor(kRed);
        residualBA1->SetMarkerColor(kRed);
        TGraphErrors *residualBC1 = GetEntries(residual_bc);
        residualBC1->SetLineColor(kBlue);
        residualBC1->SetMarkerColor(kBlue);
        TGraphErrors *residualEA1 = GetEntries(residual_ea);
        residualEA1->SetLineColor(kGreen);
        residualEA1->SetMarkerColor(kGreen);
        TGraphErrors *residualEC1 = GetEntries(residual_ec);
        residualEC1->SetLineColor(kYellow);
        residualEC1->SetMarkerColor(kYellow);
 
        TGraphErrors *residualTRT2 = GetEntries(residual_trtP);
        TGraphErrors *residualBA2 = GetEntries(residual_baP);
        residualBA2->SetLineColor(kRed);
        residualBA2->SetMarkerColor(kRed);
        TGraphErrors *residualBC2 = GetEntries(residual_bcP);
        residualBC2->SetLineColor(kBlue);
        residualBC2->SetMarkerColor(kBlue);
        TGraphErrors *residualEA2 = GetEntries(residual_eaP);
        residualEA2->SetLineColor(kGreen);
        residualEA2->SetMarkerColor(kGreen);
        TGraphErrors *residualEC2 = GetEntries(residual_ecP);
        residualEC2->SetLineColor(kYellow);
        residualEC2->SetMarkerColor(kYellow);
 
        int nbins = residualTRT1->GetN();
 
        TGraphErrors *ratioTRT = new TGraphErrors(nbins);
        TGraphErrors *ratioBA = new TGraphErrors(nbins);
        TGraphErrors *ratioBC = new TGraphErrors(nbins);
        TGraphErrors *ratioEA = new TGraphErrors(nbins);
        TGraphErrors *ratioEC = new TGraphErrors(nbins);
 
        for (int i = 0; i < nbins; i++)
        {
            double prec = 0;
            double all = 0;
            double x = 0;
            residualTRT1->GetPoint(i, x, all);
            residualTRT2->GetPoint(i, x, prec);
            cout << i << " " << x << " " << prec << " " << all << endl;
            if (all > 0)
            {
                ratioTRT->SetPoint(i, x, prec / all);
            }
            else
            {
                ratioTRT->SetPoint(i, x, 0);
            }
            residualBA1->GetPoint(i, x, all);
            residualBA2->GetPoint(i, x, prec);
            cout << i << " " << x << " " << prec << " " << all << endl;
            if (all > 0)
            {
                ratioBA->SetPoint(i, x, prec / all);
            }
            else
            {
                ratioBA->SetPoint(i, x, 0);
            }
 
            residualBC1->GetPoint(i, x, all);
            residualBC2->GetPoint(i, x, prec);
            cout << i << " " << x << " " << prec << " " << all << endl;
            if (all > 0)
            {
                ratioBC->SetPoint(i, x, prec / all);
            }
            else
            {
                ratioBC->SetPoint(i, x, 0);
            }
 
            residualEA1->GetPoint(i, x, all);
            residualEA2->GetPoint(i, x, prec);
            cout << i << " " << x << " " << prec << " " << all << endl;
            if (all > 0)
            {
                ratioEA->SetPoint(i, x, prec / all);
            }
            else
            {
                ratioEA->SetPoint(i, x, 0);
            }
 
            residualEC1->GetPoint(i, x, all);
            residualEC2->GetPoint(i, x, prec);
            cout << i << " " << x << " " << prec << " " << all << endl;
            if (all > 0)
            {
                ratioEC->SetPoint(i, x, prec / all);
            }
            else
            {
                ratioEC->SetPoint(i, x, 0);
            }
            cout << endl;
        }
 
        ratioTRT->SetTitle("Ratio Precision Hits Vs Pt. Pt > 2GeV");
        ratioTRT->GetXaxis()->SetTitle("Precission Hits/Total Hits ");
        ratioTRT->GetYaxis()->SetTitle("pt");
        ratioTRT->GetYaxis()->SetRangeUser(0.05, 0.24);
        ratioTRT->GetYaxis()->SetRangeUser(0.3, 1);
 
        ratioBA->SetLineColor(kRed);
        ratioBC->SetLineColor(kBlue);
        ratioEA->SetLineColor(kGreen);
        ratioEC->SetLineColor(kYellow);
 
        ratioTRT->Draw("alp");
        ratioBA->Draw("lp");
        ratioBC->Draw("lp");
        ratioEA->Draw("lp");
        ratioEC->Draw("lp");
    }
    else
    {
        cout << " Not enough keys in Errors directory for tb dependence plots " << endl;
    }
}

Member Data Documentation

errors

TDirectory* TBDependence::errors

private

Definition at line 4294 of file TRTCalib_makeplots.cxx.

---

The documentation for this class was generated from the following file:

• TRTCalib_makeplots.cxx