TridPmtPage.cxx

Go to the documentation of this file.

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

#include "TridPmtPage.h"
#include "TridFlatGLFrame.h"
#include "TridSketches.h"
#include "TridModelPmt.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 "MessageService/MsgService.h"
#include <DataUtil/GetCandidate.h>
#include <JobControl/JobC.h>

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

#include "Plex/PlexSEIdAltL.h"
#include "Plex/PlexPixelSpotId.h"

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

const double kSizePmt_x = 0.5;
const double kSizePmt_y = 0.5;

const double kSizePixel16_x = kSizePmt_x/4.;
const double kSizePixel16_y = kSizePmt_y/4.;

const double kSizePixel64_x = kSizePmt_x/8.;
const double kSizePixel64_y = kSizePmt_y/8.;

const double kSizeMux_x = 1.75;
const double kSizeMux_y = 0.6;
const int    kBoxesPerRack = 8;
const double kSizeRack_x = 2.0;
const double kSizeRack_y = 5.0;
const int    kRacksPerLevel = 16;
const double kSizeLevel_y = 5.0;
const double kDistEW = kSizeLevel_y * 2; 

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

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

TridPmtPage::TridPmtPage()
  :    TridPage()
{    
  fViewModesSupported = kView2D | kView3D;
  fViewMode = kView2D;    // Default view.
  fWindowName = "TridPmt";
  fAutoPOV.Set(15.0, 0, 0, 10, 90, 0 );
  fFullPOV.Set(15.0, 0, 0, 10, 90, 0 );
}

TridPmtPage::~TridPmtPage()
{ 
}


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


TridGLFrame* TridPmtPage::CreateNewGLFrame( TridPage::ViewMode_t mode )
{
  TridPOV min(0,                         0,-kDistEW,   0, 0,-180);
  TridPOV max(kRacksPerLevel*kSizeRack_x,0, kDistEW,1000,90, 180);

  if(mode==kView2D) {
    MSG("TriD",Msg::kDebug) << "Changing to 2D" << endl;
    return new TridFlatGLFrame(this,*fGuiBox,fTridControl,min,max);
  };

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







TVector3 TridPmtPage::PmtToCoords(PlexPixelSpotId& spot,
                                    float& pmtsize )
{
  float x,y,w,h;
  TVector3 v;
  TVector3 span;

  if(fContext.GetDetector()==Detector::kFar){
    GetRackCoords_FD(spot.GetRackBay(),
                     spot.GetRackLevel(),
                     spot.GetEastWest(),
                     x,y,w,h);
    v.SetXYZ(x,0,y);
    span.SetXYZ(w,0,h);
    OffsetPmtIntoRack_FD(spot,span,v,pmtsize);
  }

  else if(fContext.GetDetector()==Detector::kCalDet) {

    GetRackCoords_FD(spot.GetRackBay(),
                     spot.GetRackLevel(),
                     spot.GetEastWest(),
                     x,y,w,h);
    v.SetXYZ(x,0,y);
    span.SetXYZ(w,0,h);
    OffsetPmtIntoRack_FD(spot,span,v,pmtsize);

  }

  else if(fContext.GetDetector()==Detector::kNear) {

    GetRackCoords_ND(spot.GetRackBay(),
                     spot.GetRackLevel(),
                     spot.GetEastWest(),
                     x,y,w,h);
    v.SetXYZ(x,0,y);
    span.SetXYZ(w,0,h);
    OffsetPmtIntoRack_ND(spot,span,v,pmtsize);

  }
  
  return v;
}


TVector3 TridPmtPage::PixelToCoords(PlexPixelSpotId& spot,
                                    float& pixelsize )
{
  float pmtsize = 0;
  TVector3 v = PmtToCoords(spot,pmtsize);
  OffsetPixelIntoPmt(spot,pmtsize,v,pixelsize);
  
  return v;
}


void TridPmtPage::GetRackCoords_FD(int rackbay, char racklvl, char ew, 
                                   float& xoff, float& yoff, float& w, float& h)
{
  const float kSizeRack_x = 2.0;
  const float kSizeRack_y = 5.0;
  const float kSizeLevel_y = 5.0;
  const float kDistEW = kSizeLevel_y * 2; 

  xoff=yoff=0;
  w = kSizeRack_x;
  h = kSizeRack_y;

  // Move to correct rack bay.
  xoff += kSizeRack_x * (rackbay);

  // Caldet hack.
  if(fContext.GetDetector()==Detector::kCalDet) {
    xoff +=  kSizeRack_x;
  }
  
  // Move to correct level.
  if(racklvl == 'U') 
    yoff += kSizeLevel_y; 

  // choose E or W
   if(ew=='E') 
    yoff += 0;
  else 
    yoff -= kDistEW;
}


void TridPmtPage::GetRackCoords_ND(int rackbay, char racklvl, char ew, 
                                   float& xoff, float& yoff, float& w, float& h)
{
  
  const float kSizeRack_x = 4.0;
  const float kSizeRack_y = 1.8;
  const float kSizeLevel_y = kSizeRack_y*2.2;
   
  xoff = yoff = 0;
  w = kSizeRack_x;
  h = kSizeRack_y;

  if(ew=='E') return;

  // Move to correct rack bay.
  xoff += kSizeRack_x * (rackbay/2);
  yoff += kSizeRack_y * ((rackbay+1)%2);

  // Move to correct level.
  if(racklvl == 'U') 
    yoff -= kSizeLevel_y; 
}


void TridPmtPage::OffsetPmtIntoRack_FD(PlexPixelSpotId& spot, 
                                       TVector3& rackSpan,
                                       TVector3& ioPos,
                                       float& pmtSize)
{
  float sizeMux_x = rackSpan.X()*0.9;
  float sizeMux_y = rackSpan.Z()/(8.2);
  
  float pmtSize_x = sizeMux_x/3.5;
  float pmtSize_y = sizeMux_y/1.2;
  pmtSize = (pmtSize_x>pmtSize_y)?pmtSize_y:pmtSize_x;
 
  float xoff = 0;
  float yoff = 0;

  // Offset into the mux box
  yoff += PlaceInBox(sizeMux_y,pmtSize,0,1);
  xoff += PlaceInBox(sizeMux_x,pmtSize,spot.GetTube(),3);
  
  // Move mux box to pos in rack.
  xoff += PlaceInBox(rackSpan.X(),sizeMux_x,0,1);
  yoff += PlaceInBox(rackSpan.Z(),sizeMux_y,(spot.GetInRack()),8);

  ioPos += TVector3(xoff,0,yoff);  
}

void TridPmtPage::OffsetPmtIntoRack_ND(PlexPixelSpotId& spot, 
                                       TVector3& rackSpan,
                                       TVector3& ioPos,
                                       float& pmtSize)
{
  float sizeAlner_x = rackSpan.X()*0.23;
  float sizeAlner_y = rackSpan.Z()*0.45;

  float pmtSize_x = sizeAlner_x;
  float pmtSize_y = sizeAlner_y;
  pmtSize = (pmtSize_x>pmtSize_y)?pmtSize_y:pmtSize_x;
    
  float xoff = 0;
  float yoff = 0;

  // Offset into the alner box (centers it)
  xoff += PlaceInBox(sizeAlner_x,pmtSize,0,1);
  yoff += PlaceInBox(sizeAlner_y,pmtSize,0,1);
  
  // Move mux box to pos in rack.
  xoff += PlaceInBox(rackSpan.X(),sizeAlner_x,(spot.GetInRack()%4),4);
  yoff += PlaceInBox(rackSpan.Z(),sizeAlner_y,(spot.GetInRack()/4),2);

  ioPos += TVector3(xoff,0,yoff);
}


void  TridPmtPage::OffsetPixelIntoPmt(PlexPixelSpotId& spot, float pmtSize, 
                                      TVector3& pos, float& pixelSize)
{
  float xoff = 0;
  float yoff = 0;
  if(spot.GetElecType()==ElecType::kVA) {
     pixelSize = pmtSize*0.25;
     
     // Find the pixel offset within the tube's space.
     int ix= (spot.GetPixel()-1) % 4;
     int iy = (spot.GetPixel()-1) / 4;

     xoff += float(ix)*pixelSize;
     yoff += float(iy)*pixelSize;     

  } else {
    pixelSize = pmtSize*0.125;

    // Find the pixel offset within the tube's space.
     int ix= (spot.GetPixel()-1) % 8;
     int iy = (spot.GetPixel()-1) / 8;

     xoff += float(ix)*pixelSize;
     yoff += float(iy)*pixelSize;     
  }
  
  // Move half a pixel to get to center.
  xoff += pixelSize*0.5;
  yoff += pixelSize*0.5;
  
  pos += TVector3(xoff,0,yoff);
}


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

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

  // Create the scenery.
  if(fContext.GetDetector()==Detector::kFar) 
  {
    const float kSizeRack_x = 2.0;
    const int   kRacksPerLevel = 16;
    const float kSizeLevel_y = 5.0;

    // Draw each rack.
    for(int iew = 0;iew<2;iew++) {
      char ew = iew?'W':'E';
      for(int ilvl = 0; ilvl <2; ilvl++) {
        char lvl = ilvl?'U':'L';
        float x,y,w,h;
        for(int bay = 1;bay<=16;bay++) {
          GetRackCoords_FD(bay,lvl,ew,x,y,w,h);

          TridSketch* l;
          l = new TridSketchLine( x,  0,y,   x+w, 0, y  ); fGLFrame->AddSketch(l);
          l = new TridSketchLine( x+w,0,y,   x+w, 0, y+h); fGLFrame->AddSketch(l);
          l = new TridSketchLine( x,  0,y+h, x+w, 0, y+h); fGLFrame->AddSketch(l);
          l = new TridSketchLine( x,  0,y+h, x,   0, y);   fGLFrame->AddSketch(l);
        }
      }
    }
    // Draw EW UD labels
    TridSketchText* txt;
    txt = new TridSketchText( TVector3(-1.2, 0, kSizeLevel_y),   kv_x, kv_y, "East Side");
    txt->SetScale(0.6);
    fGLFrame->AddSketch(txt);
    
    txt = new TridSketchText( TVector3(-1.2,0,-kSizeLevel_y),    kv_x, kv_y, "West Side");
    txt->SetScale(0.6);
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(-0.3,0,kSizeLevel_y*0.5), kv_x, kv_y, "Lower");
    txt->SetScale(0.5);
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(-0.3,0,kSizeLevel_y*1.5), kv_x, kv_y, "Upper");
    txt->SetScale(0.5);
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(-0.3,0,-kSizeLevel_y*1.5), kv_x, kv_y, "Lower");
    txt->SetScale(0.5);
    fGLFrame->AddSketch(txt);

    txt = new TridSketchText( TVector3(-0.3,0,-kSizeLevel_y*0.5), kv_x, kv_y, "Upper");
    txt->SetScale(0.5);
    fGLFrame->AddSketch(txt);

    // Draw Rackbay labels
    for(int i=1;i<=kRacksPerLevel;i++) {
      txt = new TridSketchText( TVector3(kSizeRack_x*((float)i-0.5), 0, kSizeLevel_y * 2.1),
                                -kv_z, kv_y, Form("Bay%d",i) );
      txt->SetScale(0.3);
      fGLFrame->AddSketch(txt);

      txt = new TridSketchText( TVector3(kSizeRack_x*((float)i-0.5), 0, -kSizeLevel_y * 2.1),
                                -kv_z, kv_y, Form("Bay%d",i) );
      txt->SetScale(0.3);
      fGLFrame->AddSketch(txt);
    }
  } else if(fContext.GetDetector()==Detector::kCalDet) {

    // Draw each rack.
    for(int iew = 0;iew<2;iew++) {
      char ew = iew?'W':'E';
      char lvl = 'U';
      float x,y,w,h;
      for(int bay = 1;bay<=16;bay++) {
        GetRackCoords_FD(bay,lvl,ew,x,y,w,h);
        TridSketch* l;
        l = new TridSketchLine( x,  0,y,   x+w, 0, y  ); fGLFrame->AddSketch(l);
        l = new TridSketchLine( x+w,0,y,   x+w, 0, y+h); fGLFrame->AddSketch(l);
        l = new TridSketchLine( x,  0,y+h, x+w, 0, y+h); fGLFrame->AddSketch(l);
        l = new TridSketchLine( x,  0,y+h, x,   0, y);   fGLFrame->AddSketch(l);
      }
    }
    

  } else if(fContext.GetDetector()==Detector::kNear) {
    
    
    // Draw each rack.
    char ew = 'W';
    for(int ilvl = 0; ilvl <2; ilvl++) {
      char lvl = ilvl?'U':'L';
      float x,y,w,h;
      for(int bay = 1;bay<=13;bay++) {
        GetRackCoords_ND(bay,lvl,ew,x,y,w,h);
        TridSketch* l;
        l = new TridSketchLine( x,  0,y,   x+w, 0, y  ); fGLFrame->AddSketch(l);
        l = new TridSketchLine( x+w,0,y,   x+w, 0, y+h); fGLFrame->AddSketch(l);
        l = new TridSketchLine( x,  0,y+h, x+w, 0, y+h); fGLFrame->AddSketch(l);
        l = new TridSketchLine( x,  0,y+h, x,   0, y);   fGLFrame->AddSketch(l);
        TVector3 botcenter(x+(w/2.), 0.0, y+h-(h/10.));
        TridSketchText* txt = 
          new TridSketchText(botcenter,-kv_z,kv_y,
                             Form("Rack %c%02d",lvl,bay));
        txt->SetTransparency(0.3);
        txt->SetThickness(0.001);
        txt->SetScale(h/6.);
        fGLFrame->AddSketch(txt);
      }
    }
  }

  TridSketch::StopScenery();
}
  

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

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


void TridPmtPage::CreateSketches()
{
  double meanx = 0;
  double meany = 0;
  double meanz = 0;
  double meann = 1e-9;

  TridModel* basemodel;
  TridModelItr itr = fModels.GetIterator();
  while( (basemodel = itr.Next()) ) {    
    // Make a new sketch for this model.
    TridModelPmt*   pmtModel = dynamic_cast<TridModelPmt*>(basemodel);
    TridModelPixel* pixelModel = dynamic_cast<TridModelPixel*>(basemodel);

    if(pmtModel) {
      // Draw the PMT.
      float pmtsize=0;
      TVector3 x1 = PmtToCoords(pmtModel->fPixelSpot, pmtsize);
      TVector3 pos = x1+TVector3(pmtsize*0.5,0,pmtsize*0.5);
      pos.SetY(-0.1);
      
      TridSketch* sk = new TridSketchPlane(pos, 
                                           kv_x, pmtsize*0.5,
                                           kv_z, pmtsize*0.5 );
      
      sk->SetTime(basemodel->GetEarliestTime());
      sk->SetColor(1,1,1);
      sk->SetTransparency(1);
      fModels.AssociateModel(basemodel,sk->GetId());   

      fGLFrame->AddSketch(sk);
    }

    if(pixelModel) {
      // Create drawing for an individual pixel.
      
      int pixel = pixelModel->fPixelSpot.GetPixel() +1;

      /*
       // The Pixel IDs are neurotic. Fix this up like Roy does 
      // it using the VA channel.
      if(pixelModel->fPixels==16) {
        // M16.
        static Int_t vach2pixel[18] = {0,0,15,1,16,2,11,5,12,6,7,9,8,10,3,14,4,13};
        
        Int_t vachan = pixelModel->GetDigit()->GetChannelId().GetVaChannel();
        if (vachan>=2 && vachan<=17) {
          pixel = vach2pixel[vachan];
        } 
      } else {
        // M64.
        pixel = pixelModel->fPixelSpot.GetPixel() +1;
      }
      */

      PlexPixelSpotId spot = pixelModel->fPixelSpot;
      spot.SetPixel(pixel);

      if(pixel>0) {
        TVector3 pos;
        float pixelsize=0;
        pos = PixelToCoords(spot,pixelsize);
        
        float sizex = 0.9 * pixelsize;     
        float sizez = 0.9 * pixelsize;
        
        // For fun, draw the height as number of PE.
        float sizey = 0.0001* pixelModel->GetTotalCharge(CalStripType::kNone);
        if(sizey<0) sizey=0;
        pos.SetY(sizey*0.5);
        
        TridSketch* sk = 
          new TridSketchBox( pos,
                             kv_x, sizex*0.5,
                             kv_y, sizey*0.5,
                             kv_z, sizez*0.5
                             );
        
        sk->SetTime(basemodel->GetEarliestTime());
        meanx += pos.x();
        meany += pos.y();
        meanz += pos.z();
        meann += 1;
        //float c = pixelModel->GetTotalCharge(CalDigitType::kPE)/20.;
        //sk->SetColor(GetColor(c));    
        //sk->SetTransparency(0.9);
        
        fModels.AssociateModel(basemodel,sk->GetId());  
        fGLFrame->AddSketch(sk);        
      }      
    }
  }

  ModifySketches();
  
  meanx = meanx/meann;
  meany = meany/meann;
  meanz = meanz/meann;
  fGLFrame->Update();
}


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

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

  TridModelItr itr = fModels.GetIterator();
  TridModel* model;
  while( (model = itr.Next()) ) {
    // Make a new sketch for this model.

    int sketchnum = fModels.GetSketchNumber(model);
    TridSketch* sketch = fGLFrame->FindSketch(sketchnum);
    
    // Special for PMT page: only use pixel models:
    if((sketch)&&(model)) {
     
      if(dynamic_cast<TridModelPixel*>(model)) {
        // 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);

        sketch->SetColor(fTridControl->GetColor(color_x));
        sketch->SetTransparency(trans_x);

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

        if(fTridControl->IsPicked(model)) {
          sketch->SetColor(1,1,1);
        }

        if(fTridControl->IsSelected(model)) {
          sketch->SetColor(1,1,1);
        }

        // Fill our histograms.
        fColorHistogram->Fill(color_x);
        fTransHistogram->Fill(trans_x);
      } else {

        // 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.   
        TVector3 color = (fTridControl->GetColor(color_x));
        color *=0.5;
        sketch->SetColor(color);
        sketch->SetTransparency(1.0);
        
        // Turn on/off the sketch.
        sketch->SetDrawn(true);
        if(color_x<0)
          if(!fTridControl->ShowColorUnderScale())
            sketch->SetDrawn(false);
        
        if(color_x>1)
          if(!fTridControl->ShowColorOverScale())
            sketch->SetDrawn(false);
        
        
        if(fTridControl->IsPicked(model)) {
          sketch->SetColor(1,0,0);
        }
        if(fTridControl->IsSelected(model)) {
          sketch->SetColor(0,1,0);
        }
      }
    } else {
      MSG("TriD",Msg::kError) << "Cannot find sketch or model, model number " << model
                              << "  ModelAdd: "     << model 
                              << "  SketchNumber: " << sketchnum
                              << "  SketchAddr:   " << sketch << endl;
    }
  }
}

---