TridCratePage.cxx

Go to the documentation of this file.

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

#include "TridCratePage.h"
#include "TridFlatGLFrame.h"
#include "TridSketches.h"
#include "TridModelCrate.h"
#include "TridControl.h"
#include "TridModelMaker.h"

#include "Midad/Base/PageProxy.h"
#include "Midad/Gui/GuiBox.h"
#include "Midad/Gui/GuiCanvas.h"
#include "Midad/Gui/GuiMainWindow.h"
#include "Midad/Base/Mint.h"

#include <DataUtil/GetCandidate.h>
#include <JobControl/JobC.h>

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

#include "MessageService/MsgService.h"
#include "MinosObjectMap/MomNavigator.h"
#include "Plex/PlexHandle.h"
#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexStripEndId.h"
#include "Plex/PlexPixelSpotId.h"

#include "CandData/CandRecord.h"
#include "CandDigit/CandDigitListHandle.h"
#include "CandDigit/CandDigitHandle.h"
#include "RawData/RawChannelId.h"

using namespace SigC;

const double kSizeCrate_x = 2;
const double kSizeCrate_y = 2;

const double kSizeVarc_x  = 0.3;
const double kSizeVarc_y  = 1.8;
const double kSizeVmm_x   = kSizeVarc_x;
const double kSizeVmm_y   = kSizeVarc_y/6;
const double kSizeVfb_x   = kSizeVmm_x/2;
const double kSizeVfb_y   = kSizeVmm_y*0.9;

const double kSizeMaster_x = 0.1;
const double kSizeMaster_y = 1.8;
const double kSizeMinder_x = 0.09;
const double kSizeMinder_y = 0.2;

CVSID("$Id: TridCratePage.cxx,v 1.24 2006/04/20 00:37:39 tagg Exp $");

static PageProxy<TridCratePage> gsTridCratePageProxy("TridCrate");

TridCratePage::TridCratePage()
  :    TridPage()
{ 
  // Default view.
  fViewModesSupported = kView2D | kView3D;
  fViewMode = kView2D;
  fWindowName = "TridCrate";
  fFullPOV.Set(1.0, 0, 0, 9, 90, 0 );  
  fAutoPOV.Set(1.0, 0, 0, 9, 90, 0 );  
}

TridCratePage::~TridCratePage()
{ 
}

TObject* TridCratePage::Init(Mint* mint, PageDisplay* pageDisplay, GuiBox& box)
{
  MSG("TriD",Msg::kDebug) << "TridCratePage: Init()\n";
  return TridPage::Init(mint, pageDisplay, box);
}


TridGLFrame* TridCratePage::CreateNewGLFrame( TridPage::ViewMode_t mode )
{
  TridPOV min(0,             0,-kSizeCrate_y,   0, 0,-180);
  TridPOV max(kSizeCrate_x*8,0,+kSizeCrate_y,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 TridCratePage::ChannelToCoords(RawChannelId chan, 
                                 TVector3& pos, 
                                 double &width, 
                                 double &height )
{
  // 
  // Finds 2d coords of a channel in my map space.
  //
  int ix, iy;
  double x = 0;
  double y = 0;
  if(chan.GetElecType()==ElecType::kQIE) {
  
    // QIE

    // Offset into pixel
    x = kSizeMinder_x/2;
    y = kSizeMinder_y/2;

    //Which minder in master.
    x += PlaceInBox(kSizeMaster_x,kSizeMinder_x);
    y += PlaceInBox(kSizeMaster_y,kSizeMinder_y,chan.GetMasterChannel(),8);
    
    // Which master in crate
    x += PlaceInBox(kSizeCrate_x,kSizeMaster_x,chan.GetGeographicAddress()-9,12); // Masters in slots 9 to 20
    y += PlaceInBox(kSizeCrate_y,kSizeMaster_y);
    
    width = kSizeMinder_x;
    height = kSizeMinder_y;

  }  else if(chan.GetElecType()==ElecType::kVA) {  
      
    // VA electronics
    
    // Offset into pixel
    x=kSizeVfb_x/2.;
    y=kSizeVfb_y/2.;

    // Which Vfb in Vmm
    ix = chan.GetVaAdcSel();
    x += PlaceInBox(kSizeVmm_x,kSizeVfb_x,ix,2);
    y += PlaceInBox(kSizeVmm_y,kSizeVfb_y,0,1);
    
    // Which vmm in varc.
    iy = chan.GetVmm();
    x += PlaceInBox(kSizeVarc_x,kSizeVmm_x,0,1);
    y += PlaceInBox(kSizeVarc_y,kSizeVmm_y,iy,6);
    
    // Which varc in crate
    x+= PlaceInBox(kSizeCrate_x,kSizeVarc_x,chan.GetVarcId(),4);
    y+= PlaceInBox(kSizeCrate_y,kSizeVarc_y,0,1);

    width  = kSizeVfb_x;
    height = kSizeVfb_y;
  }
  
  // Which crate.
  if(fContext.GetDetector()==Detector::kFar) {
    ix = chan.GetCrate() / 2;
    iy = - chan.GetCrate() % 2;
  } else {
    iy = 0;
    ix = chan.GetCrate();
  }
  
  x+= (double)ix * kSizeCrate_x;
  y+= (double)iy * kSizeCrate_y;

  // put into xz plane instead of xy plane.
  pos.SetXYZ(x,0,y);
  return;
}

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

  TridModelMaker maker;
  maker.Prepare(&(fMint->GetJobC().Mom));
  maker.CreateChannelModels(&(fMint->GetJobC().Mom),fModels);

}


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

  TridModel* basemodel;
  TridModelItr itr = fModels.GetIterator();
  while( (basemodel = itr.Next()) ) {    
    // Make a new sketch for this model.
    TridModelCrate* model = dynamic_cast<TridModelCrate*>(basemodel);
    if(model==NULL){
      MSG("TriD",Msg::kError) << "CreateSketches() -> Unknown model type!" << endl;
      continue;
    }

    TVector3 pos;
    double w,h;
    ChannelToCoords(model->fChannel,pos,w,h);
    w *=0.9;
    h *=0.9;
    
    double depth = 0.2*model->GetOccupancy();
    pos.SetY(depth/2);
    
    TridSketch* sk = new TridSketchBox(pos,
                                       kv_x, w/2.,
                                       kv_z, h/2.,
                                       kv_y, depth/2.
                                       );
    sk->SetTime(model->GetEarliestTime());
    //float c = model->GetOccupancy() / 4;
    //sk->SetColor(GetColor(c));
    
    fGLFrame->AddSketch(sk);  
    fModels.AssociateModel(model,sk->GetId());    
  }

  // Add color and trans info.
  ModifySketches();
  
  if(fContext.GetDetector()==Detector::kCalDet) {
     fFullPOV.Set(1.0, 0, 0, 9, 90, 0 );  
     fAutoPOV.Set(1.0, 0, 0, 9, 90, 0 );  
  } else if(fContext.GetDetector()==Detector::kFar) {    
     fFullPOV.Set(8.0, 0, 0, 12, 90, 0 );
     fAutoPOV.Set(8.0, 0, 0, 12, 90, 0 );
  } else {
     fFullPOV.Set(4.0, 0, 0, 12, 90, 0 );
     fAutoPOV.Set(4.0, 0, 0, 12, 90, 0 );
  }
  
}

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

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


  // Create the scenery.
  TridSketch* l;
  TridSketch::SetDefaultColor(1,1,1);

  l = new TridSketchLine( TVector3(0,             0,0),
                          TVector3(8*kSizeCrate_x,0,0) );
  fGLFrame->AddSketch(l);
  
  l = new TridSketchLine( TVector3(0,             0,kSizeCrate_y),
                          TVector3(8*kSizeCrate_x,0,kSizeCrate_y) );
  fGLFrame->AddSketch(l);

  if(fContext.GetDetector()==Detector::kFar) {
    l = new TridSketchLine( TVector3(0,             0, -kSizeCrate_y),
                            TVector3(8*kSizeCrate_x,0, -kSizeCrate_y) );
    fGLFrame->AddSketch(l);
  }


  for(int i=0;i<9;i++) {
    TVector3 top(kSizeCrate_x * i, 0, kSizeCrate_y );
    TVector3 bottom(kSizeCrate_x * i, 0, 0 );
    if(fContext.GetDetector()==Detector::kFar)  bottom.SetXYZ(kSizeCrate_x * i, 0, -kSizeCrate_y );
    
    l = new TridSketchLine( bottom, top );
    l->SetColor(1,1,1);
    fGLFrame->AddSketch(l); 
  }

  for (int i =0; i<8;i++) {
    char buff[20];
    TridSketchText* txt;

    if(fContext.GetDetector()==Detector::kFar) 
      sprintf(buff,"Crate %d",i*2);
    else 
      sprintf(buff,"Crate %d",i);
      
    txt = new TridSketchText( TVector3( kSizeCrate_x * (i+0.5), 0, kSizeCrate_y *1.2 ),
                              -kv_z, kv_y,
                              buff);
    txt->SetScale(0.15);
    txt->SetThickness(0.001);
    fGLFrame->AddSketch(txt);

    if(fContext.GetDetector()==Detector::kFar) {
      sprintf(buff,"Crate %d",i*2 + 1);
      txt = new TridSketchText( TVector3( kSizeCrate_x * (i+0.5),  0, -kSizeCrate_y *1.2 ),
                                -kv_z, kv_y,
                                buff);
      txt->SetScale(0.15);
      txt->SetThickness(0.001);
      fGLFrame->AddSketch(txt);
    }
  }

  TridSketch::StopScenery();
}

---