Midad/MultiPage/GfxTrack.cxx

Go to the documentation of this file.

#include "GfxTrack.h"
#include "GfxTrackList.h"
#include "GfxTrackListCfg.h"
#include "ViewState.h"
#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandTrackHandle.h>

#include <TMarker.h>
#include <TList.h>
#include <TPolyLine.h>

#include <map>
using namespace std;

GfxTrack::GfxTrack(const CandTrackHandle& cth, GfxTrackList& parent)
    : fTrack(cth)
    , fParent(parent)
    , fImp(0)
{
//    cerr << "Creating GfxTrack with " << cth.GetNDaughters() << " strips\n";
}

GfxTrack::GfxTrack(const GfxTrack& rhs)
    : TObject()
    , fTrack(rhs.fTrack), fParent(rhs.fParent), fImp(0)
{
}


GfxTrack::~GfxTrack()
{
    if (fImp) { delete fImp; fImp = 0; }
}

void GfxTrack::Configure()
{
    if (fImp) { delete fImp; fImp = 0; }


    switch (fParent.GetViewState()->GetSpatialMetric()) {
    case ViewState::metric_is_continuous:
        if (! this->BuildRealImp()) return;
        break;
    case ViewState::metric_is_discreet: default:
        if (! this->BuildDiscreteImp()) return;
        break;
    }

}

int GfxTrack::GetCandTrackData(float *u, float *v, float *z, 
                               float* q, float *t,
                               int *strip_number, int *plane_number)

{
    TIter titr(fTrack.GetDaughterIterator());
    PlaneView::PlaneView_t view = fParent.GetPlaneView();

    int ind=0;
    while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) {
//        cerr << "PlaneView: " << view << " =? " << csh->GetPlaneView() << endl;
        if (csh->GetPlaneView() != view) continue;

        int plane = csh->GetPlane();
        if (plane_number) plane_number[ind] = plane;
        if (strip_number) strip_number[ind] = csh->GetStrip();
        if (u) u[ind] = fTrack.GetU(plane);
        if (v) v[ind] = fTrack.GetV(plane);
        if (z) z[ind] = fTrack.GetZ(plane);
        if (t) t[ind] = fTrack.GetT(plane);
        if (q) q[ind] = csh->GetCharge();

#if 0
        cerr << "index = " << ind
             << " view = " << view
             << " plane = " << plane
             << " strip = " << csh->GetStrip()
             << " u = " << fTrack.GetU(plane)
             << " v = " << fTrack.GetV(plane)
             << " z = " << fTrack.GetZ(plane)
             << " t = " << fTrack.GetT(plane)
             << " q = " << csh->GetCharge()
             << endl;
#endif

        ++ind;
    }
    return ind;
}

bool GfxTrack::BuildRealImp()
{
    float *x=0, *y=0;
    int *plane_number, npoints;

    int n = fTrack.GetNDaughters();
    x = new float[n];
    y = new float[n];
    plane_number = new int[n];

    
    double vx, vy;
    if (fParent.GetPlaneView() == PlaneView::kU) {
        npoints = this->GetCandTrackData(y,0,x,0,0,0,plane_number);
        vy = fTrack.GetVtxU();
    }
    else {                      // kV
        npoints = this->GetCandTrackData(0,y,x,0,0,0,plane_number);
        vy = fTrack.GetVtxV();
    }
    vx = fTrack.GetVtxZ();

    TList* track = new TList;
    track->SetOwner();

    track->Add(new TMarker(vx,vy,3)); // 3 = astrix-ish marker.
    track->Add(new TPolyLine(npoints,x,y));
    fImp = track;

    delete [] x;
    delete [] y;
    delete [] plane_number;

    return true;
}

bool GfxTrack::BuildDiscreteImp()
{
    int      n = fTrack.GetNDaughters();

    // using new [] here causes bizzare segv in unrelated parts of the
    // code, so lets get all FORTRAN about it.
    const int maxstrips = 1000;
    int strip[maxstrips], plane[maxstrips];
    float q[maxstrips];


    n = this->GetCandTrackData(0,0,0,q,0,strip,plane);
    if (n > maxstrips) n = maxstrips;
    
    map<int,float> mean_strip, norm_strip;
    for (int ind = 0; ind < n; ++ind) {
        if (mean_strip.find(plane[ind]) == mean_strip.end()) {
            mean_strip[plane[ind]] = 0;
            norm_strip[plane[ind]] = 0;
        }
        mean_strip[plane[ind]] += strip[ind]*q[ind];
        norm_strip[plane[ind]] += q[ind];
    }

    int vtx_plane = fTrack.GetVtxPlane();
    int vtx_ind = -1, ind;
    float x[maxstrips], y[maxstrips];

    map<int,float>::iterator it, done = mean_strip.end();
    for (ind=0, it = mean_strip.begin(); it != done && n < maxstrips; ++it, ++ind) {
        int plane = it->first;
        float qstrip = it->second;
        float norm = norm_strip[plane];
        x[ind] = plane;
        y[ind] = qstrip/norm;
        if (plane == vtx_plane) {
            vtx_ind = ind;
//            cerr << Form("vertex: %d: plane=%.0f strip=%.1f\n",ind,x[ind],y[ind]);
        }
    }

    TList* track = new TList;
    track->SetOwner();

    if (vtx_ind >= 0) track->Add(new TMarker(x[vtx_ind],y[vtx_ind],3));

    track->Add(new TPolyLine(ind,x,y));
    fImp = track;

    return true;
}

void GfxTrack::ExecuteEvent(int event, int px, int py)
{
    fParent.ExecuteEventTrack(event,px,py,this);
}
void GfxTrack::Paint(Option_t* option)
{
    if (!fImp) return;

    fImp->Paint(option);
}
int GfxTrack::DistancetoPrimitive(int px, int py)
{
    int dist = 0xdead;
    if (fImp) {
        TList* l = dynamic_cast<TList*>(fImp);
        if (!l) 
            dist = fImp->DistancetoPrimitive(px,py);
        else {
            TIter next(l);
            TObject* obj;
            while ((obj=next())) {
                int d = obj->DistancetoPrimitive(px,py);
                if (d < dist) dist = d;
            }
        }
    }
    return dist;
}

---