PmtPixels.cxx

Go to the documentation of this file.

#include "PmtPixels.h"
#include "Mint.h"
#include <Midad/Util/Range.h>
#include <Midad/Util/RangeControl.h>

#include <CandDigit/CandDigitHandle.h>

#include <TList.h>
#include <TBox.h>

#include <sigc++/class_slot.h>

#include <iostream>
using namespace std;

// PmtPixels: main object
PmtPixels::PmtPixels()
    : TPad("PmtPixels","Signals in the PMT",0,0,1,1)
    , fImp(0)
{
    cerr << "PmtPixels()\n";
}
PmtPixels::PmtPixels(double x1, double y1, double x2, double y2)
    : TPad("PmtPixels","Signals in the PMT",x1,y1,x2,y2)
    , fImp(0)
{
    cerr << "PmtPixels()\n";
}

PmtPixels::~PmtPixels()
{
}

void PmtPixels::SetMint(Mint* mint)
{
    fCon.disconnect();
    this->MintView::SetMint(mint);
    fCon = mint->digits_selected.connect
        (SigC::slot_class(*this,&PmtPixels::Refresh));
}

void PmtPixels::BuildImp()
{
    // This build the implementation.  It is assumed that we only need
    // to build it once.


    Detector::Detector_t det_type = this->GetMint().GetDetector();

    switch (det_type) {
    case Detector::kNear:
        this->cd();
        fImp = new PmtPixelsMxx(8);
        break;
    case Detector::kFar:
        this->cd();
        fImp = new PmtPixelsMxx(4);
        break;
    default:
        delete fImp;
        fImp = 0;
        cerr << "PmtPixels::BuildImp() unknown detector type: " 
             << det_type << endl;
        break;
    }
}

void PmtPixels::Refresh()
{
    if (!fImp) this->BuildImp();
    if (!fImp) return;


    const CandDigitHandle* cdh = this->GetMint().GetPickedDigit();
        
    if (!cdh) return;

    PlexPixelSpotId ppsid = 
        cdh->GetPlexSEIdAltL().GetBestItem().GetPixelSpotId();

    RangeDouble& rd = this->GetMint().GetChargeRange();
    double relval = rd.Relative(cdh->GetCharge());

    fImp->Clear();
    fImp->SetPixelSpot(ppsid,relval);

    this->TPad::Modified();
    this->TPad::Update();

    // get data from Mint and feed the imp.
}



// PmtSpot: one fiber
PmtSpot::PmtSpot(int /*spot_num*/, double xc, double yc, double radius)
    : TEllipse(xc,yc,radius,radius)
{
    this->TEllipse::SetFillStyle(1001);
    this->SetRelativeColor(0);
}
PmtSpot::~PmtSpot()
{
}

void PmtSpot::SetRelativeColor(double relval)
{
    static Rainbow rainbow;
    this->TEllipse::SetFillColor(rainbow.GetRelativeColor(relval));
}


// PmtPixel: one pixel = box + spots
PmtPixel::PmtPixel(int /*pixel_num*/, double xc, double yc, double w, double h)
    : TBox(xc-0.5*w, yc-0.5*h, xc+0.5*w, yc+0.5*h)
{
    double r = 0.5*(w+h);       // normally, expect w == h.
    r /= 6.0;                   // assume pmt pixel is 3 fibers wide
    
    const double dy = r*sqrt(3.0);
    
    this->push_back(new PmtSpot(1,xc+2*r, yc+dy,r));
    this->push_back(new PmtSpot(2,xc,     yc+dy,r));
    this->push_back(new PmtSpot(3,xc-2*r, yc+dy,r));

    this->push_back(new PmtSpot(4,xc+r,   yc,    r));
    this->push_back(new PmtSpot(5,xc-r,   yc,    r));

    this->push_back(new PmtSpot(6,xc+2*r, yc-dy,r));
    this->push_back(new PmtSpot(7,xc,     yc-dy,r));
    this->push_back(new PmtSpot(8,xc-2*r, yc-dy,r));
}

PmtPixel::~PmtPixel()
{
    iterator it, done = this->end();
    for (it = this->begin(); it != done; ++it) {
        PmtSpot* ps = (*it);
        delete ps;
        (*it) = 0;
    }

}
    
void PmtPixel::Draw(Option_t* opt)
{
    this->TBox::Draw(opt);
    this->TBox::SetFillStyle(0);
    this->TBox::SetLineColor(1);
    
    iterator it, done = this->end();
    for (it = this->begin(); it != done; ++it) {
        PmtSpot* ps = (*it);
        ps->Draw(opt);
    }
}

// Base class for the full PMT worth of pixels
PmtPixelsMxx::PmtPixelsMxx(int pixels_wide /*=4*/)
{
    int pixel_num = 0;
    // The width in some units
    const double real_width = 1.0;
    // border around each pixel
    const double d = 0.01*real_width; 
    // The width of one pixel
    const double w = (real_width - (2.0*pixels_wide)*d)/(pixels_wide);

    // indices origin is in upper right.  
    for (int yind = 0; yind < pixels_wide; ++yind) {
        double yc = (2*(pixels_wide-yind)-1)*(0.5*w+d);

        for (int xind = 0; xind < pixels_wide; ++xind) {
            double xc = (2*(pixels_wide-xind)-1)*(0.5*w+d);

            PmtPixel* pixel = new PmtPixel(pixel_num,xc,yc,w,w);
            this->push_back(pixel);
            pixel->Draw();
        }
    }

}

PmtPixelsMxx::~PmtPixelsMxx() 
{
    iterator it, done = this->end();
    for (it = this->begin(); it != done; ++it) {
        PmtPixel* pp = (*it);
        delete pp;
        *it = 0;
    }
}

void PmtPixelsMxx::Clear()
{
    iterator it, done = this->end();
    for (it = this->begin(); it != done; ++it) {
        PmtPixel* pp = *it;
        
        PmtPixel::iterator ppit, ppdone = pp->end();
        for (ppit = pp->begin(); ppit != ppdone; ++ppit) {
            PmtSpot* ps = *ppit;
            ps->SetRelativeColor(0);
        }
    }
}

void PmtPixelsMxx::SetPixelSpot(const PlexPixelSpotId& ppsid, double relval)
{
    int pixel = ppsid.GetPixel();
    int spot = ppsid.GetSpot();

    (*(*this)[pixel])[spot]->SetRelativeColor(relval);
}

---