Midad/MultiPage/GfxDigitList.cxx

Go to the documentation of this file.

#include "GfxDigitList.h"
#include "GfxDigitListCfg.h"
#include "GfxProxy.h"
#include "GfxDigitListMenu.h"
#include "MultiPage.h"
#include "ViewState.h"

#include <Midad/Base/PageDisplay.h>
#include <Midad/Base/Mint.h>
#include <Midad/Base/Rainbow.h>
#include <Midad/Base/DigitText.h>
#include <Midad/Util/Range.h>
#include <Midad/Gui/GuiSlider.h>
//#include <Midad/Util/Util.h>

#include <Conventions/Munits.h>

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

#include <CandDigit/CandDigitHandle.h>
#include <CandDigit/CandDigitListHandle.h>

#include <Conventions/PlaneView.h>

#include <Plex/PlexSEIdAltL.h>
#include <Plex/PlexSEIdAltLItem.h>
#include <Plex/PlexStripEndId.h>
#include <Record/RecArrayAllocator.h>

#include <MessageService/MsgService.h>
CVSID("$Id: GfxDigitList.cxx,v 1.14 2003/10/27 20:32:16 bv Exp $");

#include <Buttons.h> // part of ROOT
#include <TClonesArray.h>

#include <sigc++/sigc++.h>
#include <sigc++/class_slot.h>
using namespace SigC;

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


GfxProxy<GfxDigitList> 
gsGfxDigitListProxy("DigitList", new GfxDigitListMenu());


GfxDigitList::GfxDigitList()
    : fCfg(0)
    , fColorRange(0)
    , fMultiPage(0)
    , fMint(0)
    , fDigitCA(0)
    , fHideDigits(false)
{
    fCfg = new GfxDigitListCfg();
    fCfg->modified_signal.connect
        (SigC::slot_class(*this,&GfxDigitList::ReConfigure));

    RecArrayAllocator& a = RecArrayAllocator::Instance();
    fDigitCA = a.GetArray("GfxDigit");
}

GfxDigitList::~GfxDigitList()
{
    if (!fDigitCA) return;
    RecArrayAllocator& a = RecArrayAllocator::Instance();
    a.ReleaseArray(fDigitCA); 
    fDigitCA = 0; 
}

void GfxDigitList::Init(PageDisplay& pd, MultiPage& mp)
{
    fColorRange = &mp.GetColorRangeControl(this->GetPlaneView()).GetRange();
    ViewState* vs = this->GetViewState();
    vs->color_semantic.connect(slot_class(*this,&GfxDigitList::ReConfigure));
    vs->spatial_metric.connect(slot_class(*this,&GfxDigitList::ReConfigure));
    fPageDisplay = &pd;
    fMultiPage = &mp;
}

static bool select_digit(const CandDigitHandle* cdh, 
                         PlaneView::PlaneView_t view,
                         RangeDouble* time_range)
{
    if (!cdh) return false;
    return cdh->GetPlexSEIdAltL().GetPlaneView() == view 
        && time_range->InRange(cdh->GetPlexSEIdAltL().GetBestItem().GetTime());
}

void GfxDigitList::Configure(Mint& mint)
{
    fMint = &mint;

    const CandDigitListHandle* cslh = mint.GetDigits();
    if (!cslh || !cslh->GetNDaughters()) {
        this->ClearDigitList();
        return;
    }

    RangeDouble& time_range = 
        fPageDisplay->GetTimeSlider().GetRangeCtrl().GetRange();

    Mint::DigitVector_t sv = CDL2STLvector<CandDigitHandle>(*cslh);

    Mint::DigitVector_t::iterator it, first = sv.begin(), middle, last = sv.end();

    Slot1<bool,const CandDigitHandle*> s =
        bind(slot(select_digit),this->GetPlaneView(),&time_range);
    middle = std::partition(first,last,s);

    this->ClearDigitList();

    bool show_mux = this->GetViewState()->ShowMultiplex();

    int count = 0; 
    for (it = first; it != middle; ++it) {
        const PlexSEIdAltL& altl = (*it)->GetPlexSEIdAltL();
        if (show_mux) {
            int siz = altl.size();
            for (int ind = 0; ind < siz; ++ind) {
                int last = fDigitCA->GetLast()+1;
                new ((*fDigitCA)[last]) GfxDigit(**it,altl[ind],*this);
                GfxDigit* gs = dynamic_cast<GfxDigit*>(fDigitCA->UncheckedAt(last));
                fDigits.push_back(gs);
                count++;
            }
        }
        else {                  // only show demuxed digits
            const PlexSEIdAltLItem& item = altl.GetBestItem();
            if (item.IsZeroWeight()) continue;
            int last = fDigitCA->GetLast()+1;
            new ((*fDigitCA)[last]) GfxDigit(**it,item,*this);
            GfxDigit* gs = dynamic_cast<GfxDigit*>(fDigitCA->UncheckedAt(last));
            fDigits.push_back(gs);
            count++;
        }
    }
    MSG("Midad",Msg::kVerbose) << "Configure: Count = " << count << endl;
    this->ReConfigure();

}

void GfxDigitList::ReConfigure(void)
{
    if (!fMint) return;
    if (fHideDigits) return;

    // configure all GfxDigits
    int count = 0;
    GfxDigitVector_t::iterator it, done = fDigits.end();
    for (it = fDigits.begin(); it != done; ++it) {
       (*it)->Configure();
       count++;
    }
    MSG("Midad",Msg::kVerbose) << "Reconfig:  Count = " << count << endl;
}

void GfxDigitList::Draw(Option_t *option)
{
    GfxDigitVector_t::iterator it, done = fDigits.end();
    for (it = fDigits.begin(); it != done; ++it) 
        (*it)->Draw(option);
}


// Private methods:
void GfxDigitList::ClearDigitList()
{
    fDigits.clear();
    fDigitCA->Clear("C");
}

void GfxDigitList::ExecuteEventDigit(int event, int /*px*/, int /*py*/, 
                                     GfxDigit* gfx_digit)
{
    switch (event) {
    case kMouseEnter: {
        PlexStripEndId  seid;
        const PlexSEIdAltLItem* itm; 
        const CandDigitHandle& cdh = gfx_digit->GetDigit();
        const PlexSEIdAltLItem& item = gfx_digit->GetItem();

        itm = &item;
        if (itm) {
          seid = itm->GetSEId();
        }
        else {
          const PlexSEIdAltL& altl = cdh.GetPlexSEIdAltL();
          PlexStripEndId      best = altl.GetBestSEId();

          altl.SetFirst();
          while(altl.IsValid()) {
            seid = altl.GetCurrentSEId();
            if (seid == best) {
              const PlexSEIdAltLItem& curr = altl.GetCurrentItem();
              itm = &curr;
            }
            altl.Next();
          }
        }

        const char* s = Form("Digit: strip=%d, plane=%d, charge=%.1f, t=%.1f ns (%s)",
                             seid.GetStrip(),
                             seid.GetPlane(),
                             itm->GetPE(), 
                             itm->GetTime()/Munits::ns, seid.AsString());
        text_info.emit(s);

        DigitText* dt = fPageDisplay->GetDigitText();
        if (dt) {
            dt->Clear();
            dt->AddCandDigitText(cdh);
        }
        if (fMint) {
            fMint->SetPickedDigit(cdh);
        }
        
        break;
    }
    default: // nothing
        break;
    }
}

bool GfxDigitList::DigitMasked(const CandDigitHandle& cdh) const
{
    if (!fColorRange) return false;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = cdh.GetTime();
        break;
    case ViewState::color_is_charge:
        val = cdh.GetCharge();
        break;
    default:
        return false;
        break;
    }

    bool ret = fColorRange->InRange(val);
    return !ret;
}

bool GfxDigitList::DigitMasked(const CandDigitHandle& /*cdh*/, 
                               const PlexSEIdAltLItem& itm) const
{
    if (!fColorRange) return false;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = itm.GetTime();
        break;
    case ViewState::color_is_charge:
        val = itm.GetPE();
        break;
    default:
        return false;
        break;
    }

    bool ret = fColorRange->InRange(val);
    return !ret;
}

int GfxDigitList::GetDigitColor(const CandDigitHandle& cdh) const
{
    if (!fColorRange) return false;

    static Rainbow rainbow;

    if (this->DigitMasked(cdh)) return 0;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = cdh.GetTime();
        break;
    case ViewState::color_is_charge:
        val = cdh.GetCharge();
        break;
    default:
        return 0;
        break;
    }

    return rainbow.GetRelativeColor(fColorRange->Relative(val));
}

int GfxDigitList::GetDigitColor(const CandDigitHandle& cdh, 
                                const PlexSEIdAltLItem& itm) const
{
    if (!fColorRange) return false;

    static Rainbow rainbow;

    if (this->DigitMasked(cdh,itm)) return 0;

    double val=0;
    switch (this->GetViewState()->GetColorSemantic()) {
    case ViewState::color_is_time:
        val = itm.GetTime();
        break;
    case ViewState::color_is_charge:
        val = itm.GetPE();
        break;
    default:
        return 0;
        break;
    }

    return rainbow.GetRelativeColor(fColorRange->Relative(val));
}
void GfxDigitList::HideDigits(bool hide)
{
    fHideDigits = hide;
    this->ReConfigure();
    fMultiPage->UpdateCanvas();
}

---