GfxShower.cxx

Go to the documentation of this file.

#include "GfxShower.h"
#include "GfxShowerList.h"
#include "GfxShowerListCfg.h"
#include "ViewState.h"
#include <RecoBase/CandStripHandle.h>
#include <RecoBase/CandShowerHandle.h>
#include <UgliGeometry/UgliGeomHandle.h>
#include <UgliGeometry/UgliStripHandle.h>

#include <CandDigit/CandDigitHandle.h>
#include <Plex/PlexSEIdAltL.h>
#include <TEllipse.h>
#include <TBox.h>
#include <TPad.h>



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

#include <map>
using namespace std;

ClassImp(GfxShower)

GfxShower::GfxShower(const CandShowerHandle& cth, GfxShowerList& parent)
    : fShower(cth)
    , fParent(parent)
    , fImp(0)
{
//    cerr << "Creating GfxShower with " << cth.GetNDaughters() << " strips\n";
}

GfxShower::GfxShower(const GfxShower& rhs)
    : TObject()
      ,fShower(rhs.fShower), fParent(rhs.fParent), fImp(0)
{
}


GfxShower::~GfxShower()
{
  this->Clear();
}

void GfxShower::Clear(Option_t*)
{
  if (fImp) delete fImp; fImp=0;
}
void GfxShower::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 GfxShower::GetCandShowerData(float *u, float *v, 
                               float *x, float *y, float *z, 
                               float *q, float *t,
                               int *strip_number, int *plane_number)

{
    TIter titr(fShower.GetDaughterIterator());
    PlaneView::PlaneView_t view = fParent.GetPlaneView();
    GraphicsView::GraphicsView_t gview = fParent.GetGraphicsView();

    int ind=0;
    titr.Reset();
    while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) {

      if(csh->GetPlaneView() == view ||
          gview == GraphicsView::kUV || gview == GraphicsView::kXY) 
        {
                
          int plane = csh->GetPlane();
          if (plane_number) {
            plane_number[ind] = plane;
          }
          if (strip_number) {
            strip_number[ind] = csh->GetStrip();
          }
          if (u){
            if(csh->GetPlaneView() == PlaneView::kV)
              {
                u[ind]=csh->GetTPos();
              }
            else
              {
                u[ind] = fShower.GetU(plane);
              }
          }
          if (v) {
            if(csh->GetPlaneView() == PlaneView::kU)
              {
                v[ind]=csh->GetTPos();
              }
            else
              {
                u[ind] = fShower.GetV(plane);
              }

          }
          if (x) {
            if(csh->GetPlaneView() == PlaneView::kV)
              {
                x[ind] = 0.70710678*(fShower.GetU(plane)-csh->GetTPos());
              }
            else
              {
                x[ind] = 0.70710678*(csh->GetTPos()-fShower.GetV(plane));
              }
           
          }
          if (y) {
            if(csh->GetPlaneView() == PlaneView::kV)
              {
                y[ind] = 0.70710678*(fShower.GetU(plane)+csh->GetTPos());
              }
            else
              {
                y[ind] = 0.70710678*(csh->GetTPos()+fShower.GetV(plane));
              }
           
          }
          if (z) {
            z[ind] = csh->GetZPos();
          }
          if (t) {
            t[ind] = csh->GetCorrBegTime();
          }
          if (q) {
            q[ind] = fShower.GetEnergy();
          }     
          ++ind;
        }
    }
    return ind;
}

bool GfxShower::BuildRealImp(){
  float *x=0, *y=0;
  int *plane_number;
  int npoints=0;
  
  int vtxColor=28;
  int shwrStripColor=46;
  fColor=vtxColor;
  
  if(fParent.GetEVD()->GetCandEvent()){
    Bool_t found=false;
    CandEventHandle * ev = fParent.GetEVD()->GetCandEvent();
    Int_t nShowers = ev->GetLastShower()+1;
    for (Int_t it=0;it<nShowers;it++){
      const CandShowerHandle * evshw = ev->GetShower(it);
      if(evshw->IsCloneOf(fShower))found=true;
    }
    if(!found){
      vtxColor=fParent.GetEVD()->GetGhostColor();
      shwrStripColor=fParent.GetEVD()->GetGhostColor();
      fColor=fParent.GetEVD()->GetGhostColor();
    }
  }
  else  if(fParent.GetEVD()->GetCandSlice()){
    CandSliceHandle slc1 =  *(fParent.GetEVD()->GetCandSlice());
    CandSliceHandle slc2;
    if(fShower.GetCandSlice())slc2=*(fShower.GetCandSlice());
    if(slc1!=slc2 && !slc1.IsCloneOf(slc2)){
      vtxColor=fParent.GetEVD()->GetGhostColor();
      shwrStripColor=fParent.GetEVD()->GetGhostColor();
      fColor=fParent.GetEVD()->GetGhostColor();
    }
  }

    double cx,cy,dx,dy;
    int n = fShower.GetNDaughters();
    x = new float[n];
    y = new float[n];
    
    plane_number = new int[n];
    TList* shower = new TList;
    shower->SetOwner();
    double vx, vy;

    if (fParent.GetGraphicsView() == GraphicsView::kUZ) {
        vx = fShower.GetVtxZ();
        vy = fShower.GetVtxU();

        TMarker * Vx = new TMarker(vx,vy,29);
        Vx->SetMarkerSize(1);
        Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
        shower->Add(Vx); 
   }
    else if(fParent.GetGraphicsView() == GraphicsView::kVZ) 
      {                      // kV
        vx = fShower.GetVtxZ();
        vy = fShower.GetVtxV();
        TMarker * Vx = new TMarker(vx,vy,29);
        Vx->SetMarkerSize(1);
        Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
        shower->Add(Vx); 
    }
    else if(fParent.GetGraphicsView() == GraphicsView::kXY) 
      {                     
        npoints = this->GetCandShowerData(0,0,x,y,0,0,0,0,plane_number);
        vx =  0.70710678*(fShower.GetVtxU()-fShower.GetVtxV());
        vy =  0.70710678*(fShower.GetVtxU()+fShower.GetVtxV());
        TMarker * Vx = new TMarker(vx,vy,29);
        Vx->SetMarkerSize(1);
        Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
        shower->Add(Vx); 
    }
    else if(fParent.GetGraphicsView() == GraphicsView::kUV) 
      {                     
        npoints = this->GetCandShowerData(y,x,0,0,0,0,0,0,plane_number);
        vx = fShower.GetVtxV();
        vy = fShower.GetVtxU();
        TMarker * Vx = new TMarker(vx,vy,29);
        Vx->SetMarkerSize(1);
        Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
        shower->Add(Vx);
    }
 
    TIter titr(fShower.GetDaughterIterator());
    PlaneView::PlaneView_t view = fParent.GetPlaneView();
    GraphicsView::GraphicsView_t gview = fParent.GetGraphicsView();
    while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) 
      {
        if (csh->GetPlaneView() == view)
          {
            if(gview !=GraphicsView::kXY && gview !=GraphicsView::kUV)
              {                 
                TIter digitItr(csh->GetDaughterIterator());
                while (CandDigitHandle *cdh = dynamic_cast<CandDigitHandle*>(digitItr())) {
                  
                  UgliGeomHandle ugh(*cdh->GetVldContext());
                  UgliStripHandle ush;
                  
                  ush = ugh.GetStripHandle(cdh->GetPlexSEIdAltL().GetBestItem().GetSEId());
                  
                  if (!ush.IsValid()) return false;
                  
                  cx = ush.GlobalPos(0).Z();
                  cy = ush.GetTPos();
                  dx = 1.25*ush.GetHalfThickness();
                  dy = 1.25*ush.GetHalfWidth();
                  TEllipse* box = new TEllipse(cx,cy,dx,dy);
                  box->SetFillColor(shwrStripColor);
                  box->SetLineColor(shwrStripColor);
                  shower->Add(box);
                  
                }
              }
            else
              {

                for(int i=0;i<npoints;i++){
       
                  cx = x[i];
                  cy = y[i];
                  dx = 0.01;
                  dy = 0.01;
                  TEllipse* box = new TEllipse(cx,cy,dx,dy);
                  box->SetFillColor(shwrStripColor);
                  box->SetLineColor(shwrStripColor);
                  shower->Add(box);
                }
                
              }
          }
      }

    fImp = shower;

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

    return true;
}

bool GfxShower::BuildDiscreteImp(){
  double cx,cy,dx,dy;
  int      n = fShower.GetNDaughters();
  
  // using new [] here causes bizzare segv in unrelated parts of the
  // code, so lets get all FORTRAN about it.
  const int maxstrips = 10000;
  int strip[maxstrips], plane[maxstrips];
  float q[maxstrips];
  float x[maxstrips],y[maxstrips];
  int vtxColor=28;
  int shwrStripColor=46;
  fColor=vtxColor;
  if(fParent.GetEVD()->GetCandEvent()){
    Bool_t found=false;
    CandEventHandle * ev = fParent.GetEVD()->GetCandEvent();
    Int_t nShowers = ev->GetLastShower()+1;
    for (Int_t it=0;it<nShowers;it++){
      const CandShowerHandle * evshw = ev->GetShower(it);
      if(evshw->IsCloneOf(fShower))found=true;
    }
    if(!found){
      vtxColor=fParent.GetEVD()->GetGhostColor();
      shwrStripColor=fParent.GetEVD()->GetGhostColor();
      fColor=fParent.GetEVD()->GetGhostColor();
    }
  }
  else    if(fParent.GetEVD()->GetCandSlice()){
    CandSliceHandle slc1 =  *(fParent.GetEVD()->GetCandSlice());
    CandSliceHandle slc2;
    if(fShower.GetCandSlice())slc2=*(fShower.GetCandSlice());
    if(slc1!=slc2 && !slc1.IsCloneOf(slc2)){
      vtxColor=fParent.GetEVD()->GetGhostColor();
      shwrStripColor=fParent.GetEVD()->GetGhostColor();
      fColor=fParent.GetEVD()->GetGhostColor();
    }
  }

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

    int ind;

    if(fParent.GetGraphicsView() != GraphicsView::kXY && 
       fParent.GetGraphicsView() != GraphicsView::kUV)
      {
        n = this->GetCandShowerData(0,0,0,0,0,q,0,strip,plane);
        if (n > maxstrips) n = maxstrips;
        
        map<int,float> mean_strip, norm_strip;
        for (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 = fShower.GetVtxPlane();
        int vtx_ind = -1;
        
        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]);
          }
        }
        if(vtx_ind>-1 && vtx_ind<=ind){
          TMarker * Vx = new TMarker(x[vtx_ind],y[vtx_ind],29);
          Vx->SetMarkerSize(1);
          Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
          shower->Add(Vx);
        }       
      }

    else if(fParent.GetGraphicsView() == GraphicsView::kXY) 
      {                     
        ind = this->GetCandShowerData(0,0,x,y,0,0,0,0,plane);
        float vx =  0.70710678*(fShower.GetVtxU()-fShower.GetVtxV());
        float vy =  0.70710678*(fShower.GetVtxU()+fShower.GetVtxV());
        TMarker * Vx = new TMarker(vx,vy,29);
        Vx->SetMarkerSize(1);
        Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
        shower->Add(Vx);
    }
    else if(fParent.GetGraphicsView() == GraphicsView::kUV) 
      {                     
        ind = this->GetCandShowerData(y,x,0,0,0,0,0,0,plane);
        float vx = fShower.GetVtxV();
        float vy = fShower.GetVtxU();
        TMarker * Vx = new TMarker(vx,vy,29);
        Vx->SetMarkerSize(1);
        Vx->SetMarkerColor(vtxColor);
        TAttLine* att_line = dynamic_cast<TAttLine*>(Vx);
        if (att_line) att_line->SetLineWidth(1);
        shower->Add(Vx);

    }

 
    TIter titr(fShower.GetDaughterIterator());
    PlaneView::PlaneView_t view = fParent.GetPlaneView();
    GraphicsView::GraphicsView_t gview = fParent.GetGraphicsView();
    ind=0;
    while (CandStripHandle* csh = dynamic_cast<CandStripHandle*>(titr())) 
      {
        if (csh->GetPlaneView() == view)
          {
            if(gview !=GraphicsView::kXY && gview !=GraphicsView::kUV)
              { 
                
                TIter digitItr(csh->GetDaughterIterator());
                while (CandDigitHandle *cdh = dynamic_cast<CandDigitHandle*>(digitItr())) {
                  

                  cx = cdh->GetPlexSEIdAltL().GetBestItem().GetSEId().GetPlane();
                  cy = cdh->GetPlexSEIdAltL().GetBestItem().GetSEId().GetStrip();
                  dx = .5;
                  dy = .5;
                  TEllipse* box = new TEllipse(cx,cy,dx,dy);
                 
                  box->SetFillColor(2);
                  shower->Add(box);
                  
                }
              }
            else
              {

                for(int i=0;i<ind;i++){
       
                  cx = x[i];
                  cy = y[i];
                  dx = 0.5;
                  dy = 0.5;
                  TEllipse* box = new TEllipse(cx,cy,dx,dy);
                  box->SetFillColor(shwrStripColor);
                  shower->Add(box);
                }
                
              }
          }
      }


    fImp = shower;

    return true;
}

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

    fImp->Paint(option);
}
int GfxShower::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;
}

---