BDQViewer.cxx

Go to the documentation of this file.

#include "BDQViewer.h"

#include <RootUtil/CanvasViewer.h>
#include <HistMan/HistMan.h>

#include <TH1F.h>
#include <TH1I.h>
#include <TH2F.h>
#include <TFile.h>
#include <TGTab.h>
#include <TGText.h>
#include <TGTextView.h>
#include <TGText.h>
#include <TApplication.h>
#include <RQ_OBJECT.h>

#include <iostream>
using namespace std;


class Earliest : public CanvasTab
{
    TGTextView* fText;

public:
    Earliest(TGTextView* text) : fText(text) {}

    void Init(TCanvas* canvas) {

        HistMan file_hists("BDP Data Quality/File Hists");

        const char* earliest_names[] = {
            "earliest_dae_stnd",
            "earliest_vme_stnd",
            "earliest_last_dae",
            0
        };
        canvas->SetTitle("Earliest-time plots");
        canvas->Divide(1,3);
        for (int ind=0; earliest_names[ind]; ++ind) {
            canvas->cd(ind+1);
            gPad->SetLogy();
            TH1F* h = file_hists.Get<TH1F>(earliest_names[ind]);
            if (!h) continue;
            h->SetXTitle("#Delta Time (seconds)");
            h->DrawCopy();
        }
    }

    void Expose() {
        fText->Clear();
        fText->AddLine("(a) The time between the first device time (DAE) "
                           "and the spill time from SpillTimeND DB table.  ");
        fText->AddLine("Inherent jitter should be well less than 0.5 seconds.  ");
        fText->AddLine("Anything more than 1 second indicates a missing entry ");
        fText->AddLine("in the SpillTimeND table.");
        fText->AddLine("(b) Same but using the time of the earliest SWIC-like device ");
        fText->AddLine("(from the Hadron/muon/profile monitor's VME crate).");
        fText->AddLine("(c) Repetition period. Typically 2 seconds, but can be larger.");
    }
};

class PerTime : public CanvasTab {
    TGTextView* fText;

public:
    PerTime(TGTextView* text) : fText(text) {}

    void Init(TCanvas* canvas) {
        HistMan file_hists("BDP Data Quality/File Hists");
        const char* per_names[] = {
            "npot_per_hour",
            "npot_per_min",
            "spills_per_hour",
            "spills_per_min",
            0
        };
        canvas->SetTitle("Per time plots");
        canvas->Divide(2,2);
        for (int ind=0; per_names[ind]; ++ind) {
            canvas->cd(ind+1);
            gPad->SetLogy();
            TH1F* h = file_hists.Get<TH1F>(per_names[ind]);
            if (!h) continue;
            h->SetXTitle("Time from start of file");
            h->DrawCopy();
        }
    }

    void Expose() {
        fText->Clear();
        fText->AddLine("Number of protons and spills per hour and minute.  ");
        fText->AddLine("Any drop outs not associated with actual beam down time ");
        fText->AddLine("indicates a problem.");
    }

};

class DbCheck : public CanvasTab {
    TGTextView* fText;
public:
    DbCheck(TGTextView* text) : fText(text) {}

    void Init(TCanvas* canvas) {
        HistMan db_hists("BDP Data Quality/DB Hists");
        const char* db_names[] = {
            "stnd_bdp_dt",
            "stnd_bdp_dt_hour",
            "stnd_bdp_dt_min",
            0
        };
        canvas->SetTitle("STND-BDP plots");
        canvas->Divide(1,3);
        for (int ind=0; db_names[ind]; ++ind) {
            canvas->cd(ind+1);
            if (!ind) {
                gPad->SetLogy();
                TH1F* h1 = db_hists.Get<TH1F>(db_names[ind]);
                if (!h1) continue;
                h1->SetXTitle("SpillTimeND - BDP time");
                h1->DrawCopy();
            }
            else {
                gPad->SetLogy(false);
                TH2F* h2 = db_hists.Get<TH2F>(db_names[ind]);
                if (!h2) continue;
                h2->SetXTitle("Time from begin of file");
                h2->SetYTitle("SpillTimeND - BDP time");
                h2->DrawCopy("colz");
            }
            
        }
    }
    void Expose() {
        fText->Clear();
        fText->AddLine("(a)Difference between SpillTimeND and BeamMonSpill DB entries.");
        fText->AddLine("Anything more than 1 sec from zero indicates lost BeamMonSpill.");
        fText->AddLine("(b)This difference version time in hour bins. ");
        fText->AddLine("This indicates when any loss occurs");
        fText->AddLine("(c)Same but for minute bins");
    }
            
};

class TorCheck : public CanvasTab {
    TGTextView* fText;
public:
    TorCheck(TGTextView* text) : fText(text) {}

    void Init(TCanvas* canvas) {
        HistMan file_hists("BDP Data Quality/File Hists");
        
        const char* tor_names[] = {
            "toroids",
            "tortgt_trtgtd",
            "tor101_tr101d",
            0
        };
        canvas->SetTitle("Toroid comparison plots");
        canvas->Divide(1,3);
        for (int ind=0; tor_names[ind]; ++ind) {
            cerr << "\"" << tor_names[ind] << "\"\n";
            canvas->cd(ind+1);
            if (ind) gPad->SetLogy();
            
            TH1F* h = file_hists.Get<TH1F>(tor_names[ind]);

            if (!h) {
                cerr << "No such TH1F: " << tor_names[ind] << endl;
                continue;
            }
            if (ind) 
                h->SetXTitle(Form("%s differences (npot)",tor_names[ind]));
            else {
                h->SetYTitle("Proton count (tera-protons)");
                h->SetXTitle("Toroids (npot)");
            }
            h->DrawCopy();
        }       
    }

    void Expose() {
        fText->Clear();
        fText->AddLine("(a) Proton count for each NuMI toroid.");
        fText->AddLine("(b) Relative differences between TORTGT and TRTGTD");
        fText->AddLine("(b) Relative differences between TOR101 and TR101D");
        fText->AddLine("These should all be w/in 1%.");
    }
};

class DevCount : public CanvasTab {
    TGTextView* fText;
public:
    DevCount(TGTextView* text) : fText(text) {}

    void Init(TCanvas* canvas) {
        HistMan file_hists("BDP Data Quality/File Hists");
        canvas->SetTitle("Device Counts");
        canvas->Divide(1,2);
        canvas->cd(1);
        TH1F* h = file_hists.Get<TH1F>("dev_count");
        if (h) h->DrawCopy();
        else cerr << "Can't get \"dev_count\" histogram\n";

        canvas->cd(2);
        TVirtualPad* pad = gPad;
        pad->Divide(2,1);

        pad->cd(1);
        TH1I* hi = file_hists.Get<TH1I>("total_blocks");
        if (hi) hi->DrawCopy();
        else cerr << "Can't get \"total_blocks\" histogram\n";

        pad->cd(2);
        hi = file_hists.Get<TH1I>("unique_blocks");
        if (hi) hi->DrawCopy();
        else cerr << "Can't get \"unique_blocks\" histogram\n";
        

    }
    void Expose() {
        fText->Clear();
        fText->AddLine("(a) Number of spills in which various important device exist.");
        fText->AddLine("Any droupouts more than about 1% should be noted.");
        fText->AddLine("(b) Total RawBeamMonBlocks in \"mom\".  Should be one.");
        fText->AddLine("Multiple blocks indicate serious problem!");
        fText->AddLine("(c) \"Unique\" blocks.  When multiple blocks happen they");
        fText->AddLine("can be somewhat filtered.  Should always be 1.");
    }
};


BDQViewer::BDQViewer(const char* filename)
{
    fMain = new TGMainFrame(0, 800,800);
    fMain->SetCleanup(kDeepCleanup);
    fMain->Connect("CloseWindow()", "BDQViewer", this, "CloseWindow()");
    
    fMain->SetWindowName("GuiTest Signal/Slots");
    
    fCTabs = new CanvasTabs(fMain);

    TGTab& tab = fCTabs->GetTabs();
    tab.Connect("Selected(Int_t)", "BDQViewer", this, "DoTab(Int_t)");

    TFile f(filename);
    HistMan io(f);

    fText = new TGTextView(fMain,800,150,"");

    DbCheck* dbcheck  = new DbCheck(fText);
    fCTabs->AdoptTab("SpillTimeND check",dbcheck);
    fCTabs->AdoptTab("File based spill dT",new Earliest(fText));
    fCTabs->AdoptTab("#POT per time",new PerTime(fText));
    fCTabs->AdoptTab("Toroid comparisons",new TorCheck(fText));
    fCTabs->AdoptTab("Device counts",new DevCount(fText));
    dbcheck->Expose();

    TGLayoutHints* lh = new TGLayoutHints(kLHintsBottom | kLHintsLeft |
                                          kLHintsExpandX, 5, 5, 5, 5);
    fMain->AddFrame(fText,lh);

    fMain->Resize(800,800);
    fMain->Layout();
    fMain->MapSubwindows();
    fMain->MapWindow();
    
    //fMain->Print();
}

void BDQViewer::DoTab(Int_t /*tab*/)
{
}

void BDQViewer::CloseWindow() 
{
    gApplication->Terminate();
}

---