TridUVPage.cxx

Go to the documentation of this file.

// Root stuff:
#include <TStyle.h>
#include <TColor.h>
#include <TROOT.h>
#include <TGeoManager.h>
#include <TH1.h>

// Trid Stuff:
#include "TridUVPage.h"
#include "TridModelStrip.h"
#include "TridModelTrack.h"
#include "TridModelShower.h"
#include "TridGLFrame.h"
#include "TridFlatGLFrame.h"
#include "TridSketches.h"
#include "TridControl.h"
#include "TridModelMaker.h"

// Midad:
#include "Midad/Base/PageProxy.h"
#include "Midad/Gui/GuiBox.h"
#include "Midad/Gui/GuiCanvas.h"
#include "Midad/Gui/GuiMainWindow.h"
#include "Midad/Gui/GuiMenu.h"
#include "Midad/Base/Mint.h"
#include "Midad/Base/PageDisplay.h"
#include "Midad/Base/DigitText.h"

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

// Offline:
#include <DataUtil/GetCandidate.h>
#include <JobControl/JobC.h>
#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexStripEndId.h"
#include "Plex/PlexVetoShieldHack.h"
#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitHandle.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliStripHandle.h"


CVSID("$Id: TridUVPage.cxx,v 1.18 2007/07/09 21:56:17 tagg Exp $");

using namespace SigC;

// We don't use this here because we are just a base class.  But, any
// subclass should have a version like it.
static PageProxy<TridUVPage> gsTridPageProxy("TridUV");

const Float_t kSize_Plane = 0.06; // Approximate pitch in m
const Float_t kSize_Strip = 0.0205; // Approximate strip width in m
const Float_t kSize_SM_Gap = 1.5297;
const Float_t kSize_SM1_Start = 0;
const Float_t kSize_SM1_End = kSize_Plane * 248;
const Float_t kSize_SM2_Start = kSize_Plane * 248 + kSize_SM_Gap;
const Float_t kSize_SM2_End = kSize_Plane * 480 + kSize_SM_Gap;
const Float_t kSize_UV_Far = kSize_Strip * 192;
const Float_t kSize_Calor = 7.1522;

const Float_t kSize_UV_Caldet = kSize_Strip * 25;
const Float_t kSize_UV_Near = kSize_Strip * 192;

const Float_t kFarOffsetU = -4;
const Float_t kFarOffsetV =  4;

const Float_t kNearOffsetU = -2.65;
const Float_t kNearOffsetV =  2.65;


TridUVPage::TridUVPage()
  : TridPage(),
    fShowTracks(true),
    fShowShowerBlobs(true),
    fShowStrips(true),
    fBestDemuxOnly(true)
{
  // Default view mode.
  fViewModesSupported = kView2D | kView3D;
  fViewMode = kView2D;
  fWindowName = "TridUV"; // Must be the same as the proxy name.
}

TridUVPage::~TridUVPage()
{
  fModels.Clear();
  // This is now taken care of by the SigC::Ptr stuff.
  // if(fGLFrame) delete fGLFrame;
}

TObject* TridUVPage::Init(Mint* mint, PageDisplay* pd, GuiBox& box)
{ 
  TridPage::Init(mint,pd,box);

  // Add custom things for this view.
  fShowTracks.AddToMenu(fOptionsMenu,"Show Tracks");
  fShowTracks.Connect(slot_class(*this,&TridUVPage::ModifySketches));
  fShowShowerBlobs.AddToMenu(fOptionsMenu,"Show Showers");
  fShowShowerBlobs.Connect(slot_class(*this,&TridUVPage::ModifySketches));
  fShowStrips.AddToMenu(fOptionsMenu,"Show Strips");
  fShowStrips.Connect(slot_class(*this,&TridUVPage::ModifySketches));

  fBestDemuxOnly.AddToMenu(fOptionsMenu,"Best Demux Only");
  fBestDemuxOnly.Connect(slot_class(*(TridPage*)this,&TridPage::Update));


  MSG("TriD",Msg::kDebug) << "TridUVPage: Init()" << endl;
  
  return NULL;
}

TridGLFrame* TridUVPage::CreateNewGLFrame( TridPage::ViewMode_t mode )
{
  TridPOV min(0,   0, -4,   0,  0, -180);
  TridPOV max(30,  0, +4, 1000, 90, 180);
  
  if(mode==kView2D) {
    MSG("TriD",Msg::kDebug) << "Changing to 2D" << endl;
    return new TridFlatGLFrame(this,*fGuiBox,fTridControl,min,max,1.5);
  };

  MSG("TriD",Msg::kDebug) << "Changing to 3D" << endl;
  return new TridGLFrame(this,*fGuiBox,fTridControl,min,max);
}


void TridUVPage::CreateModels()
{
  fModels.Clear();
  fTridControl->ClearPicked();
  fTridControl->ClearSelected();

  TridModelMaker maker;
  maker.Prepare(&(fMint->GetJobC().Mom));
  maker.CreateStripModels(&(fMint->GetJobC().Mom),fModels);
  maker.CreateTrackModels(&(fMint->GetJobC().Mom),fModels);
  maker.CreateShowerModels(&(fMint->GetJobC().Mom),fModels);

}



void TridUVPage::CreateSketches()
{
  fModels.ClearAssociations();

  double meanplane = 0;
  double meann = 0;

  
  UgliGeomHandle ugli(fContext);
  
  Float_t offsetU = 0;
  Float_t offsetV = 0;

  
  switch(fContext.GetDetector()) {
  case Detector::kCalDet: 
    offsetU =  0.25;
    offsetV =  0.25;
    break;
  case Detector::kFar:
    offsetU =  kFarOffsetU;
    offsetV =  kFarOffsetV; 
    break;
  case Detector::kNear:
    offsetU = kNearOffsetU;
    offsetV = kNearOffsetV; 
    break;
  default: break;
  } 

  TridModel*   basemodel;
  TridModelItr itr = fModels.GetIterator();
  while( (basemodel = itr.Next()) ) {    
    // Make a new sketch for this model.
    
    // Track models.
    TridModelTrack* track = dynamic_cast<TridModelTrack*>(basemodel);    
    if(track) { 
      int first = track->GetFirstPlane();
      int last  = track->GetLastPlane();
      double lastu=0., lastv=0., lastz=0.;
 
      for(int plane = first; plane<=last; plane++) {
        if(track->IsValid(plane)) {
          UgliScintPlnHandle upln = ugli.GetScintPlnHandle(PlexPlaneId(fContext.GetDetector(),plane));  
          if(! upln.IsValid()) continue;
          double u = track->GetU(plane);
          double v = track->GetV(plane);
          double z = upln.GetZ0();
          
          if(plane!=first) {
            TridSketch* sk;
            // U view:
            sk = new TridSketchLine( TVector3(lastz, 0.1, offsetU + lastu),
                                     TVector3(z,     0.1, offsetU + u    ) );
            sk->SetColor(1,0,0);
            fGLFrame->AddSketch(sk);
            fModels.AssociateModel(track,sk->GetId());
                
            // V view:
            sk = new TridSketchLine( TVector3(lastz, 0.1, offsetV + lastv),
                                     TVector3(z,     0.1, offsetV + v    ) );
            sk->SetColor(1,0,0);
            fGLFrame->AddSketch(sk);
            fModels.AssociateModel(track,sk->GetId());
          }
          
          lastu=u;
          lastv=v;
          lastz=z;
        }      
      } 
      
    }

    // Shower models.
    TridModelShower* shower = dynamic_cast<TridModelShower*>(basemodel);    
    if(shower) {
      int first = shower->GetFirstPlane();
      int last  = shower->GetLastPlane();
      for(int plane = first; plane<= last; plane++) {
        if(shower->IsValid(plane)) {
          float u = shower->GetU(plane);
          float v = shower->GetV(plane);
          float width = shower->GetWidth(plane);
          PlexPlaneId planeid(fContext.GetDetector(),plane); //use steel to avoid ugli errors in ND spect
          float z = ugli.GetScintPlnHandle(planeid).GetZ0();    
          
          float y1, y2;
          if(planeid.GetPlaneView()==PlaneView::kU) {
            y1 = offsetU + u + width;
            y2 = offsetU + u - width;
          } else {
            y1 = offsetV + v + width;
            y2 = offsetV + v - width;
          }

          //cout << "Shower plane " << plane << "  " << y1 << " " << y2 << endl;
          
          TridSketch* sk = new TridSketchLine( TVector3(z, 0.1, y1),
                                               TVector3(z, 0.1, y2) );
          sk->SetColor(0,0,1);
          fGLFrame->AddSketch(sk);
          fModels.AssociateModel(shower,sk->GetId());
        }
      }
    }

    // Strip models.
    TridModelStrip* model = dynamic_cast<TridModelStrip*>(basemodel);    
    if(model) {      
      PlexStripEndId seid = model->fStrip;
      PlaneView::PlaneView_t view = seid.GetPlaneView();
      
      // Find offset pos.
      Float_t x,y,w,h;
      x = y = 0;
      
      UgliStripHandle ustrip = ugli.GetStripHandle(seid);
      
      x += ustrip.GlobalPos(0).z();
      if(view == PlaneView::kV)
        y = offsetV + ustrip.GetTPos();
      else
        y = offsetU + ustrip.GetTPos(); 

      if((fContext.GetDetector()==Detector::kFar) && (seid.GetPlane()>249)) // Put it in SM 2.
        x += kSize_SM_Gap;
      
      // NB half-widths.
      w = kSize_Plane*2;
      h = kSize_Strip*2;
      
      meanplane += x;
      meann += 1.0;
      
      TVector3 pos(x,0.1,y);
      
      TridSketch* sk;
      sk = new TridSketchEllipse( pos,
                                  w*kv_x,
                                  h*kv_z, 
                                  6
                                  );
        
      sk->SetTime(model->GetMeanTime());
      fGLFrame->AddSketch(sk);
      fModels.AssociateModel(model,sk->GetId());   
    }
  }

  ModifySketches(); // Set colors and transparencies.

  // Set up automatic and default viewing coordinates.
  double zloc = 15;
  if(meann>0) zloc = meanplane/meann;
  fAutoPOV.Set(zloc, 0, 0, 9, 90, 0 );  
  fFullPOV.Set(15,   0, 0, 21, 90, 0 );  

}


void TridUVPage::CreateScenery()
{
  TridSketch::StartScenery();
  TridSketch::SetDefaultColor(fTridControl->GetForegroundColor());

  
  // Put a black quad behind everything so mouse movement works better.
  TridSketch* backplane = new TridSketchPlane
    ( TVector3(0.0, -1.0, 0.0),
      kv_x, 100.,
      kv_z, 100. 
      );
  backplane->SetColor(fTridControl->GetBackgroundColor());
  fGLFrame->AddSketch(backplane);

  // Line between views
  TridSketch* sk = new TridSketchLine( TVector3(kSize_SM1_Start,0,0), TVector3(kSize_SM2_End,0,0));
  fGLFrame->AddSketch(sk);
  
  // Labels
  TridSketchText* txt;
  txt = new TridSketchText( TVector3(-0.8,0,2.0), kv_x, kv_y, "U View");
  txt->SetScale(0.5);
  fGLFrame->AddSketch(txt);

  txt = new TridSketchText( TVector3(-0.8,0,-2.0), kv_x, kv_y, "V View");
  txt->SetScale(0.5);
  fGLFrame->AddSketch(txt);

  if(fContext.GetDetector()==Detector::kFar) {
    // SM 1 box.
    sk = new TridSketchLine( TVector3(kSize_SM1_Start, 0, -8), TVector3(kSize_SM1_Start,0,  8) ); fGLFrame->AddSketch(sk);    
    sk = new TridSketchLine( TVector3(kSize_SM1_End,   0, -8), TVector3(kSize_SM1_End,  0,  8) );  fGLFrame->AddSketch(sk);    
    sk = new TridSketchLine( TVector3(kSize_SM1_Start, 0,  8), TVector3(kSize_SM1_End,  0,  8) );      fGLFrame->AddSketch(sk);
    sk = new TridSketchLine( TVector3(kSize_SM1_Start, 0, -8), TVector3(kSize_SM1_End,  0, -8) );     fGLFrame->AddSketch(sk);

    // SM 2 box.
    sk = new TridSketchLine( TVector3(kSize_SM2_Start, 0, -8), TVector3(kSize_SM2_Start, 0, 8) ); fGLFrame->AddSketch(sk);
    sk = new TridSketchLine( TVector3(kSize_SM2_End,   0, -8), TVector3(kSize_SM2_End,  0, 8) );  fGLFrame->AddSketch(sk);
    sk = new TridSketchLine( TVector3(kSize_SM2_Start, 0, 8),  TVector3(kSize_SM2_End, 0, 8) );      fGLFrame->AddSketch(sk);
    sk = new TridSketchLine( TVector3(kSize_SM2_Start, 0,-8),  TVector3(kSize_SM2_End, 0, -8) );     fGLFrame->AddSketch(sk);  
  }

  else if(fContext.GetDetector()==Detector::kNear) {
    // Line at left
    fGLFrame->AddSketch(new TridSketchLine( TVector3(0,0,0), TVector3(0,0, 3.95) ) );
    fGLFrame->AddSketch(new TridSketchLine( TVector3(0,0,0), TVector3(0,0,-3.95) ) );
    // Line at spectrometer
    const float kspect = 7.1512;
    fGLFrame->AddSketch(new TridSketchLine( TVector3(kspect,0,0), TVector3(kspect,0, 3.95) ) );
    fGLFrame->AddSketch(new TridSketchLine( TVector3(kspect,0,0), TVector3(kspect,0,-3.95) ) );  
    // Fully instrumented region U
    const float fullu1 = -0.27;
    const float fullu2 =  2.57;
    const float fullv1 =  0.24;
    const float fullv2 =  -2.57;

    fGLFrame->AddSketch(new TridSketchLine( TVector3(0,0,kNearOffsetU+fullu1), TVector3(kspect,0,kNearOffsetU+fullu1) ) );
    fGLFrame->AddSketch(new TridSketchLine( TVector3(0,0,kNearOffsetU+fullu2), TVector3(kspect,0,kNearOffsetU+fullu2) ) ); 
    fGLFrame->AddSketch(new TridSketchLine( TVector3(0,0,kNearOffsetV+fullv1), TVector3(kspect,0,kNearOffsetV+fullv1) ) );
    fGLFrame->AddSketch(new TridSketchLine( TVector3(0,0,kNearOffsetV+fullv2), TVector3(kspect,0,kNearOffsetV+fullv2) ) );      
  }

  TridSketch::StopScenery();
}

void TridUVPage::ModifySketches()
{
  // Go through all models. Modify they sketches to match the current
  // transparency and color maps.

  fColorHistogram->Reset();
  fTransHistogram->Reset();

  int nsketches =0;

  TridSketchListItr itr = fGLFrame->GetIterator();
  while( TridSketch* sketch = itr.Next() ) {
    int sketchnum = sketch->GetId();
    TridModel* model = fModels.GetModelFromSketch(sketchnum);

    if((sketch)&&(model)) {
      nsketches++;

      bool isToggled = false;

      // Get color and trans as number between 0 and 1,
      // interpolated in our current scale.
      Double_t color_x = fTridControl->GetRangedModelColor(model);
      Double_t trans_x = fTridControl->GetRangedModelTrans(model);

      // Modify the sketch.
      sketch->SetColor(fTridControl->GetColor(color_x));
      sketch->SetTransparency(trans_x);

      if(color_x>1)
        if(!fTridControl->ShowColorOverScale())
           sketch->SetDrawn(false);

      if(       dynamic_cast<TridModelStrip*>(model) )  {
        if(fShowStrips()) isToggled = true;
        // Fill our histograms.
        fColorHistogram->Fill(color_x);
        fTransHistogram->Fill(trans_x);      
      }
      else if(  dynamic_cast<TridModelTrack*>(model)  ) {
        if(fShowTracks()) isToggled = true;
        sketch->SetColor(1,0.3,0.3);
        sketch->SetTransparency(1.0);
      }
      else if( dynamic_cast<TridModelShower*>(model) )  {
        if(fShowShowerBlobs()) isToggled = true;
        sketch->SetColor(0.3,0.3,1);
        sketch->SetTransparency(0.5);
      }

      // Turn on/off the sketch.
      if(color_x<0)
        if(!fTridControl->ShowColorUnderScale())
          isToggled = false;
      sketch->SetDrawn(isToggled);

      // If picked, shine as white.
      if(fTridControl->IsPicked(model))
        sketch->SetColor(1,1,1);

      // Ditto selected.
      if(fTridControl->IsSelected(model))
        sketch->SetColor(1,1,1);


    } else {
      if(!(sketch->IsScenery())) {
        MSG("TriD",Msg::kError) << "Cannot find sketch or model "
                                << "  ModelAdd: "     << model 
                                << "  ModelKey: "     << ((model) ? (model->GetSortKey()) : 0)
                                << "  SketchNumber: " << sketchnum
                                << "  SketchAddr:   " << sketch << endl;
        if(sketch) sketch->Print();
        if(model) model->Print();
      }
    }
  }
}



void TridUVPage::ChangeSketches(void)
{
  // Update display.
  fGLFrame->DeleteSketches();
  CreateSketches();
  CreateScenery();
  fGLFrame->Update();

}

---