UserDisplayModule.cxx

Go to the documentation of this file.

#include "UserDisplayModule.h"

#include <Midad/Base/Mint.h>
#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/CanvasSignals.h>
#include <Midad/Base/SteelOutline.h>

#include <JobControl/JobC.h>
#include <RecoBase/CandTrackHandle.h>
#include <RecoBase/CandTrackListHandle.h>
#include <RecoBase/CandStripHandle.h>
#include <MinosObjectMap/MomNavigator.h>

#include <DataUtil/GetDetector.h>
#include <DataUtil/CDL2STL.h>
using namespace DataUtil;

// Boiler plate for using the Message Service.
#include <MessageService/MsgService.h>
CVSID("$Id: UserDisplayModule.cxx,v 1.11 2007/11/11 07:13:48 rhatcher Exp $");

// Boiler plate needed for us to be a Job Module.
#include <JobControl/JobCModuleRegistry.h>
JOBMODULE(UserDisplayModule,"UserDisplay","Example of adding a Midad display in a Job Module\n");


#include <TList.h>
#include <TH2D.h>
#include <TCanvas.h>
#include <TEllipse.h>
#include <TText.h>

UserDisplayModule::UserDisplayModule()
    : fCanvas(0)
    , fUZview(0)
    , fVZview(0)
    , fUVview(0)
    , fSteelOutline(0)
    , fCleanup(0)
{
    fCleanup = new TList;
    fCleanup->SetOwner();
}

UserDisplayModule::~UserDisplayModule()
{
    if (fUZview) delete fUZview;
    if (fVZview) delete fVZview;
    if (fUVview) delete fUVview;
    if (fCleanup) delete fCleanup;
}

void UserDisplayModule::BeginRun()
{
    if (gMint && !fCanvas) this->BuildDisplay();
}

JobCResult UserDisplayModule::Ana(const MomNavigator *mom)
{
    if (gMint) {                // paranoia
        if (&gMint->GetJobC().Mom != mom) {
            MSG("User",kError) << "Module's mom and JobC's mom differ: "
                               << (void*)&gMint->GetJobC().Mom << " != "
                               << (void*) mom << endl;
        }
    }

    if (!fCanvas) {
        // No canvas - we can't do anything, but otherwise nothing
        // to say that there is a problem, so just return "ok".
        MSG("User",kWarning) << "I have no canvas!\n";
        return JobCResult::kAOK;
    }

    this->UpdateDisplay();

    return JobCResult::kAOK;
}

void UserDisplayModule::BuildDisplay()
{
    // Get Ugli for later.  Bail immediately if fail
    UgliGeomHandle ugh = gMint->GetUgliGeomHandle();
    if (! ugh.IsValid()) {
        MSG("User",kWarning) << "Got invalid Ugli\n";
        return;
    }


    const int width = 1000, height = 500;

    CanvasSignals* cs = 0;
    PageDisplay* pd = gMint->GetDisplay();

    // No pre-existing display, so make one to our size
    if (!pd) {
        pd = gMint->SpawnDisplay(width,height);
        cs = dynamic_cast<CanvasSignals*>
            (pd->AddPage("UserCanvas"));
    }
    // A display exists, so let's add a stand alone window (one could
    // also just as well do a PageDisplay::AddPage, but would not have
    // to live with whatever size was given in its creation).
    else {
        cs = dynamic_cast<CanvasSignals*>
            (pd->SpawnSinglePage("UserCanvas",width,height));
    }

    if (!cs) {
        MSG("User",kWarning) << "Failed to get UserCanvas's CanvasSignals\n";
        return;
    }

    // One can use CanvasSignals to connect to various events,
    // eg. zooming or in particular notification of new data.  But
    // since we are in a job module, we already get notification in
    // Ana(), so just use the CanvasSignals to access the TCanvas;
    fCanvas = &cs->GetCanvas();

    // Now fill up the canvas with whatever we want.  This example
    // uses simple 2D colored histograms to present 3 views of the
    // data.
    fCanvas->Divide(2,1);

    // Work out the extents of the histograms.  This implicitly
    // assumes FarDet and probably needs to be improved for NearDet,
    // but should take into account the missing scint. plane in
    // between super modules.
    vector<UgliScintPlnHandle> sph = ugh.GetScintPlnHandleVector();
    int first_plane = sph.begin()->GetPlaneNumber();
    int last_plane = (sph.end()-1)->GetPlaneNumber();
    // Assume strip numbers start from 0!
    int nstrips = sph.begin()->NumberOfStrips();
    
    fCanvas->cd(1);
    fHistPad = new TPad("fHistPad","UZ and VZ views",0,0,1,1);
    fHistPad->Draw();

    fHistPad->cd();
    fHistPad->Divide(1,2);

    // U vs. Z view
    fHistPad->cd(1);
    fUZview = new TH2D("UZview","Strip vs. Plane, U view",
                       last_plane-first_plane+1,first_plane,last_plane+1,
                       nstrips,0,nstrips);
    fUZview->SetStats(false);
    fUZview->Draw("COLZ");

    // V vs. Z view
    fHistPad->cd(2);
    fVZview = new TH2D("VZview","Strip vs. Plane, V view",
                       last_plane-first_plane+1,first_plane,last_plane+1,
                       nstrips,0,nstrips);
    fVZview->SetStats(false);
    fVZview->Draw("COLZ");
    
    // U vs. V view
    fCanvas->cd(2);
    fUVview = new TPad("UVview","U vs V view",0,0,1,1);
    fUVview->SetFillStyle(4000);

    float t[4];
    ugh.GetTransverseExtent(PlaneView::kU,t[0],t[1]);
    ugh.GetTransverseExtent(PlaneView::kV,t[2],t[3]);
    for (int ind=0; ind<4;++ind) t[ind] = TMath::Abs(t[ind]);
    int maxind = TMath::LocMax(4,t);
    float tsize = TMath::Sqrt(2.0) * t[maxind];

    fUVview->Range(-tsize,-tsize,tsize,tsize);
    fUVview->Draw();

    fSteelOutline = new SteelOutline(DataUtil::GetDetector(gMint->GetJobC().Mom));
}

void UserDisplayModule::AddTrack(const CandTrackHandle* cth)
{
    UgliGeomHandle ugh = gMint->GetUgliGeomHandle();
    if (! ugh.IsValid()) {
        MSG("User",kWarning) << "Got invalid Ugli\n";
        return;
    }

    // Track daughter list are a set of candidate strips.
    TIter titr(cth->GetDaughterIterator());

    while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) {
        int plane = csh->GetPlane();
        int strip = csh->GetStrip();
        float charge = csh->GetCharge();

        switch (csh->GetPlaneView()) {
        case PlaneView::kU:
            fUZview->Fill(plane,strip,charge);
            break;
        case PlaneView::kV:
            fVZview->Fill(plane,strip,charge);
            break;
        default:                // silently ignore
            break;
        }

        double radius = 4.0*Munits::centimeter;
        double x,y, u = cth->GetU(plane), v = cth->GetV(plane);
        ugh.uv2xy(u,v,x,y);

        fUVview->cd();
        TEllipse* el = new TEllipse(x,y,radius,radius);
        el->Draw();
        fCleanup->Add(el);
    }

}

static void clear_hist(TH2D* hist)
{
    hist->Reset();
    hist->GetXaxis()->UnZoom();
    hist->GetYaxis()->UnZoom();
}

void UserDisplayModule::UpdateDisplay()
{
    static TText* no_tracks = 0;

    if (! no_tracks) {
        no_tracks = new TText(0.,0.,"No Tracks");
        no_tracks->SetTextSizePixels(100);
        no_tracks->SetTextColor(2);
    }

    clear_hist(fUZview);
    clear_hist(fVZview);
    fUVview->Clear();
    fCleanup->Delete();

    fUVview->cd();
    fSteelOutline->Draw();

    // Get whatever tracks Mint has as current.
    const CandTrackListHandle* ctlh = gMint->GetTracks();

    if (ctlh && ctlh->GetNDaughters()) {
        typedef vector<const CandTrackHandle*> TrackVector_t;
        TrackVector_t tv = CDL2STLvector<const CandTrackHandle>(*ctlh);
        for (unsigned int ind = 0; ind < tv.size(); ++ind) {
            this->AddTrack(tv[ind]);
        }
    }
    else no_tracks->Draw();


    fUVview->Modified();
    fHistPad->cd(1);
    gPad->Modified();
    fHistPad->cd(2);
    gPad->Modified();
    fCanvas->Modified();
    fCanvas->Update();
}

---