Mint.cxx

Go to the documentation of this file.

#include "Mint.h"
#include "MCint.h"
#include "PageDisplay.h"
#include "PageDisplayConfig.h"

#include <Midad/Gui/GuiMainWindow.h>
#include <Midad/Gui/GuiButton.h>

#include <JobControl/JobC.h>
#include <CandData/CandHeader.h>
#include <CandDigit/CandDigitListHandle.h>
#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandStripListHandle.h>
#include <RecoBase/CandTrackListHandle.h>
#include <RecoBase/CandShowerListHandle.h>
#include <Plex/PlexSEIdAltL.h>
#include <CandDigit/CandDigitHandle.h>

#include <DataUtil/GetUgliGeomHandle.h>
#include <DataUtil/GetCandidate.h>
#include <DataUtil/GetCandHeader.h>
#include <DataUtil/GetDetector.h>
#include <DataUtil/CDL2STL.h>
#include <Util/LoadMinosPDG.h>

#include <TSystem.h>
#include <TTimer.h>

#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>

using namespace SigC;

#include <vector>
#include <iostream>
using namespace std;

Mint* gMint = 0;

ClassImp(Mint)

Mint::Mint(JobC& jc)
    : fJint(jc)
    , fMCint(0)
    , fFreeRunning(false)
    , fPause(0)
    , fTimer(0)
{
    fTimeRange = manage(new Range<double>());
    fTimeExtrema = manage(new Range<double>());
    fChargeRange = manage(new Range<double>());
    fChargeExtrema = manage(new Range<double>());
    gMint = this;
    fMCint = new MCint(*this);
    fJint.mom_modified.connect(slot_class(*this,&Mint::NewMom));

    fCandidateLookup.UnLockValues();
    fCandidateLookup.Set("CandDigitList","");
    fCandidateLookup.Set("CandStripList","");
    fCandidateLookup.Set("CandTrackList","");
    fCandidateLookup.Set("CandShowerList","");

    // get the TDatabasePDG initialized and populated
    LoadMinosPDG();
}

Mint::~Mint() 
{
}

JobC& Mint::GetJobC() const
{
    return fJint.GetJobC();
}
MCint& Mint::GetMCint() const
{
    return *fMCint;
}
PageDisplay* Mint::SpawnDisplay(int width, int height,
                                const PageDisplayConfig* cfg)
{

    GuiMainWindow* gmw = new GuiMainWindow(width-1,height-1);
    gmw->SetWindowName("Midad");

    PageDisplay* pd = new PageDisplay(*gmw,this);
    PageDisplayConfig default_pdc;
    if (!cfg) cfg = &default_pdc;
    pd->Init(*cfg);
    pd->close_window.connect(slot(*gmw,&GuiMainWindow::SendCloseMessage));
    fJint.mom_modified.connect(slot(*pd,&PageDisplay::ClearDisplay));
    fJint.mom_modified.connect(slot(*pd,&PageDisplay::UpdateDisplay));
                                    
    gmw->Add(*pd);

    gmw->ShowAll();
//    gmw->SetMinSize();
    gmw->Resize(width,height);
    gmw->ConnectClose(true);     // delete

    fDisplays.push_back(pd);

    return pd;
}
PageDisplay* Mint::GetDisplay(int which /*=0*/)
{
    int ndisps = fDisplays.size();

    if (which < 0 || which >= ndisps) {
        cerr << "Can't get display #" << which 
             << ", (have " << ndisps << ")\n";
        return 0;
    }
    return fDisplays[which];
}

class MyTimer : public TTimer {
public:

    MyTimer(Mint* mint, Mint::MintMoveMeth_t move)
        : TTimer(), fMint(mint), fMove(move) {}

    virtual Bool_t Notify() {
        (fMint->*fMove)();
        delete this;
        return kTRUE;
    }
private:
    Mint* fMint;
    Mint::MintMoveMeth_t fMove;

};

void Mint::DoMovement(Mint::MintMoveMeth_t move)
{
    if (fFreeRunning) {
        for (unsigned int ind = 0; ind < fDisplays.size(); ++ind) 
            fDisplays[ind]->ProcessEvents();

        if (fFreeRunning) {     // still?
            if (fPause <= 0)  { (this->*move)(); }
            else { 
                MyTimer* mt = new MyTimer(this,move); // launch timer
                mt->Start(fPause, kTRUE);
            }
        }
    }
    
}

void Mint::Next()
{
    fJint.Next();
    this->DoMovement(&Mint::Next);
}
void Mint::NextPass()
{
    fJint.NextPass();
    this->DoMovement(&Mint::NextPass);
}
void Mint::Prev()
{
    fJint.Prev();
    this->DoMovement(&Mint::Prev);
}
void Mint::GoTo(int run, int snarl)
{
    fJint.GoTo(run,snarl);
}

void Mint::SetFreeRunning(bool tf)
{
    fFreeRunning = tf;
    if (fFreeRunning) 
        cerr << "Will free run - click Next/Prev button\n";
    else
        cerr << "Free run stopped after next event\n";
}

void Mint::SetPause(Long_t ms)
{
    fPause = ms;
    cerr << "SetPause(" << ms << ")\n";
}


void Mint::NewMom()
{
    this->DumpMom();
//    fSelectedDigits.clear();
    fPickedDigit = 0;
//    this->UpdateStripRanges();
    this->UpdateDigitRanges();
    if (fMCint) fMCint->Update();
}
    
void Mint::DumpMom()
{
    const MomNavigator* mom = fJint.GetMom();
    if (!mom) {
        cerr << "Mint::DumpMom: no MOM!\n";
        return;
    }

    CandRecord* crec = dynamic_cast<CandRecord*>
        (mom->GetFragment("CandRecord", "PrimaryCandidateRecord"));
    if (!crec) {
        cerr << "Mint::DumpMom: no CandRecord\n";
        return;
    }

    const TObjArray oa = crec->GetCandHandleList();
    int last = oa.GetLast();
    cerr << "Contents of PrimaryCandidateRecord:\n";
    for (int i = 0; i <= last; ++i) {
        TObject* o = oa.At(i);
        if (!o) continue;
        CandHandle* ch = dynamic_cast<CandHandle*>(o);
        if (!ch) {
            cerr << "\t" << o->ClassName() << " not a CandHandle\n";
            continue;
        }
//        if (!ch->GetCandBase()) {
//            cerr << "\t" << 0->ClassName() << " doesn't have a CandBase!!!\n";
//            continue;
//        }
        cerr << "\t" << o->ClassName() << "::" << o->GetName()<< endl;
    }
    
}

UgliGeomHandle Mint::GetUgliGeomHandle()
{
    return DataUtil::GetUgliGeomHandle(&(this->GetJobC().Mom));
}


// For now, just hard code stuff.
CandDigitListHandle* Mint::GetDigits() const
{
    const char* name = 0;
    fCandidateLookup.Get("CandDigitList",name);
    return DataUtil::GetCandidate<CandDigitListHandle>
        (&(this->GetJobC().Mom),"CandDigitListHandle",name);
}
CandStripListHandle* Mint::GetStrips() const
{
    const char* name = 0;
    fCandidateLookup.Get("CandStripList",name);
    return DataUtil::GetCandidate<CandStripListHandle>
        (&(this->GetJobC().Mom),"CandStripListHandle",name);
}
CandTrackListHandle* Mint::GetTracks() const
{
    const char* name = 0;
    fCandidateLookup.Get("CandTrackList",name);
    return DataUtil::GetCandidate<CandTrackListHandle>
        (&(this->GetJobC().Mom),"CandTrackListHandle",name);
}
CandShowerListHandle* Mint::GetShowers() const
{
    const char* name = 0;
    fCandidateLookup.Get("CandShowerList",name);
    return DataUtil::GetCandidate<CandShowerListHandle>
        (&(this->GetJobC().Mom),"CandShowerListHandle",name);
}


Detector::Detector_t Mint::GetDetector() const
{
    Detector::Detector_t dt = 
        DataUtil::GetDetector(this->GetJobC().Mom);
    return dt;
}

void Mint::UpdateStripRanges()
{
    Detector::Detector_t det = this->GetDetector();
    if (det == Detector::kUnknown) return;

    const CandStripListHandle* cslh = this->GetStrips();
    if (!cslh) return;

    vector<const CandStripHandle*> dv = 
        DataUtil::CDL2STLvector<CandStripHandle>(*cslh);
    int siz = dv.size();
    if (! siz) return;

    double tmin=0, tmax=0, qmin=0,qmax=0;
    bool first = true;
    for (int ind = 0; ind < siz; ++ind) {
        const CandStripHandle* csh = dv[ind];
        double t = csh->GetTime();
        double q = csh->GetCharge();
        if (first) {
            tmin = tmax = t;
            qmin = qmax = q;
            first=false;
            continue;
        }
        if (t < tmin) tmin = t;
        if (t > tmax) tmax = t;
        if (q < qmin) qmin = q;
        if (q > qmax) qmax = q;
    }

    if (!first) {
        // work around div by zero in TGDoubleSlider
        double eps = 1.0e-10;
        if (tmin == tmax) { tmin -= eps; tmax += eps; }
        if (qmin == qmax) { qmin -= eps; qmax += eps; }

        fTimeRange->Set(tmin,tmax);
        fTimeExtrema->Set(tmin,tmax);
        fChargeRange->Set(qmin,qmax);
        fChargeExtrema->Set(qmin,qmax);
    }
}

void Mint::UpdateDigitRanges()
{
    Detector::Detector_t det = this->GetDetector();
    if (det == Detector::kUnknown) return;

    const CandDigitListHandle* cslh = this->GetDigits();
    if (!cslh) return;

    vector<const CandDigitHandle*> dv = 
        DataUtil::CDL2STLvector<CandDigitHandle>(*cslh);
    int siz = dv.size();
    if (! siz) return;

    double tmin=0, tmax=0, qmin=0,qmax=0;
    bool first = true;

    for (int ind = 0; ind < siz; ++ind) {
        const CandDigitHandle* csh = dv[ind];
        const PlexSEIdAltL& altl = csh->GetPlexSEIdAltL();
        PlaneView::PlaneView_t pv = altl.GetPlaneView();
        if (det != Detector::kCalib && 
           pv != PlaneView::kU && pv != PlaneView::kV) continue;

        altl.SetFirst();
        while (altl.IsValid()) {
          double t = altl.GetCurrentItem().GetTime();
          double q = altl.GetCurrentItem().GetPE();
          if (first) {
              tmin = tmax = t;
              qmin = qmax = q;
              first=false;
              continue;
          }
          if (t < tmin) tmin = t;
          if (t > tmax) tmax = t;
          if (q < qmin) qmin = q;
          if (q > qmax) qmax = q;
          altl.Next();
        }
    }
    // give some buffer at either end...
    tmax +=  0.02*(tmax - tmin);
    tmin += -0.02*(tmax - tmin);
    qmax +=  0.02*(qmax - qmin);
    qmin += -0.02*(qmax - qmin);

    // cerr << endl; 
    // cerr << " tmin, tmax = " << tmin << "  " << tmax << endl;
    // cerr << " qmin, qmax = " << qmin << "  " << qmax << endl;
    if (!first) {
        // work around div by zero in TGDoubleSlider
        double eps = 1.0e-8;
        if (tmin == tmax) { tmin -= eps; tmax += eps; }
        if (qmin == qmax) { qmin -= eps; qmax += eps; }

        fTimeRange->Set(tmin,tmax);
        fTimeExtrema->Set(tmin,tmax);
        fChargeRange->Set(qmin,qmax);
        fChargeExtrema->Set(qmin,qmax);
    }
}


void Mint::SetSelectedDigits(Mint::DigitVector_t dv)
{
    fSelectedDigits = dv;
    digits_selected.emit();
}
Mint::DigitVector_t Mint::GetSelectedDigits(void) const
{
    return fSelectedDigits;
}
void Mint::SetPickedDigit(const CandDigitHandle& cdh)
{
    fPickedDigit = &cdh;
    digit_picked.emit();
}
void Mint::SetPickedDigit(const CandDigitHandle& cdh,
                          const PlexSEIdAltLItem& /*itm*/)
{
    fPickedDigit = &cdh;
    digit_picked.emit();
}
const CandDigitHandle* Mint::GetPickedDigit() const
{
    return fPickedDigit;
}


void Mint::SetSelectedStrips(Mint::StripVector_t dv)
{
    fSelectedStrips = dv;
    strips_selected.emit();
}
Mint::StripVector_t Mint::GetSelectedStrips(void) const
{
    return fSelectedStrips;
}
void Mint::SetPickedStrip(const CandStripHandle& cdh)
{
    fPickedStrip = &cdh;
    strip_picked.emit();
}
const CandStripHandle* Mint::GetPickedStrip() const
{
    return fPickedStrip;
}

---