PTGuiMainFrame.cxx

Go to the documentation of this file.

//
// PTGuiMainFrame
//
// This is the main frame of the GUI constructed by the PTGui class
// The PT GUI can be used to browse the detector media, materials,
// physics cuts and process flags, and to plot x-sec plots for applicable
// physics process types.
//
// This code is based on that of geant3_vmc/TGeant3/G3GuiGeomMain class:
//   * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
//   *                                                                        *
//   * Author: The ALICE Off-line Project.                                    *
//   * Contributors are mentioned in the code where appropriate.              *
//   Primary Author: Andreas Morsch
//
// but has been adapted for the MINOS PTSim simulation.  See the above
// noted G3GuiGeomMain class for a full copyright notice.
//
// Adapted for MINOS: S. Kasahara 8/2006
//

#include <iostream>
using namespace std;

#include <TMultiGraph.h>
#include <TClonesArray.h>
#include <TGTab.h>
#include <TGCanvas.h>
#include <TApplication.h>
#include <TGComboBox.h>
#include <TGTextEntry.h>
#include <TGTextBuffer.h>
#include <TGButton.h>
#include <TGLabel.h>
#include <TGListBox.h>
#include <TGraph.h>
#include <TCanvas.h>
#include <TGMenu.h>
#include <TGFileDialog.h>
#include <TFile.h>
#include <TGeoManager.h>
#include <TLegend.h>
#include <TH1F.h>

#include "MessageService/MsgService.h"
#include "G3PTSim/TGeant3/TGeant3.h"
#include "ParticleTransportSim/Gui/PTGui.h"
#include "ParticleTransportSim/Gui/PTGuiMainFrame.h"
#include "ParticleTransportSim/Gui/PTGuiMaterial.h"
#include "ParticleTransportSim/Gui/PTGuiMedium.h"
#include "ParticleTransportSim/Gui/PTGuiRollGMinos.h"
#include "ParticleTransportSim/Gui/PTGuiRollG3.h"

ClassImp(PTGuiMainFrame)

CVSID("$Id: PTGuiMainFrame.cxx,v 1.7 2007/08/28 23:37:37 schubert Exp $");

static const char *gOpenTypes[] = { "ROOT files",   "*.root",
                                    "All files",    "*",
                                    0,              0 };

// Definition of methods
// *********************

//__________________________________________________________________
PTGuiMainFrame::PTGuiMainFrame(const TGWindow* p, UInt_t w, UInt_t n) :
                   TGMainFrame(p,w,n), fL10KENbin(1000), fL10KEmin(-5.),
                   fL10KEmax(1.),fCurrentPTParticle(0),
                   fCurrentPTMechanism(0),fMediumFrame(0),fMediumCombo(0),
                   fMaterialFrame(0),fProcessFrame(0),fCutFrame(0),
                   fParticleCombo(0),fMechanismCombo(0),fPlotButton(0),
                   fMultiGraph(0),fPTGuiRollG3(0),fPTGuiRollGMinos(0) {
  // Normal constructor
  // A PTGuiMainFrame IsA TGMainFrame which is a top level window.

  // Initialization
  for ( Int_t igeo = 0; igeo < 2; igeo++ ) {
    fCurrentPTGuiMedium[igeo] = 0;
    fProcessLB[igeo] = 0;
    fCutLB[igeo] = 0;
    for ( int ie = 0; ie < 6; ie++ ) fMaterialTextE[ie][igeo] = 0;
    for ( int ie = 0; ie < 9; ie++ ) fMediumTextE[ie][igeo] = 0;
  }
  for ( Int_t ib = 0; ib < 3; ib++ ) fL10KETextB[ib] = 0;
  
  // Create a menuBar to lie along the top of the Gui
  // arguments: parent is this, size 1x1 pixel, horizontal layout
   TGMenuBar* menuBar = new TGMenuBar(this,1,1,kHorizontalFrame);
   // place in main frame in top left corner, expand in x to fit mainframe
   // leaving 0 or 1 pixel buffer on edges
   AddFrame(menuBar,
    new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 0, 0, 1, 1)); 
  
   // Add some menu file options to menubar
   TGPopupMenu* menuFile = new TGPopupMenu(gClient->GetRoot());
   menuFile -> AddEntry("&Open...",kFileOpen);
   menuFile -> AddEntry("&Close Browser",kFileCloseBrowser);
   menuFile -> AddEntry("&QuitRoot",kFileQuit);
   menuFile -> Associate(this);
   menuBar  -> AddPopup("File",menuFile,
               new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0));

  // Create tab widget.  A tab widget contains a set of composite
  // frames each with a little tab with a name (like a set of folders
  // with tabs)
   TGTab* tabmgr = new TGTab(this,400,400);
   AddFrame(tabmgr,
      new TGLayoutHints(kLHintsBottom | kLHintsExpandX | kLHintsExpandY,
                        2, 2, 5, 1));       

   // Now build the frames under the tabs
   BuildMediumFrame(tabmgr);
   BuildMaterialFrame(tabmgr);
   BuildProcessFrame(tabmgr);
   BuildCutFrame(tabmgr);
   BuildXSecFrame(tabmgr);
   
   // Set a name to the main frame
   SetWindowName("PT Browser");
   // Map all subwindows of main frame
   MapSubwindows();
   // We need to use GetDefault...() to initialize the layout algorithm...
   Resize(GetDefaultSize());
   // Map main frame
   MapWindow();

   // Fill entries
   fPTGuiRollG3 = new PTGuiRollG3();
   AddComboMedia();
   Update();

}

//__________________________________________________________________
PTGuiMainFrame::~PTGuiMainFrame() {
  // Delete anything that doesn't belong to main frame.
  // I'm a little fuzzy on window frame memory management issues, but
  // I believe that every object which has its ancestral root in
  // the parent window will be deleted when this window (main window)
  // is deleted
  
}

//__________________________________________________________________
void PTGuiMainFrame::Plot() {
  // Plot de/dx or cross-sections
  
  if ( fCurrentPTMechanism < 0 || fCurrentPTMechanism > PTGui::kNMechanism ) 
    return;
  if ( fCurrentPTParticle  < 0 || fCurrentPTParticle  > PTGui::kNParticle ) 
    return;

  // Material
  Int_t imate = fCurrentPTGuiMedium[0]->IdMat();
  if ( imate < 0 ) return;
  
  // Kinetic energy bins
  Float_t* L10tkin = new Float_t[fL10KENbin];
  Float_t* tkin = new Float_t[fL10KENbin];
  Float_t* value = new Float_t[fL10KENbin];
  Float_t* pcut = new Float_t[fL10KENbin];
  Float_t de = (fL10KEmax-fL10KEmin)/fL10KENbin;
  for ( UInt_t ie = 0; ie < fL10KENbin; ie++ ) {
    L10tkin[ie] = fL10KEmin + Float_t(ie)*de;
    tkin[ie] = pow((Float_t) 10.,L10tkin[ie]);
    value[ie] = 0.;
    pcut[ie] = 0.;
  }

  // Mechanism & particle type
  TGTextLBEntry* textE = dynamic_cast<TGTextLBEntry*>
        (fMechanismCombo->GetListBox()->GetEntry(fCurrentPTMechanism));
  std::string mechname = textE->GetText()->GetString();
  // Retrieve the mechanism number, this is a cheat 
  UInt_t imech = textE->GetUniqueID();
  std::string descname = PTGui::kDescMechanism[imech];
  
  Int_t ipart = fCurrentPTParticle + 1;
  std::string graphname = PTGui::kLabelParticle[ipart-1] + "             "
      + mechname + " (" + descname + ")             " 
      + std::string(fCurrentPTGuiMedium[0]->GetName());

  if ( fMultiGraph ) {
    // Clean up old multigraph, this also deletes any owned graphs
    delete fMultiGraph; fMultiGraph = 0;
  }
  
  TCanvas* c1 = new TCanvas("c1"," ",400,10,1000,700);
  TLegend* lgd = new TLegend(0.7,0.8,0.89,0.89);
  // Create a multigraph to display the set of graphs
  fMultiGraph = new TMultiGraph();
  fMultiGraph -> SetTitle(graphname.c_str());

  if ( mechname != "ALL XSEC" ) {
    Int_t ixst = 0; // return value
    char* mechch = const_cast<char*>(mechname.c_str());
    ((TGeant3*) gMC) -> Gftmat(imate,ipart,mechch,
                               (Int_t)fL10KENbin,tkin, value, pcut, ixst);
 
    if ( ixst ) {
      // name of the graph reflects content
    
      TGraph* graph = new TGraph(fL10KENbin,L10tkin,value);
    
      graph->SetFillColor(42);
      graph->SetMarkerColor(4);
      graph->SetMarkerStyle(21);
      graph->SetMarkerSize(0.4);
      fMultiGraph->Add(graph);
      lgd -> AddEntry(graph,"PTSim","PL");
      
      // If GMinos file is open, extract matching graph
      if ( fCurrentPTGuiMedium[1] ) {

        Int_t igminosmate = fCurrentPTGuiMedium[1]->IdMat();
        TGraph* gminosgraph 
               = fPTGuiRollGMinos->GetGraph(igminosmate,ipart,imech+1);
        if ( gminosgraph ) {
          gminosgraph->SetMarkerStyle(21);
          gminosgraph->SetMarkerSize(0.3);
          fMultiGraph -> Add(gminosgraph);
          lgd -> AddEntry(gminosgraph,"GMinos","PL");

        }
      }
      
      fMultiGraph->Draw("AP");
      lgd->Draw();
      fMultiGraph->GetHistogram()->GetXaxis()
           ->SetTitle("Log10(Kinetic Energy (GeV))");

      if ( mechname == "RANG" || mechname == "STEP") {
        fMultiGraph -> GetHistogram() -> SetYTitle("Distance (cm)");
      }
      else if ( mechname == "LOSS" ) {
        fMultiGraph -> GetHistogram() -> SetYTitle("dE/dX (MeV/cm)");
      }
      else {
        fMultiGraph -> GetHistogram() -> GetYaxis()
              -> SetTitle("Macroscopic X-Section (1/cm)");
      }
     
      Double_t minimum = pow(10,log10(graph->GetHistogram()->GetMaximum())-4.);
      minimum = TMath::Min(minimum,1.e-4);
      fMultiGraph -> GetHistogram() -> SetMinimum(minimum);
      fMultiGraph -> GetHistogram()->SetAxisRange(fL10KEmin,fL10KEmax,"X");
 
      if ( mechname != "LOSS" ) c1->SetLogy();
      c1->Update();
      c1->Modified();
      
    }
    
  }
  else {
    // Loop over all applicable x-secs, and plot on same plot, use log scale
    // not RANG,STEP,LOSS
    
    Int_t nent = fMechanismCombo->GetNumberOfEntries();

    TLegend* lgd = new TLegend(0.6,0.7,0.89,0.89);
    Int_t nmech = 0;
    for ( Int_t ient = 0; ient < nent; ient++ ) {
      TGTextLBEntry* combotextE = dynamic_cast<TGTextLBEntry*>
        (fMechanismCombo->GetListBox()->GetEntry(ient));
      std::string combomechname = combotextE->GetText()->GetString();
      UInt_t icombomech = combotextE -> GetUniqueID();
      std::string combodescname = PTGui::kDescMechanism[icombomech];
      if ( combomechname == "RANG" || combomechname == "STEP" || 
           combomechname == "LOSS" || combomechname == "ALL XSEC" ) continue;
      Int_t ipart = fCurrentPTParticle + 1;
      // Material
      Int_t imate = fCurrentPTGuiMedium[0]->IdMat();
      char* combomechch = const_cast<char*>(combomechname.c_str());
      Int_t ixst = 0;
      ((TGeant3*) gMC) -> Gftmat(imate,ipart,combomechch,
                               (Int_t)fL10KENbin,tkin, value, pcut, ixst);
      nmech++;
       // Create graph and overlay
      TGraph* combograph = new TGraph(fL10KENbin,L10tkin,value);
      combograph->SetFillColor(42);
      Int_t icolor = 1+nmech; // skip black
      if ( icolor >= 10 ) icolor++; // skip white
      combograph->SetMarkerColor(icolor); 
      combograph->SetLineColor(icolor);
      combograph->SetMarkerStyle(21);
      combograph->SetMarkerSize(0.4);
      fMultiGraph -> Add(combograph);
     
      // If GMinos file is open, extract matching graph
      if ( fCurrentPTGuiMedium[1] ) {
        Int_t igminosmate = fCurrentPTGuiMedium[1]->IdMat();
        TGraph* gminosgraph 
               = fPTGuiRollGMinos->GetGraph(igminosmate,ipart,icombomech+1);
        if ( gminosgraph ) {
          gminosgraph->SetMarkerStyle(21);
          gminosgraph->SetMarkerSize(0.3);
          fMultiGraph -> Add(gminosgraph);
        }
      }
      std::string combographname = combomechname + " (" + combodescname + ")";
      lgd -> AddEntry(combograph,combographname.c_str(),"PL");
    }
    fMultiGraph -> Draw("AP");
    lgd -> Draw();
    fMultiGraph -> GetHistogram()->GetYaxis()
                -> SetTitle("Macroscopic X-Section (1/cm)");
    fMultiGraph -> GetHistogram()->GetXaxis()
                -> SetTitle("Log10(Kinetic Energy (GeV))");
    Double_t minimum 
           = pow(10,log10(fMultiGraph->GetHistogram()->GetMaximum())-4.);
    minimum = TMath::Min(minimum,1.e-4);
    fMultiGraph -> GetHistogram()->SetMinimum(minimum);
    fMultiGraph -> GetHistogram()->SetAxisRange(fL10KEmin,fL10KEmax,"X");
    c1 -> Update();
    c1 -> Modified();
    c1 -> SetLogy();    
  }
  
  

  delete [] L10tkin;
  delete [] tkin;
  delete [] value;
  delete [] pcut;
    
}
  
//__________________________________________________________________
Bool_t PTGuiMainFrame::ProcessMessage(Long_t msg, Long_t parm1, Long_t parm2) {
  // Process messages received by widgets

  switch ( GET_MSG(msg) ) {

  case kC_TEXTENTRY:
    // Text entries for binning of cross-section plots
    switch ( GET_SUBMSG(msg) ) {
    case kTE_TEXTCHANGED:
      switch (parm1) {
      case kTextL10KENbin:
        fL10KENbin = (Int_t)atof(fL10KETextB[0]->GetString());
        break;
      case kTextL10KEmin:
        fL10KEmin = atof(fL10KETextB[1]->GetString());
        break;
      case kTextL10KEmax:
        fL10KEmax = atof(fL10KETextB[2]->GetString());
        break;
      }
    }
    break;
    
  case kC_COMMAND:
    switch ( GET_SUBMSG(msg) ) {
    case kCM_BUTTON:
      switch(parm1) {
      case 1: 
        Plot();
        break;

      default:
        break;
      } // parm1
      break;
   
    case kCM_COMBOBOX:
      switch(parm1) {

      case kComboMedium:
        // Medium combo
        fCurrentPTGuiMedium[0]=(PTGuiMedium*)
          (fPTGuiRollG3->GetMedia()->UncheckedAt(Int_t(parm2)));
        Update();
        break;

      case kComboParticle:
       // Particle combo
        fCurrentPTParticle = Int_t(parm2);
        UpdateMechanismCombo();
        break;

      case kComboMechanism:
       // Mechanism combo
        fCurrentPTMechanism = Int_t(parm2);
        break;
          
      default:
        break;
      
      } // parm1
      break;

    case kCM_MENU:
      switch(parm1) {

      case kFileOpen: 
        // Menu option File open
        OpenGMinosFile();
        break;

      case kFileCloseBrowser:
        // Menu option close browser
        CloseWindow();
        
        break;

      case kFileQuit:
        // Menu option quit root
        gApplication->Terminate(0);
        break;
          
      default:
        break;
      
      } // parm1
      break;

    default:
      break;

    } // GET_SUBMSG(msg)

  default:
    break;
    
  }  // GET_MSG(msg)
  
  return kTRUE;

}

//__________________________________________________________________
void PTGuiMainFrame::Update() {
  // Update Widgets

  if ( !fCurrentPTGuiMedium[0] ) {
    Int_t nmed = fPTGuiRollG3 -> GetMedia() -> GetEntriesFast();
    if ( nmed > 0 ) fCurrentPTGuiMedium[0] = dynamic_cast<PTGuiMedium*>
                      (fPTGuiRollG3 -> GetMedia() -> At(0));
  }
  if ( fPTGuiRollGMinos) fCurrentPTGuiMedium[1]=
        (fPTGuiRollGMinos->GetMedium(fCurrentPTGuiMedium[0]->GetName()));
  
  UpdateList();
  UpdateCombo();
  
}

//__________________________________________________________________
void PTGuiMainFrame::UpdateCombo() {
  // Update Combo Boxes

  UpdateMechanismCombo();
    
}

//__________________________________________________________________
void PTGuiMainFrame::UpdateList() {
  // Update List Boxes

  for ( int igeo = 0; igeo < 2; igeo++ ) {
    UpdateMediumList(igeo);
    UpdateMaterialList(igeo);
    UpdateProcessList(igeo);
    UpdateCutList(igeo);
  }
  
}

//__________________________________________________________________
void PTGuiMainFrame::OpenGMinosFile() {
  // Open gminos file

   // This code snipped stolen from TRootBrowser
   static TString dir(".");
   TGFileInfo fi;
   fi.fFileTypes = gOpenTypes;
   fi.fIniDir = StrDup(dir);
   new TGFileDialog(fClient->GetDefaultRoot(),this,kFDOpen,&fi);
   if (!fi.fFilename) return;
   dir = fi.fIniDir;
   if ( fPTGuiRollGMinos ) {
     // If already existing gminos file, close it and start fresh
     MSG("PTGui",Msg::kInfo) << "Closing existing gminos file " << endl;
     delete fPTGuiRollGMinos;  fPTGuiRollGMinos = 0;
   }
 
   TFile* file = new TFile(fi.fFilename,"update");
   if ( !(file -> IsOpen()) || (file -> IsZombie()) ) {
     MSG("PTGui",Msg::kWarning) << "Unable to open file "
                                << file->GetName() << endl;
     delete file; file = 0;
     return;
   }

   // Extract the gminos geometry from the file and initialize
   fPTGuiRollGMinos = new PTGuiRollGMinos(file);
   BuildMediumCombo(1);
   BuildMaterialList(1);
   BuildCutList(1);
   BuildProcessList(1);
   MapSubwindows();
   Resize(GetDefaultSize());
   MapWindow();
   
   Update();
   
}


//__________________________________________________________________
void PTGuiMainFrame::UpdateProcessList(Int_t igeo) {
  // Update Process List 

  if ( !fProcessLB[igeo] || !fCurrentPTGuiMedium[igeo] ) return;

  fProcessLB[igeo] -> RemoveEntries(0,PTGui::kNProcess-1); 
  for ( Int_t ip = 0; ip < PTGui::kNProcess; ip++ ) {
    Float_t pflag = fCurrentPTGuiMedium[igeo]->Process(ip); 
    char tmp[20];
    sprintf(tmp,"%6s%5d",(PTGui::kLabelProcess[ip]).c_str(),(Int_t)pflag);
    fProcessLB[igeo]->AddEntry(tmp,ip);
  }

  fProcessLB[igeo]->MapSubwindows();
  fProcessLB[igeo]->Layout();
    
}

//__________________________________________________________________
void PTGuiMainFrame::UpdateCutList(Int_t igeo) {
  // Update Cut List 

  if ( !fCutLB[igeo] || !fCurrentPTGuiMedium[igeo] ) return;

  fCutLB[igeo] -> RemoveEntries(0,PTGui::kNCut-1); 
  for ( Int_t ic = 0; ic < PTGui::kNCut; ic++ ) {
    Float_t cut = fCurrentPTGuiMedium[igeo]->Cut(ic); // pars 0-9 are cuts
    char tmp[20];
    sprintf(tmp,"%6s%10.3e",(PTGui::kLabelCut[ic]).c_str(),cut);
    fCutLB[igeo]->AddEntry(tmp,ic);
  }

  fCutLB[igeo]->MapSubwindows();
  fCutLB[igeo]->Layout();    
    
}

//__________________________________________________________________
void PTGuiMainFrame::UpdateMaterialList(Int_t igeo) {
  // Update Material List

    PTGuiMedium* med = fCurrentPTGuiMedium[igeo];
    if ( !med ) return;
    
    Int_t imat = med->IdMat();
    std::string matname = "<null>";
    Float_t a = -1;
    Float_t z = -1;
    Float_t dens = -1;
    Float_t radl = -1;
    Float_t absl = -1;
    if  ( imat >= 0 ) {
      PTGuiMaterial* ptmat = 0;
      if ( igeo == 0 ) ptmat = dynamic_cast<PTGuiMaterial*>
                   (fPTGuiRollG3->GetMaterials()->At(imat-1));
      else ptmat = dynamic_cast<PTGuiMaterial*>
                   (fPTGuiRollGMinos->GetMaterials()->At(imat-1));
    
      matname = ptmat->GetName();
      a = ptmat->A();
      z = ptmat->Z();    
      dens = ptmat->Density();
      radl = ptmat->RadLen();
      absl = ptmat->IntLen();
    }
     
    char buf[20];
     
    sprintf(buf, "%20s", matname.c_str());
    fMaterialTextE[0][igeo]->GetBuffer()->Clear();
    fMaterialTextE[0][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMaterialTextE[0][igeo]);

    sprintf(buf, "%20.3e", a);
    fMaterialTextE[1][igeo]->GetBuffer()->Clear();
    fMaterialTextE[1][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMaterialTextE[1][igeo]);

    sprintf(buf, "%20.3e", z);
    fMaterialTextE[2][igeo]->GetBuffer()->Clear();
    fMaterialTextE[2][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMaterialTextE[2][igeo]);

    sprintf(buf, "%20.3e", dens);
    fMaterialTextE[3][igeo]->GetBuffer()->Clear();
    fMaterialTextE[3][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMaterialTextE[3][igeo]);

    sprintf(buf, "%20.3e", radl);
    fMaterialTextE[4][igeo]->GetBuffer()->Clear();
    fMaterialTextE[4][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMaterialTextE[4][igeo]);

    sprintf(buf, "%20.3e", absl);
    fMaterialTextE[5][igeo]->GetBuffer()->Clear();
    fMaterialTextE[5][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMaterialTextE[5][igeo]);

  
}

//__________________________________________________________________
void PTGuiMainFrame::UpdateMediumList(Int_t igeo) {
  // Update Medium lists

    if ( !fCurrentPTGuiMedium[igeo] ) return;
  
    std::string medName = fCurrentPTGuiMedium[igeo]->GetName();
    Int_t     imed = fCurrentPTGuiMedium[igeo]->Id();
    Int_t    isvol = fCurrentPTGuiMedium[igeo]->Isvol();
    Int_t   ifield = fCurrentPTGuiMedium[igeo]->Ifield();
    Float_t fieldm = fCurrentPTGuiMedium[igeo]->Fieldm();    
    Float_t tmaxfd = fCurrentPTGuiMedium[igeo]->Tmaxfd();
    Float_t stemax = fCurrentPTGuiMedium[igeo]->Stemax();
    Float_t deemax = fCurrentPTGuiMedium[igeo]->Deemax();
    Float_t  epsil = fCurrentPTGuiMedium[igeo]->Epsil();
    Float_t  stmin = fCurrentPTGuiMedium[igeo]->Stmin();

    if ( igeo == 0 )fMediumCombo->Select(imed-1);
    char buf[20];
    
    int itxt = 0;
    sprintf(buf,"%20s",medName.c_str());
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0,buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);
    
    itxt++;
    sprintf(buf, "%20i", isvol);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20i", ifield);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20.3e", fieldm);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20.3e", tmaxfd);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20.3e", stemax);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20.3e", deemax);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20.3e", epsil);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

    itxt++;
    sprintf(buf, "%20.3e", stmin);
    fMediumTextE[itxt][igeo]->GetBuffer()->Clear();
    fMediumTextE[itxt][igeo]->GetBuffer()->AddText(0, buf);
    gClient->NeedRedraw(fMediumTextE[itxt][igeo]);

  
}


//__________________________________________________________________
void PTGuiMainFrame::UpdateMechanismCombo() {
  // Mechanism ComboBox entries are added if the mechanism is valid
  // for the current particle type.

  if ( !fCurrentPTGuiMedium[0] ) return;
  
  fMechanismCombo->RemoveAll();
  
  // Test each mechanism to check validity for the current particle type
  
  // Kinetic energy bins
  Float_t tkin[1] = {1.};
  Float_t value[1] = {0};
  Float_t pcut[1] = {0};

  Int_t nmech = 0;
  for ( Int_t imech = 0; imech < PTGui::kNMechanism-1; imech++ ) {
    Int_t ipart = fCurrentPTParticle + 1;

     // Material
    Int_t imate = fCurrentPTGuiMedium[0]->IdMat();
    std::string mechname = PTGui::kLabelMechanism[imech];
    char* mechstr = const_cast<char*>(mechname.c_str());

    Int_t ixst = 0;
    ((TGeant3*) gMC) -> Gftmat(imate,ipart,mechstr,1,tkin, value, pcut, ixst);
    
    if ( ixst > 0 ) {
      fMechanismCombo->AddEntry((PTGui::kLabelMechanism[imech]).c_str(),nmech);
      TGTextLBEntry* textE = dynamic_cast<TGTextLBEntry*>
        (fMechanismCombo->GetListBox()->GetEntry(nmech));
      textE->SetUniqueID(imech);
      nmech++;
    }
    
  }
  
  fCurrentPTMechanism = -1;
  if ( nmech > 0 ) {
    // Add the final entry for All X-sec
    fMechanismCombo->AddEntry(
             (PTGui::kLabelMechanism[PTGui::kNMechanism-1]).c_str(),nmech);
    TGTextLBEntry* textE = dynamic_cast<TGTextLBEntry*>
        (fMechanismCombo->GetListBox()->GetEntry(nmech));
    textE->SetUniqueID(PTGui::kNMechanism-1);
    fMechanismCombo->Select(0);
    fCurrentPTMechanism = 0;
  }
  

}

//__________________________________________________________________
void PTGuiMainFrame::AddComboMedia() {
  // Set the media combo entries

  TClonesArray* medArray = fPTGuiRollG3->GetMedia();
  Int_t nent = medArray->GetEntriesFast();
  
  for ( Int_t ient = 0; ient < nent; ient++ ) {
    PTGuiMedium* medium = dynamic_cast<PTGuiMedium*>(medArray->At(ient));
    fMediumCombo->AddEntry(medium->GetName(),ient);
    fMediumCombo->Select(ient);
    fMediumCombo->Resize(200,20);
  }
  
}

//__________________________________________________________________
void PTGuiMainFrame::BuildMaterialFrame(TGTab* tabmgr) {
  // Private method. Build frame associated with tab "Materials"

  TGCompositeFrame* tabF = tabmgr->AddTab("Material");

  // Add the main frame under this tab with a horizontal layout
  fMaterialFrame = new TGCompositeFrame(tabF,60,20,kHorizontalFrame);

  tabF -> AddFrame(fMaterialFrame,
            new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));

  BuildMaterialList();
  
}

//__________________________________________________________________
void PTGuiMainFrame::BuildMaterialList(Int_t igeo) {
  // Add a composite frame to the material frame containing the list of 
  // material parameters and their values

  TGCompositeFrame *vF 
             = new TGCompositeFrame(fMaterialFrame,60,20,kVerticalFrame);
  fMaterialFrame -> AddFrame(vF,
            new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));

  TGLayoutHints* textL1 = new TGLayoutHints(kLHintsTop | kLHintsExpandY,
                                             5, 5, 5, 5);
  TGLayoutHints* textL2 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX);
  
  const Int_t npar = 6; // material parameters
  std::string labelText[npar] = {
    "Material Name    ",
    "Atomic Weight    ",
    "Atomic Number    ",
    "Density          ",
    "Radiation Length ",
    "Absorption Length"
  };
  for ( Int_t ipar=0; ipar < npar; ipar++ ) {
    TGHorizontalFrame* textF
                     = new TGHorizontalFrame(vF,400,100,kFixedWidth);
    vF -> AddFrame(textF,textL1);
    fMaterialTextE[ipar][igeo] 
              = new TGTextEntry(textF,new TGTextBuffer(20),ipar);
    fMaterialTextE[ipar][igeo] -> Associate(this);
    textF->AddFrame(new TGLabel(textF,(labelText[ipar]).c_str()),
                        textL2);
    textF->AddFrame(fMaterialTextE[ipar][igeo],textL2);
  }
  
}

//__________________________________________________________________
void PTGuiMainFrame::BuildMediumFrame(TGTab* tabmgr) {
  // Private method. Build frame associated with tab "Media" and
  // add a combobox (drop down list) of media.

  TGCompositeFrame *tabF = tabmgr->AddTab("Media");

  // Add the main frame under this tab.  TGCompositeFrame is
  // the base class for composite widgets (menu bars, list boxes, etc).
  // It provides a layout manager and a frame container (TList*)
  // kHorizontalFrame creates a horizontal layout
  fMediumFrame = new TGCompositeFrame(tabF,60,20,kHorizontalFrame);

  tabF -> AddFrame(fMediumFrame,
                    new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));

  // Add a ComboBox (a drop down list box) for media to the tab main frame
  fMediumCombo = new TGComboBox(fMediumFrame,kComboMedium);
  fMediumFrame -> AddFrame(fMediumCombo,
                    new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));
  
  BuildMediumCombo();
  
}

//__________________________________________________________________
void PTGuiMainFrame::BuildMediumCombo(Int_t igeo) {
  // Add a composite frame to the medium frame containing a list of 
  // media parameters and their values
  
  // Add a composite frame to the main frame containing the list of material
  // parameters and their values
  TGCompositeFrame *vF 
             = new TGCompositeFrame(fMediumFrame,60,20,kVerticalFrame);
  fMediumFrame -> AddFrame(vF,
                    new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));

  TGLayoutHints* textL1 = new TGLayoutHints(kLHintsTop | kLHintsExpandY,
                                             5, 5, 5, 5);
  TGLayoutHints* textL2 = new TGLayoutHints(kLHintsLeft | kLHintsExpandX);
  
  const Int_t npar = 9; // medium parameters
  std::string labelText[npar] = {
    "Medium Name           ",
    "Sensitivity Flag      ",
    "Magnetic Field Flag   ",
    "Maximum Field         ",
    "Max. Ang. Deviation   ",
    "Maximum Step          ",
    "Max. Frac. Energy Loss",
    "Crossing Precision    ",
    "Minimum Step Size     "
  };

  for ( Int_t ipar=0; ipar < npar; ipar++ ) {
    TGHorizontalFrame* textF
                     = new TGHorizontalFrame(vF,400,100,kFixedWidth);
    vF -> AddFrame(textF,textL1);
    fMediumTextE[ipar][igeo] = new TGTextEntry(textF,new TGTextBuffer(20),ipar);
    fMediumTextE[ipar][igeo] -> Associate(this);
    textF->AddFrame(new TGLabel(textF,(labelText[ipar]).c_str()),
                        textL2);
    textF->AddFrame(fMediumTextE[ipar][igeo],textL2);
  }

  fMediumCombo -> Resize(200,20);
  fMediumCombo -> Associate(this);
  

}

//__________________________________________________________________
void PTGuiMainFrame::BuildProcessFrame(TGTab* tabmgr) {
  // Private method. Build frame associated with tab "Processes"

  TGCompositeFrame *tabF = tabmgr->AddTab("Processes");

  // Add the main frame under this tab.  TGCompositeFrame is
  // the base class for composite widgets (menu bars, list boxes, etc).
  // It provides a layout manager and a frame container (TList*)
  // kHorizontalFrame creates a horizontal layout
  fProcessFrame = new TGCompositeFrame(tabF,60,20,kHorizontalFrame);

  TGLayoutHints *mainL=new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
  tabF -> AddFrame(fProcessFrame,mainL);
  
  BuildProcessList();
  
}

//__________________________________________________________________
void PTGuiMainFrame::BuildProcessList(Int_t igeo) {
  // Add a ListBox for process flags to the tab main frame

  fProcessLB[igeo] = new TGListBox(fProcessFrame,1);
  fProcessFrame -> AddFrame(fProcessLB[igeo],
                    new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));

  fProcessLB[igeo] -> Resize(150,350);
  fProcessLB[igeo] -> Associate(this);

}

//__________________________________________________________________
void PTGuiMainFrame::BuildCutFrame(TGTab* tabmgr) {
  // Private method. Build frame associated with tab "Cuts"

  TGCompositeFrame *tabF = tabmgr->AddTab("Cuts");

  // Add the main frame under this tab.  
  fCutFrame = new TGCompositeFrame(tabF,60,20,kHorizontalFrame);

  TGLayoutHints *mainL=new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
  tabF -> AddFrame(fCutFrame,mainL);
  
  BuildCutList();
  
}

//__________________________________________________________________
void PTGuiMainFrame::BuildCutList(Int_t igeo) {

  // Add a ListBox for Cut values to the tab main frame
  fCutLB[igeo] = new TGListBox(fCutFrame,1);
  fCutFrame -> AddFrame(fCutLB[igeo],
                     new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5));

  fCutLB[igeo] -> Resize(150,350);
  fCutLB[igeo] -> Associate(this);

}

//__________________________________________________________________
void PTGuiMainFrame::BuildXSecFrame(TGTab* tabmgr) {
  // Private method. Build frame associated with tab "dE/dX and X-Sections"

  TGCompositeFrame *tabF = tabmgr->AddTab("dE/dX and X-Sections");

  // Add the main frame under this tab.  
  TGCompositeFrame* mainF = new TGCompositeFrame(tabF,60,20,kHorizontalFrame);
  TGLayoutHints *mainL=new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);
  tabF -> AddFrame(mainF,mainL);


  // Create a frame within the main frame to store the particle combo box
  TGCompositeFrame* partF = new TGCompositeFrame(mainF,60,20,kVerticalFrame);
  mainF -> AddFrame(partF,mainL);

  // Add a ComboBox (a drop down list box) for particle type to the mech frame
  fParticleCombo = new TGComboBox(partF,kComboParticle);
  partF -> AddFrame(fParticleCombo,mainL);
  for ( Int_t ipart = 0; ipart < PTGui::kNParticle; ipart++ ) {
    fParticleCombo->AddEntry((PTGui::kLabelParticle[ipart]).c_str(),ipart);
  }

  fParticleCombo->Select(0);
  fParticleCombo->Resize(100,20);
  fParticleCombo->Associate(this);
  fCurrentPTParticle = 0;
  
  // Create a frame within the main frame to store the mechanism combo box
  TGCompositeFrame* mechF = new TGCompositeFrame(mainF,60,20,kVerticalFrame);
  mainF -> AddFrame(mechF,mainL);
  
  // Add a ComboBox (a drop down list box) for mechanism type to the mech frame
  fMechanismCombo = new TGComboBox(mechF,kComboMechanism);
  mechF -> AddFrame(fMechanismCombo,mainL);
  //UpdateMechanismCombo();
  //  
  for ( Int_t imech = 0; imech < PTGui::kNMechanism; imech++ ) {
    fMechanismCombo->AddEntry((PTGui::kLabelMechanism[imech]).c_str(),imech);
  }

  fMechanismCombo->Select(0);
  fMechanismCombo->Resize(100,20);
  fMechanismCombo->Associate(this);

  // Add to the particle frame some text boxes to store energy range
  fL10KETextB[0] = new TGTextBuffer(10);
  TGTextEntry* keTextE0=new TGTextEntry(partF,fL10KETextB[0],
                                        kTextL10KENbin);
  fL10KETextB[0] -> AddText(0,"1000");
  keTextE0 -> Associate(this);

  fL10KETextB[1] = new TGTextBuffer(10);
  TGTextEntry* keTextE1=new TGTextEntry(partF,fL10KETextB[1],
                                        kTextL10KEmin);
  fL10KETextB[1] -> AddText(0,"-5");
  keTextE1 -> Associate(this);

  fL10KETextB[2] = new TGTextBuffer(10);
  TGTextEntry* keTextE=new TGTextEntry(partF,fL10KETextB[2],
                                       kTextL10KEmax);
  fL10KETextB[2] -> AddText(0,"1");
  keTextE -> Associate(this);
  
  TGLabel* keLabel 
       = new TGLabel(partF,"Nbins,L10(KEmin),L10(KEmax) (GeV)");
  TGLayoutHints* keL = new TGLayoutHints(kLHintsLeft | kLHintsExpandX);
  partF->AddFrame(keLabel,keL);
  partF->AddFrame(keTextE0,keL);
  partF->AddFrame(keTextE1,keL);
  partF->AddFrame(keTextE,keL);

  // Plot Button
  TGCompositeFrame* plotF = new TGCompositeFrame(mainF,60,20,kHorizontalFrame);
  mainF -> AddFrame(plotF,mainL);
  fPlotButton = new TGTextButton(plotF,"Plot",1);
  fPlotButton -> Associate(this);
  plotF -> AddFrame(fPlotButton);
  
}

//__________________________________________________________________
void PTGuiMainFrame::CloseWindow() {
   // Got close message for this MainFrame. Calls parent CloseWindow()
   // (which destroys the window).
   // The close message is generated by the window manager when its close
   // window menu item is selected.

   TGMainFrame::CloseWindow();

}

---