STEER/TFndGeometry.cxx

// @(#)fROOT/STEER:$Name:  $:$Id: TFndGeometry.cxx,v 1.28 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/07/05

//                                                                                //
//                             TFndGeometry                                       //
//                                                                                //
//                                                                                //
//  This class provides a completre support for the FINUDA spectrometer geometry  //
//
//  If you want to import the geometry from the FORTRAN Montecarlo code:
//   1: (within the fidarc/mc environment)
//     # $SCI/fidamc
//      (select workstation type = 1)
//     # rz/file 21 fin_spec.geom on
//     # exit
//     # mv fin_spec.geom <path to root-geometry file>/.
//
//   2: (within the froot environment)
//     # cd <path to root-geometry file>
//     # g2root fin_spec.geom fin_spec_geom.C
//
//   3: (within a root-shell)
//       root [0] gROOT->ProcessLine(".x fin_spec_geom.C");
//       root [1] TFile *f = new TFile(filename,"RECREATE");
//       root [2] gGeoManager->Write();
//       root [3] f->Close();
//       root [4] delete f;
//   Step "2" and step "3" are automatically performed by the
//    "TFndGeometry::ConvertFromGeant3()" method
//
//   see the "ImportGeometry.C" macro
//   last imported geometry: fidamc-603 (Sept 05, 2007)
//                                                                                //

#include "Riostream.h"

#include "TSystem.h"
#include "TRandom.h"
#include "TGeoTube.h"

#include "TFile.h"
#include "TThread.h"
#include <TView3D.h>

#include "TFndDB.h"
#include "TFndGeometry.h"

TFndGeometry *gFndGeom;

ClassImp(TFndGeometry)

//_______________________________________
TFndGeometry::TFndGeometry():
  fVerboseLevel(),fSetup(),
  fPromptNode(),fPromptVolume(),fCurDetNode(),fTgtNodes(),
  fMainCanvas()
{
  gFndGeom = this;
  
}

//_______________________________________
TFndGeometry::~TFndGeometry(){

  delete fMainCanvas;
  gFndGeom = 0;
}

//_______________________________________
Double_t TFndGeometry::GetTofinoRotAngles(Int_t slab){
  
  if(slab < 0 || slab > K_N_TOFINO_SLABS){
    gROOT->Error("TFndGeometry::GetTofinoRotAngles","Slab out of range (%d)",slab);
    return 0;
  }
  
  Double_t res = (Double_t)(slab-1) * GetTofinoSlabAngle();
  res +=  GetTofinoSlabAngle() / 2;
  return res;
}

//_______________________________________
Double_t TFndGeometry::GetTofoneRotAngles(Int_t slab){

  if(slab < 0 || slab > K_N_TOFONE_SLABS){
    gROOT->Error("TFndGeometry::GetTofoneRotAngles","Slab out of range (%d)",slab);
    return 0;
  }
  
  Double_t res = (Double_t)(slab-1) * GetTofoneSlabAngle();
  // The first TOFONE slab crosses x-axis (different from TOFINO!!!)
  return res;
}

//_______________________________________
Int_t TFndGeometry::ConvertFromGeant3(TString root_geom_filename, TString geant3_geom_path,Bool_t CleanTmp){
  // if you use the default parameters you get the "fin_spec.geom" file from $PWD
  // and save a ROOT-geometry-file (gGeoManager) in $PWD
  // The temporary fin_spec_geom.C file is deleted if CleanTmp is set to kTRUE (default)
  //
  // the "fin_spec.geom" can be generated within the GEANT3 prompt in this way:
  //     # rz/file 21 fin_spec.geom on
  //     # exit
  //
  // return value:
  //              0: ok
  //             -1: error
  
  TString TempFileName = root_geom_filename;
  Int_t dot_id = TempFileName.Index(".");
  if(dot_id == -1){
    gROOT->Warning("ConvertFromGeant3","no \".\" found into the geom_filename: not converting");
    return -1;
  }
  TempFileName.Resize(dot_id);
  TempFileName+=".C";
  
  TString cmd_conv;
  cmd_conv.Form("%s %s %s","g2root",geant3_geom_path.Data(),TempFileName.Data());

  Printf(" ---> sending command \"%s\"",cmd_conv.Data());
  gSystem->Exec(cmd_conv.Data());
  Printf("TFndGeometry::ConvertFromGeant3 ---> Root GEOMETRY macro created.");

  TString cmd_x = ".x ";
  cmd_x += TempFileName;
  Printf("sending root-command \"%s\"",cmd_x.Data());
  gROOT->ProcessLine(cmd_x.Data());

  TFile f(root_geom_filename,"RECREATE");
  gGeoManager->SetName("TheFinudaGeometry");
  gGeoManager->Write();
  f.Close();

  if(CleanTmp){
    TString cmd_rm = "rm -i "; cmd_rm += TempFileName;
    gSystem->Exec(cmd_rm.Data());
  }
  return 0;
}

//_______________________________________
Int_t TFndGeometry::LoadGeometry(TString filename){
  // return value:
  //               0: ok
  //              -1: File not found
  //              -2: Can not get the gGeoManager pointer
  
  if(gSystem->AccessPathName(ExpandPathName(filename))){
    Warning("LoadGeometry","File \"%s\"not found",filename.Data());  
    return -1;
  }

  //  TString man_name = filename;
  //  Int_t dot_id = man_name.Index(".");
  //   if(dot_id == -1){
  //     gROOT->Warning("LoadGeometry","no \".\" found into the \"%s\"file: not converting",filename.Data());
  //     return -2;
  //   }
  //  man_name.Resize(dot_id);
  
  TFile f(filename,"OPEN");
  if(fVerboseLevel>1) f.ls();
  if(fVerboseLevel>0) Printf("Geometry manager new address: %x",f.Get("TheFinudaGeometry"));
  //  new TGeoManager();
  if(gGeoManager) delete gGeoManager;
  gGeoManager = (TGeoManager *)(f.Get("TheFinudaGeometry"));

  if(!gGeoManager){
    Warning("LoadGeometry","No geometry loaded");  
    return -2;
  }
  f.Close();
  // 
  Init();


  return 0;
}

//_______________________________________
void TFndGeometry::Init(){
  // called after loading geometry from file
  // the setup is selected looking at the targets
  // target nodes are also loaded

  fPromptNode = gGeoManager->GetNode(0);
  fPromptVolume = fPromptNode->GetVolume();

  // find setup and set target nodes
  if(fPromptVolume->FindNode("TAR1_1")){
    fSetup = (Int_t) FGEO_2003;    
    fTgtNodes[0] = fPromptVolume->FindNode("TAR1_1");
    fTgtNodes[1] = fPromptVolume->FindNode("LIM2_1");
    fTgtNodes[2] = fPromptVolume->FindNode("LIM3_1");
    fTgtNodes[3] = fPromptVolume->FindNode("LIM4_1");
    fTgtNodes[4] = fPromptVolume->FindNode("TAR5_1");
    fTgtNodes[5] = fPromptVolume->FindNode("TAR6_1");
    fTgtNodes[6] = fPromptVolume->FindNode("TAR7_1");
    fTgtNodes[7] = fPromptVolume->FindNode("TAR8_1");
  }
  else if(fPromptVolume->FindNode("LIM1_1")){
    fSetup = (Int_t) FGEO_2006;
    fTgtNodes[0] = fPromptVolume->FindNode("LIM1_1");
    fTgtNodes[1] = fPromptVolume->FindNode("TAR2_1");
    fTgtNodes[2] = fPromptVolume->FindNode("LIM3_1");
    fTgtNodes[3] = fPromptVolume->FindNode("LIM4_1");
    fTgtNodes[4] = fPromptVolume->FindNode("LIM5_1"); // DEG5 for 2006 only (degrader)
    fTgtNodes[5] = fPromptVolume->FindNode("LIM6_1");
    fTgtNodes[6] = fPromptVolume->FindNode("TAR7_1");
    fTgtNodes[7] = fPromptVolume->FindNode("LIM8_1");    
  }
  else{
    Error("Init","Can not identify current setup!");
    gApplication->Terminate();
  }
  if(fVerboseLevel>0) Info("Init","Loaded setup is \"%s\" (id: %d)",GetCurrentSetup().Data(),fSetup);
  // following line could be used for debugging purposes (useful here)
  //  PrintStructure(6); 
  LoadGeoMatrices();
  if(fVerboseLevel>0)  Info("Init","All matrices succesfully loaded");
}

//_______________________________________
void TFndGeometry::LoadGeoMatrices(){
  // TGeoHMatrix is used in order to combine every roto-translation

  Int_t channel; // used by all detectors (standard DB numbering)

  for(Int_t lay=1;lay<=2;lay++){
    for(Int_t sl=1;sl<=K_N_TOFONE_SLABS;sl++){
      if(lay ==1 && sl>K_N_TOFINO_SLABS){ 
        fGeoMatr_Top_Tof[lay-1][sl-1] = 0;
        continue;
      }
      channel = TFndDB::Tof_ChannelToDBNumbering(lay,sl);
      SelectDetectorNode(FIN_TOF,channel);
      if(fVerboseLevel>1)  Printf("LoadGeoMatrices ===> node TOF: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
      //       fGeoMatr_Top_Tof[lay-1][sl-1] = fCurDetNode->GetMatrix();
      fGeoMatr_Top_Tof[lay-1][sl-1] = new TGeoHMatrix();
      Double_t trasl_tof[3] = { 0. , 0. , 0. };
      TGeoTube *tgtub = (TGeoTube *) ( fCurDetNode->GetDaughter(0)->GetVolume()->GetShape() );
      trasl_tof[0] =  tgtub->GetRmin();
      trasl_tof[0] += ( (tgtub->GetRmax() - tgtub->GetRmin()) / 2 );
      //      Printf("===========> ch %d ; rad: %f",channel,trasl_tof[0] );
      fGeoMatr_Top_Tof[lay-1][sl-1]->SetTranslation(trasl_tof);
      // add traslation from center of FINUDA to center of slabs
      fGeoMatr_Top_Tof[lay-1][sl-1]->RotateZ( (lay==1) ? GetTofinoRotAngles(sl) : GetTofoneRotAngles(sl) );
    }
  }
  //   fGeoMatr_Top_Sil[2][10]
  
  for(Int_t lay=1;lay<=2;lay++){
    for(Int_t mod=1;mod<=K_N_Sil_Modules;mod++){
      if(lay==1){ // case of ISIM
        if(mod>8) continue;
        SelectDetectorNode(FIN_ISM,mod);
      }
      else SelectDetectorNode(FIN_OSM,mod);
      //
      fGeoMatr_Top_Sil[lay-1][mod-1] = fCurDetNode->GetMatrix();
    }
  }
  

  for(Int_t lay=1;lay<=K_N_LMD_LAYERS;lay++){  // layer values: 1,2
    for(Int_t ch=1;ch<=K_N_LMD_CHAMS_PER_LAYER;ch++){ // ch values: 1,2,3,4,5,6,7,8
      for(Int_t wire=0;wire<=K_N_LMD_OUTER_WIRES;wire++){ // wire 0: chamber node ; wire [1;max]: wire node
        if(lay==1 && wire > K_N_LMD_INNER_WIRES) continue;
        
        channel = TFndDB::Lmd_ChannelToDBNumbering(lay,ch,wire);
        SelectDetectorNode(FIN_LMD,channel);
        
        if(wire==0){ // external node
          if(fVerboseLevel>1) Printf("LoadGeoMatrices ===> external node LMD: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
          fGeoMatr_Top_Lmd[lay-1][ch-1] = fCurDetNode->GetMatrix();
          continue;
        }
        // ---
        if(fVerboseLevel>1) Printf("LoadGeoMatrices ---> LMD: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
        if(lay ==1) fGeoMatr_InnerLmd_Wire [ch-1][wire-1] = fCurDetNode->GetMatrix();
        else if(lay ==2) fGeoMatr_OuterLmd_Wire [ch-1][wire-1] = fCurDetNode->GetMatrix();
        else{ Error("LoadGeoMatrices","layer out of range (%d)",lay); gApplication->Terminate(); }
      }
    }
  }
  // Combine LMD roto-translations
  for(Int_t l_id=0;l_id<K_N_LMD_LAYERS;l_id++){  // indices
    for(Int_t ch_id=0;ch_id<K_N_LMD_CHAMS_PER_LAYER;ch_id++){ // ch_id values: 0,1,2,3,4,5,6,7
      for(Int_t wire_id=0;wire_id<K_N_LMD_OUTER_WIRES;wire_id++){ // wire_id [0;max-1]
        if(l_id==0 && wire_id >= K_N_LMD_INNER_WIRES) continue;
        if(l_id ==0){
          fGeoMatr_Top_InnerLmdWire[ch_id][wire_id] = new TGeoHMatrix(*fGeoMatr_Top_Lmd[l_id][ch_id]);
          fGeoMatr_Top_InnerLmdWire[ch_id][wire_id]->Multiply(fGeoMatr_InnerLmd_Wire[ch_id][wire_id]);
        }
        else if(l_id==1){
          fGeoMatr_Top_OuterLmdWire[ch_id][wire_id] = new TGeoHMatrix(*fGeoMatr_Top_Lmd[l_id][ch_id]);
          fGeoMatr_Top_OuterLmdWire[ch_id][wire_id]->Multiply(fGeoMatr_OuterLmd_Wire[ch_id][wire_id]);
        }
        else{
          Error("LoadGeoMatrices","layer ID out of range (%d)",l_id); gApplication->Terminate(); 
        }
      } 
    }
  }
  // ---
  for(Int_t crown=1;crown<=K_N_STB_CROWNS;crown++){  // crown values: 1-6
    for(Int_t tube=0;tube<=K_N_STB_TUBES;tube++){ // tube 0: main node ; tube [1-404]: tube node
      channel = TFndDB::Stb_ChannelToDBNumbering(crown,tube);
      SelectDetectorNode(FIN_STB,channel);
      if(tube == 0){
        if(fVerboseLevel>1) printf("LoadGeoMatrices ===> STB (outer volume): \"%d\": \"%s\"\n",channel,fCurDetNode->GetName());
        continue; // no need to load container matrix: it is an identity
      }
      if(fVerboseLevel>1) printf("LoadGeoMatrices ---> STB: channel \"%d\": \"%s\"\n",channel,fCurDetNode->GetName());
      fGeoMatr_Top_StbWire[crown-1][tube-1] = fCurDetNode->GetMatrix();; // MRF->Wire.RF
    }
  }  
}

//____________________________________
Double_t TFndGeometry::SilPositionStrip(const Int_t &side, const Double_t &barcha) {
  //
  // Convert the strip number, which is fractional due to center of
  // mass calculation, into the position in the local frame [cm]
  //
  // Strip pitch for p+ and n+ side
  const Double_t pitchp = 0.0025;
  const Double_t pitchn = 0.0050; 
  //
  // MicroStrip Geometrical constants
  //
  const Double_t pgeo[18]={0.0000,0.0740,6.3920,0.0740,
                           0.0000,0.0740,6.3920,0.0740,
                           0.0000,0.0740,6.3920,0.0740,
                           0.0000,
                           0.0000,0.0800,5.1000,0.0800,0.0000};
  const Double_t qgeo[18]={0.0000,0.0750,6.3900,0.0750,
                           0.0000,0.0750,6.3900,0.0750,
                           0.0000,0.0750,6.3900,0.0750,
                           0.0000,
                           0.0000,0.1462,4.9676,0.1462,0.0000};
  // Number of p+ side strips
  const Double_t nstrp=2041.0;
  const Double_t maxchp=1021.0;
  // Number of n+ side strips         
  const Double_t nstrn=3837.0;          
  const Double_t maxchn=1920.0;
  //
  Double_t idncha = floor(barcha);
  Double_t difcha = barcha - idncha;
  Double_t idnstr = 0.;
  Double_t pitch  = 0.;
  Double_t helle  = 0.;
  Double_t dely0  = 0.;
  Double_t numstr = 0.;
  Double_t nfrac  = 0.;
  Double_t nikstr = 0.;
  Double_t strpos = 0.;
  if (side == 0) {
    //
    //  p+ side
    //
    idnstr = 2*idncha-1;          
    pitch  = pitchp;
    helle  = 0.5*(pgeo[14]+pgeo[15]+pgeo[16]);
    dely0  = pgeo[16];         
    numstr = nstrp;
    strpos = pitch*(idnstr-1)-helle+dely0;
  } else {
    //
    //  n+ side
    //
    if (idncha <= maxchn/3.) {
      nfrac = 1.;
    } else if (idncha <= maxchn/3.*2.) {
      nfrac = 2.;
    } else {
      nfrac = 3.;
    }
    idnstr = 2*idncha-nfrac;        
    numstr = nstrn/3;
    pitch  = pitchn;
    if (idnstr > numstr*2) {
      //
      //      Lateral detector with positive Z-coordinate
      //
      nikstr = 2.;
      helle  = 0.5*(qgeo[1]+qgeo[2]+qgeo[3]);
      dely0  = qgeo[3];        
      strpos = pitch*(idnstr-nikstr*numstr-1.)+dely0+(0.5*qgeo[6]+qgeo[5]+qgeo[4]);
    } else if (idnstr <= numstr) {
      //
      //      Lateral detector with negative Z-coordinate
      //
      nikstr = 0.;
      helle  = 0.5*(qgeo[9]+qgeo[10]+qgeo[11]);
      dely0  = qgeo[11];       
      strpos = pitch*(idnstr-nikstr*numstr-1)+dely0-(0.5*qgeo[6]+qgeo[7]+qgeo[8])-2.*helle;
    } else {
      //
      //      Central detector
      //
      nikstr = 1.;
      helle  = 0.5*(qgeo[5]+qgeo[6]+qgeo[7]);
      dely0  = qgeo[7];        
      strpos = pitch*(idnstr-nikstr*numstr-1)-helle+dely0;
    }
  }
  strpos += difcha*2.0*pitch;
  return strpos;
}

//_______________________________________
void TFndGeometry::RefSys_TofSlabToMRS(const Int_t &channel,const Double_t* local, Double_t* master) {

  Int_t lay = -1;
  Int_t sla = -1;
  TFndDB::Tof_ChNum_To_DetChan(channel,lay,sla);

  if(
     (channel > K_N_TOFINO_SLABS && channel <= 100) ||
     (channel > 172 && channel <= 300) ||
     (channel > 312)
     ) {
    Error("RefSys_TofSlabToMRS","Wrong channel number (%d)",channel);
    for(Int_t i=0;i<3;i++) master[i] = 0.;
    return;
  }
  
  //  cout << "channel: " << channel << "; lay: " << lay << "; sla: " << sla << endl; 
  fGeoMatr_Top_Tof[lay-1][sla-1]->LocalToMaster(local,master);

}

//_______________________________________
void TFndGeometry::RefSys_SilModToMRS(const Int_t &layer,const Int_t &module,const Double_t* local, Double_t* master){
  
  fGeoMatr_Top_Sil[layer-1][module-1]->LocalToMaster(local,master);
}

//_______________________________________
void TFndGeometry::RefSys_LmdWireToMRS(const Int_t &channel,const Double_t* local, Double_t* master) {

  Int_t lay = -1;
  Int_t dch = -1;
  Int_t wire = -1;
  Int_t wire_node = -1; // not used but needed to call the following method
  TFndDB::Lmd_ChNum_To_DetChan(channel,lay,dch,wire,wire_node);

  if(lay ==1) fGeoMatr_Top_InnerLmdWire[dch-1][wire-1]->LocalToMaster(local,master); 
  else if(lay ==2) fGeoMatr_Top_OuterLmdWire[dch-1][wire-1]->LocalToMaster(local,master);
  else{
    Error("RefSys_LmdWireToMRS","layer value out of range (%d)",lay); gApplication->Terminate(); 
  } 
}

//_______________________________________
void TFndGeometry::RefSys_StbWireToMRS(const Int_t &channel,const Double_t* local, Double_t* master) {

  Int_t crown = -1;
  Int_t tube = -1;
  Int_t wire_node = -1; // not used but needed to call the following method
  TFndDB::Stb_ChNum_To_DetChan(channel,crown,tube,wire_node);
  fGeoMatr_Top_StbWire[crown-1][tube-1]->LocalToMaster(local,master);
}

//_______________________________________
void TFndGeometry::PrintGeoMatrices(Int_t det,Int_t verbose_lev){
  // print matrices on standard output
  // the verbose level is local
  
  Int_t channel; // used by all detectors (standard DB numbering)

  switch(det){
  case (Int_t) FIN_GTS:
    // no geometry for GTS
    break;
  case (Int_t) FIN_TOF:  
    for(Int_t lay=1;lay<=2;lay++){
      for(Int_t sl=1;sl<=K_N_TOFONE_SLABS;sl++){
        if(lay ==1 && sl>K_N_TOFINO_SLABS) continue;
        channel = TFndDB::Tof_ChannelToDBNumbering(lay,sl);
        SelectDetectorNode(FIN_TOF,channel);
        Printf("PrintGeoMatrices ===> node TOF: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
        fGeoMatr_Top_Tof[lay-1][sl-1]->Print();
      }
    }
    break;
  case (Int_t) FIN_ISM:
    for(Int_t mod=1;mod<=8;mod++){
      SelectDetectorNode(FIN_ISM,mod);
      Printf("PrintGeoMatrices ===> node ISIM: module \"%d\": \"%s\"",mod,fCurDetNode->GetName());
      fGeoMatr_Top_Sil[0][mod-1]->Print();
    }
    break;
  case (Int_t) FIN_OSM:
    for(Int_t mod=1;mod<=K_N_Sil_Modules;mod++){
      SelectDetectorNode(FIN_OSM,mod);
      Printf("PrintGeoMatrices ===> node OSIM: module \"%d\": \"%s\"",mod,fCurDetNode->GetName());
      fGeoMatr_Top_Sil[1][mod-1]->Print();
    }
    break;
  case (Int_t) FIN_LMD:
    for(Int_t lay=1;lay<=K_N_LMD_LAYERS;lay++){  // layer values: 1,2
      for(Int_t ch=1;ch<=K_N_LMD_CHAMS_PER_LAYER;ch++){ // ch values: 1,2,3,4,5,6,7,8
        for(Int_t wire=0;wire<=K_N_LMD_OUTER_WIRES;wire++){ // wire 0: chamber node ; wire [1;max]: wire node
          if(lay==1 && wire > K_N_LMD_INNER_WIRES) continue;

          channel = TFndDB::Lmd_ChannelToDBNumbering(lay,ch,wire);
          SelectDetectorNode(det,channel);
          if(wire==0){ // external node
            Printf("PrintGeoMatrices ===> external node LMD: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
            fGeoMatr_Top_Lmd[lay-1][ch-1]->Print();
            continue;
          }
          Printf("PrintGeoMatrices -> LMD: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
          if(lay ==1) fGeoMatr_InnerLmd_Wire [ch-1][wire-1]->Print();
          else if(lay==2) fGeoMatr_OuterLmd_Wire [ch-1][wire-1]->Print();
          else{ Error("PrintGeoMatrices","layer out of range (%d)",lay); gApplication->Terminate(); }
        }
      }
    }
    break;
  case (Int_t) FIN_STB:
    for(Int_t crown=1;crown<=K_N_STB_CROWNS;crown++){  // crown values: 1-6
      for(Int_t tube=0;tube<=K_N_STB_TUBES;tube++){ // tube 0: main node ; tube [1-404]: tube node
        channel = TFndDB::Stb_ChannelToDBNumbering(crown,tube);
        SelectDetectorNode(FIN_STB,channel);
        if(tube == 0){
          Printf("PrintGeoMatrices ===> STB (outer volume): \"%d\": \"%s\"",channel,fCurDetNode->GetName());
          continue;
        }
        Printf("PrintGeoMatrices ---> STB: channel \"%d\": \"%s\"",channel,fCurDetNode->GetName());
        fGeoMatr_Top_StbWire[crown-1][tube-1]->Print();
      }
    }  
    break;
  default:
    Warning("PrintGeoMatrices","detector id \"%d\" not available",det);
    return;
  }

}

//_______________________________________
Int_t TFndGeometry::ShowGeometry(Option_t *option,Int_t vis_level){
  // return value:
  //              0: ok
  //             -1: error

  if(!fPromptNode){
    Warning("ShowGeometry","No geometry available");
    return -1;
  }

  delete fMainCanvas;
  fMainCanvas = new TCanvas("FinGeomCanvas","FINUDA Geometry",100,100,400,400);
  fMainCanvas->SetFillColor(0);
  gGeoManager->SetVisLevel(vis_level);
  SetDefaultColors();
  SetDefaultVisibility();

  gGeoManager->GetTopVolume()->Draw(option);
  //  TView *view = new TView(1); // up to root-version 5.13
  TView3D *view = new TView3D();
  Double_t k=150.;
  view->SetRange( -k, -k, -k, k, k, k);
  Int_t iret;
  view->SetView(5, 5, 0, iret);
  view->SetViewChanged();
  fMainCanvas->SetView(view);  
  fMainCanvas->Modified();
  fMainCanvas->Update();

  return 0;
}

//_______________________________________
Int_t TFndGeometry::PrintNode(TGeoNode *node,Int_t id_subnum,const Int_t level){
  // returns the number of daughters

  if(!node){
    Warning("PrintNode","node not defined!");
    return 0;
  }

  TString sp_str = "";
  sp_str.Resize(level * 5);

  Printf("%s      -> Sub-Node number %d: \"%s\" (level %d)",sp_str.Data(),id_subnum,node->GetName(),level);
  Int_t ndau = node->GetNdaughters();
  if(!ndau) return 0;

  Printf("%s         Number of daughters: %d",sp_str.Data(),ndau);
  return ndau;

}

//_______________________________________
void TFndGeometry::PrintStructure(const Int_t levels){
  // a maximum of 7 levels (default) is allowed
  // direct daughters of the fPromptNode belong to level "0"
  //
  // NOTE: level 6 should be the deepest one
  //       according to the current geometry (Aug 2006)

  if(!gGeoManager){
    Warning("PrintStructure","No geometry loaded");  
    return;
  }
  

  Int_t Nmany      = gGeoManager->GetNmany();
  Int_t Nsegments  = gGeoManager->GetNsegments();
  Int_t NAlignable = gGeoManager->GetNAlignable();
  Int_t Ntracks    = gGeoManager->GetNtracks();
  Int_t NNodes     = gGeoManager->GetNNodes();
  

  Printf("");
  Printf(" --------- the FINUDA SPECTROMETER geometry structure: ---------");
  Printf(" -> Top volume: \"%s\"",gGeoManager->GetTopVolume()->GetName());
  Printf("    Number of many =======> %d",Nmany);
  Printf("    Number of segments ===> %d",Nsegments);
  Printf("    Number of Alignable ==> %d",NAlignable);
  Printf("    Number of tracks =====> %d",Ntracks);
  Printf("    Number of nodes ======> %d",NNodes);
  Printf("    --- --- --- ---");

  // from this line on everything will be referred to the prompt node
  // in order to browse the hyerarchical structure of the geometry
  Printf(" --------- Inspecting the geometry structure: ---------");

  Int_t NDaughters = fPromptNode->GetNdaughters();
  
  Printf(" -> Prompt node: \"%s\"",fPromptNode->GetName());
  Printf("    Number of daughters ======> %d",NDaughters);
  
  // ---
  TGeoNode *daughts[levels];
  Int_t ndau[levels];
  Int_t next_dau_num[levels];   
  for(Int_t i=0;i<levels;i++){
    daughts[i] = 0;
    ndau[i] = 0;
    next_dau_num[i] = 0;
  }
  // ---
  for(ndau[0]=0;ndau[0]<NDaughters;ndau[0]++){ // level 0
    daughts[0] = fPromptNode->GetDaughter(ndau[0]);
    next_dau_num[0] = PrintNode(daughts[0],ndau[0],0);
    if(levels <1) continue;
    for(ndau[1]=0;ndau[1]<next_dau_num[0];ndau[1]++){ // level 1
      daughts[1] =  daughts[0]->GetDaughter(ndau[1]);
      next_dau_num[1] = PrintNode(daughts[1],ndau[1],1);
      if(levels <2) continue;
      for(ndau[2]=0;ndau[2]<next_dau_num[1];ndau[2]++){ // level 2
        daughts[2] =  daughts[1]->GetDaughter(ndau[2]);
        next_dau_num[2] = PrintNode(daughts[2],ndau[2],2);
        if(levels <3) continue;
        for(ndau[3]=0;ndau[3]<next_dau_num[2];ndau[3]++){ // level 3
          daughts[3] =  daughts[2]->GetDaughter(ndau[3]);
          next_dau_num[3] = PrintNode(daughts[3],ndau[3],3);
          if(levels <4) continue;
          for(ndau[4]=0;ndau[4]<next_dau_num[3];ndau[4]++){ // level 4
            daughts[4] =  daughts[3]->GetDaughter(ndau[4]);
            next_dau_num[4] = PrintNode(daughts[4],ndau[4],4);
            if(levels <5) continue;
            for(ndau[5]=0;ndau[5]<next_dau_num[4];ndau[5]++){ // level 5
              daughts[5] =  daughts[4]->GetDaughter(ndau[5]);
              next_dau_num[5] = PrintNode(daughts[5],ndau[5],5);
              if(levels <6) continue;
              for(ndau[6]=0;ndau[6]<next_dau_num[5];ndau[6]++){ // level 6
                daughts[6] =  daughts[5]->GetDaughter(ndau[6]);
                next_dau_num[6] = PrintNode(daughts[6],ndau[6],6);
                if(levels <7) continue;
                for(ndau[7]=0;ndau[7]<next_dau_num[6];ndau[7]++){ // level 7
                  daughts[7] =  daughts[6]->GetDaughter(ndau[7]);
                  next_dau_num[7] = PrintNode(daughts[7],ndau[7],7);
                }    
              }    
            }    
          }    
        }    
      } 
    }
  }
  // ---  
}

//_______________________________________
TGeoNode *TFndGeometry::SelectDetectorNode(const Int_t &det, const Int_t &ch){
  // the current node is set and then returned:
  // do not delete the returned node
  //
  // if you need to get the index of the selected node use:
  //   gGeoManager->GetTopVolume()->GetIndex(fCurDetNode) 
  //
  // TO BE FIXED FOR SIL

  if(det == (Int_t) FIN_GTS){
    Warning("SelectDetectorNode","No geometry has been provided for GTS",det);
    return 0;
  }

  fCurDetNode = 0;
  
  Int_t lay = -1;   // used by LMD/STB
  Int_t dch_num = -1; // used by LMD
  Int_t wire_num = -1; //  used by LMD
  Int_t wirenode = -1; // needed to select the anode volume
  
  TString nnam;     // used by STB
  //  Int_t offset = 0; // used by STB

  switch(det){
  case (Int_t) FIN_GTS:
    // no geometry for GTS
    break;
  case (Int_t) FIN_TOF:  
    if(ch >= 1   &&   ch <= K_N_TOFINO_SLABS)    fCurDetNode = fPromptVolume->FindNode("ITOF_1");
    else if(ch>=101 && ch<=100+K_N_TOFONE_SLABS) fCurDetNode = fPromptVolume->FindNode("ETOF_1");
    else{
      Error("SelectDetectorNode","Wrong cannel number for TOF (%d)",ch);
      return 0;
    }
    break;
  case (Int_t) FIN_ISM:
    nnam.Form("ISIM_%d",ch);
    fCurDetNode = fPromptVolume->FindNode(nnam);
    break;
  case (Int_t) FIN_OSM:
    nnam.Form("OSIM_%d",ch);
    fCurDetNode = fPromptVolume->FindNode(nnam);
    break;
  case (Int_t) FIN_LMD: // to be completed
    // wire(ch) numbering:
    //   xyzk:
    //         x: layer    [1;2]
    //         y: chamber  [1-8]
    //        zk: wire   [1-12](inner) ; [1-22] (outer)
    //        zk == 00 means -> chamber external node
    
    if(ch<=0 || ch > 2822){
      Error("SelectDetectorNode","Channel out of range (LMD): %d",ch);
      gApplication->Terminate();
    }
    TFndDB::Lmd_ChNum_To_DetChan(ch,lay,dch_num,wire_num,wirenode);
    if(wire_num == 0){
      fCurDetNode = fPromptVolume->FindNode("BAG2_1")->GetDaughter((lay-1)*8 + (dch_num-1)); 
      break;
    }
    if(fVerboseLevel>1) Printf("Selecting node for LMD: ch: %d ===> layer: %d; dch_num: %d; wire_num: %d; wirenode: %d.",ch,lay,dch_num,wire_num,wirenode);
    //    fCurDetNode = gGeoManager->GetVolume("BAG2")->GetNode(0)->GetDaughter(0)->GetDaughter(0);
    //fCurDetNode = gGeoManager->GetVolume("BAG2")->GetNode(8)->GetDaughter(0)->GetDaughter(0); // outer
    //
    fCurDetNode = fPromptVolume->FindNode("BAG2_1")
      ->GetDaughter((lay-1)*8 + (dch_num-1))->GetDaughter(0)->GetDaughter(0)
      ->GetDaughter(4)->GetDaughter(wirenode);

    //    cout << "============> " << fCurDetNode->GetName() << endl;
    //    fCurDetNode = fPromptNode->GetVolume()->FindNode("BAG2_1")->GetDaughter(0)->GetDaughter(0); // outer
    break;
  case (Int_t) FIN_STB: // to be completed
    // "lay" used for "crown-1"
    // "wire_num" used for "tube" [1-404]
    // "wire_node" used for "tube_node"
    // wire number "0" used for STB crown
    
    TFndDB::Stb_ChNum_To_DetChan(ch,lay,wire_num,wirenode);
    if(lay<1 || lay > K_N_STB_CROWNS || wire_num<0 || wire_num >K_N_STB_TUBES){
      Error("SelectDetectorNode","Channel out of range (STB): %d",ch);
      gApplication->Terminate();
    }
    if(lay<=2){
      nnam = "SSTR_1";
    }
    else if(lay<=6){
      nnam = "TSTR_1";
    }
    //     else if(lay<=6){
    //       nnam = "TSTR_1";
    //       //      offset = 810;
    //     }
    else{
      Error("SelectDetectorNode","BUG! (stb)");
      gApplication->Terminate();
    }
    if(fVerboseLevel>1) Printf("Selecting node for STB: ch: %d ===> crown: %d; tube: %d; wirenode: %d.",ch,lay,wire_num,wirenode);
    if(wire_num==0) fCurDetNode = fPromptVolume->FindNode(nnam);
    else fCurDetNode = fPromptVolume->FindNode(nnam)->GetDaughter(wirenode);
    if(!fCurDetNode){
      Error("SelectDetectorNode","BUG!");
      gApplication->Terminate();
    }
    break;
  default:
    Warning("SelectDetectorNode","detector id \"%d\" not available",det);
    return 0;
  }

  if(fVerboseLevel>0) Info("SelectDetectorNode","Current node set to \"%s\"",fCurDetNode->GetName());
  return fCurDetNode;
}

//    NOBODY SHOULD NEED TO MODIFY THE FOLLOWING METHODS    //

//_______________________________________
Int_t TFndGeometry::SetDefaultColors(){
  // in some cases a quick access to common volumes is used

  // beam-pipe
  fPromptVolume->FindNode("PIPE_1")->GetVolume()->SetLineColor(35);
  for(Int_t i=0;i<fPromptVolume->FindNode("PIPE_1")->GetNdaughters();i++){
    fPromptVolume->FindNode("PIPE_1")->GetDaughter(i)->GetVolume()->SetLineColor(95);
  }

  SelectDetectorNode(FIN_TOF,1); // tofino
  fCurDetNode->GetDaughter(0)->GetVolume()->SetLineColor(7);

  SelectDetectorNode(FIN_ISM,1); // isim
  fCurDetNode->GetVolume()->SetLineColor(18);

  // targets
  for(Int_t i=0;i<8;i++) fTgtNodes[i]->GetVolume()->SetLineColor(28);

  SelectDetectorNode(FIN_OSM,1); // osim
  fCurDetNode->GetVolume()->SetLineColor(19);

  // lmd (inner and outer)
  fPromptVolume->FindNode("BAG2_1")->GetDaughter(0)->GetDaughter(0)->GetDaughter(0)->GetVolume()->SetLineColor(38);
  fPromptVolume->FindNode("BAG2_1")->GetDaughter(8)->GetDaughter(0)->GetDaughter(0)->GetVolume()->SetLineColor(9);

  // straw  
  fPromptVolume->FindNode("SSTR_1")->GetVolume()->SetLineColor(29);
  fPromptVolume->FindNode("TSTR_1")->GetVolume()->SetLineColor(30);

  SelectDetectorNode(FIN_TOF,101); // tofone
  fCurDetNode->GetDaughter(0)->GetVolume()->SetLineColor(7);

  // --------------------
  //    --- STRUCTURE ---
  fPromptVolume->FindNode("MCRA_1")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("MCRA_1")->GetVolume()->SetLineColor(18);

  fPromptVolume->FindNode("FLCN_1")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("FLCN_2")->GetVolume()->SetLineColor(18);

  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN1_1")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN1_2")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN2_1")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN2_2")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN3_1")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN3_2")->GetVolume()->SetLineColor(18);

  fPromptVolume->FindNode("RIN5_1")->GetVolume()->SetLineColor(18);
  fPromptVolume->FindNode("RIN5_2")->GetVolume()->SetLineColor(18);

  TString mdcstr = "";
  TString beastr = "";
  for(Int_t l=1;l<=2;l++){
    for(Int_t c=1;c<=16;c++){
      mdcstr.Form("MDC%d_%d",l,c); // side borders (lmd)
      beastr.Form("BEA%d_%d",l,c); // front/rear borders (lmd)
      fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode(mdcstr.Data())->GetVolume()->SetLineColor(18);
      fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode(beastr.Data())->GetVolume()->SetLineColor(18);
    }
  }
  // ---
  gGeoManager->ModifiedPad();

}

//_______________________________________
Int_t TFndGeometry::SetDefaultVisibility(){
  // the default visibility includes all detector layers
  // with a low-memory usage: it is useful as base visualization
  // for the event-display.
  
  SetLayerVisibility(FGEO_TOFINO,      1,1);
  SetLayerVisibility(FGEO_BEAM_PIPE,   1,0);
  SetLayerVisibility(FGEO_ISIM,        1,0);
  SetLayerVisibility(FGEO_TARGETS,     1,0);
  SetLayerVisibility(FGEO_OSIM,        1,0);
  SetLayerVisibility(FGEO_INNER_LMD,   1,0);
  SetLayerVisibility(FGEO_OUTER_LMD,   1,0);
  SetLayerVisibility(FGEO_STRAW_TUBES, 1,0);
  SetLayerVisibility(FGEO_TOFONE,      1,1);
  SetStructureVisibility(0,0);
}

//_______________________________________
void TFndGeometry::SetLayerVisibility(Int_t layer,Bool_t visible,Bool_t detailed){
  // the "layer" must be chosen from TFndGeometry::EFndGeoLayers:
  //  see TFndGeometry.h for available values
  //
  //     enum EFndGeoLayers {
  //     FGEO_BEAM_PIPE = 0,                
  //     FGEO_TOFINO,                       
  //     FGEO_ISIM, FGEO_TARGETS, FGEO_OSIM,
  //     FGEO_INNER_LMD, FGEO_OUTER_LMD,    
  //     FGEO_STRAW_TUBES,                  
  //     FGEO_TOFONE,                       
  //     };                  
  
  switch(layer){
  case (Int_t)FGEO_BEAM_PIPE:
    fPromptVolume->FindNode("PIPE_1")->GetVolume()->FindNode("BERI_1")->SetVisibility(visible);
    fPromptVolume->FindNode("PIPE_1")->GetVolume()->FindNode("PSTR_1")->SetVisibility(kFALSE);
    fPromptVolume->FindNode("PIPE_1")->GetVolume()->FindNode("PSTR_2")->SetVisibility(kFALSE);
    fPromptVolume->FindNode("PIPE_1")->GetVolume()->FindNode("PTAI_1")->SetVisibility(detailed);
    fPromptVolume->FindNode("PIPE_1")->GetVolume()->FindNode("PTAI_2")->SetVisibility(detailed);
    //     fPromptVolume->FindNode("PIPE_1")->SetVisibility(!visible);
    //     fPromptVolume->FindNode("PIPE_1")->GetVolume()->SetVisibility(detailed);
    //     fPromptVolume->FindNode("PIPE_1")->GetVolume()->VisibleDaughters(visible);
      //    for(Int_t i=0;i<fPromptVolume->FindNode("PIPE_1")->GetNdaughters();i++){
      //      fPromptVolume->FindNode("PIPE_1")->GetDaughter(i)->SetVisibility(visible);
      //      fPromptVolume->FindNode("PIPE_1")->GetDaughter(i)->GetVolume()->SetVisibility(detailed);
      //    }
    return;
  case (Int_t)FGEO_TOFINO:
    fPromptVolume->FindNode("ITOF_1")->GetVolume()->SetVisibility(visible);
    fPromptVolume->FindNode("ITOF_1")->GetVolume()->VisibleDaughters(visible && detailed);
    return;
  case (Int_t)FGEO_ISIM:
    fPromptVolume->FindNode("ISIM_1")->GetVolume()->SetVisibility(visible);
    fPromptVolume->FindNode("IGLA_1")->GetVolume()->SetVisibility(detailed);
    fPromptVolume->FindNode("IUPL_4")->GetVolume()->SetVisibility(detailed);
    return;
  case (Int_t)FGEO_TARGETS:
    for(Int_t i=0;i<8;i++){
      fTgtNodes[i]->GetVolume()->SetVisibility(visible);
      fTgtNodes[i]->GetVolume()->VisibleDaughters(detailed);
    }
    if(fSetup==(Int_t)FGEO_2006) fPromptVolume->FindNode("DEG5_1")->SetVisibility(visible && detailed);
    return;
  case (Int_t)FGEO_OSIM:
    fPromptVolume->FindNode("OSIM_1")->GetVolume()->SetVisibility(visible);
    fPromptVolume->FindNode("OGLA_1")->GetVolume()->SetVisibility(detailed);
    fPromptVolume->FindNode("OUPL_6")->GetVolume()->SetVisibility(detailed);
    return;
  case (Int_t)FGEO_INNER_LMD:
    SetLmdLayVis(0,visible,detailed);
    return;
  case (Int_t)FGEO_OUTER_LMD:
    SetLmdLayVis(1,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES:
    for(Int_t i=0;i<6;i++) SetStbLayVis(i,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES_1:
    SetStbLayVis(0,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES_2:
    SetStbLayVis(1,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES_3:
    SetStbLayVis(2,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES_4:
    SetStbLayVis(3,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES_5:
    SetStbLayVis(4,visible,detailed);
    return;
  case (Int_t)FGEO_STRAW_TUBES_6:
    SetStbLayVis(5,visible,detailed);
    return;
    //
  case (Int_t)FGEO_TOFONE:
    fPromptVolume->FindNode("ETOF_1")->GetVolume()->SetVisibility(visible);
    fPromptVolume->FindNode("ETOF_1")->GetVolume()->VisibleDaughters(visible && detailed);
    return;
  default:
    Warning("SetLayerVisibility","The selected layer was not accepted (id = %d)",layer);
    return;
  }

}

//_______________________________________
void TFndGeometry::SetStructureVisibility(Bool_t visible,Int_t detail_lev){



  fPromptVolume->FindNode("MCRA_1")->GetVolume()->SetVisibility(visible);
  fPromptVolume->FindNode("MCRA_1")->GetVolume()->VisibleDaughters((Bool_t)detail_lev);
  
  // --- after fROOT-9.0 (gcc-4/gfortran used for re-rceating geometry from fidarc 603)
  Bool_t flcvis  = (detail_lev >= 4) ? kTRUE: kFALSE;
  Bool_t rin5vis = (detail_lev >= 5) ? kTRUE: kFALSE;
  Bool_t flavis  = (detail_lev >= 6) ? kTRUE: kFALSE;
  Bool_t magvis3 = (detail_lev >= 7) ? kTRUE: kFALSE;
  Bool_t magvis2 = (detail_lev >= 8) ? kTRUE: kFALSE;
  Bool_t magvis1 = (detail_lev >= 9) ? kTRUE: kFALSE;

  fPromptVolume->FindNode("MAG1_1")->SetVisibility(magvis1);
  fPromptVolume->FindNode("MAG1_2")->SetVisibility(magvis1);
  fPromptVolume->FindNode("MAG2_1")->SetVisibility(magvis2);
  fPromptVolume->FindNode("MAG2_2")->SetVisibility(magvis2);
  fPromptVolume->FindNode("MAG3_1")->SetVisibility(magvis3);

  fPromptVolume->FindNode("FLCN_1")->SetVisibility(flcvis);
  fPromptVolume->FindNode("FLCN_2")->SetVisibility(flcvis);

  fPromptVolume->FindNode("COIL_1")->SetVisibility(kFALSE);

  fPromptVolume->FindNode("CCOM_1")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("CCOM_2")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("PBEL_1")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("PBEL_2")->SetVisibility(kFALSE);

  fPromptVolume->FindNode("MCP1_1")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("MCP1_2")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("MCP2_1")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("MCP2_2")->SetVisibility(kFALSE);

  fPromptVolume->FindNode("FLA1_1")->SetVisibility(flavis);
  fPromptVolume->FindNode("FLA1_2")->SetVisibility(flavis);
  fPromptVolume->FindNode("FLA2_1")->SetVisibility(flavis);
  fPromptVolume->FindNode("FLA2_2")->SetVisibility(flavis);
  
  fPromptVolume->FindNode("BAG1_1")->SetVisibility(kFALSE);
  fPromptVolume->FindNode("STST_1")->SetVisibility(kFALSE);

  fPromptVolume->FindNode("RIN5_1")->SetVisibility(rin5vis);
  fPromptVolume->FindNode("RIN5_2")->SetVisibility(rin5vis);

  Bool_t rinvis = (detail_lev >= 3) ? kTRUE: kFALSE;
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN1_1")->SetVisibility(rinvis);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN1_2")->SetVisibility(rinvis);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN2_1")->SetVisibility(rinvis);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN2_2")->SetVisibility(rinvis);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN3_1")->SetVisibility(rinvis);
  fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode("RIN3_2")->SetVisibility(rinvis);
  

  TString mdcstr = "";
  TString beastr = "";
  Bool_t mdcvis = (detail_lev >= 1) ? kTRUE: kFALSE;
  Bool_t beavis = (detail_lev >= 2) ? kTRUE: kFALSE;

  for(Int_t l=1;l<=2;l++){
    for(Int_t c=1;c<=16;c++){
      mdcstr.Form("MDC%d_%d",l,c); // side borders (lmd)
      beastr.Form("BEA%d_%d",l,c); // front/rear borders (lmd)
      fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode(mdcstr.Data())->SetVisibility(mdcvis);
      fPromptVolume->FindNode("BAG2_1")->GetVolume()->FindNode(beastr.Data())->SetVisibility(beavis);
    }
  }
  //
}

//_______________________________________
void TFndGeometry::SetLmdLayVis(Int_t lay,Bool_t visible,Bool_t detailed){

  Int_t offset = (Int_t)(lay * 8);
  TGeoNode *cnod = fPromptVolume->FindNode("BAG2_1")->GetDaughter(offset)->GetDaughter(0)->GetDaughter(0);
  gGeoManager->SetVisOption(0);
  cnod->GetVolume()->SetVisibility(visible);
  cnod->GetVolume()->VisibleDaughters(detailed && visible);
  cnod->GetDaughter(0)->GetVolume()->SetVisibility(visible && detailed);
}

//_______________________________________
void TFndGeometry::SetStbLayVis(Int_t lay,Bool_t visible,Bool_t detailed){

  TString nnam;
  Int_t offset = 0;
  
  if(lay<2){
    nnam = "SSTR_1";
  }
  else if(lay<4){
    nnam = "TSTR_1";
  }
  else if(lay<6){
    nnam = "TSTR_1";
    offset = 810;
  }
  else{
    Error("SetStbLayVis","BUG!");
    gApplication->Terminate();
  }
  
  TGeoNode *cnod = fPromptVolume->FindNode(nnam);
  if(!cnod){
    Error("SetStbLayVis","BUG!");
    gApplication->Terminate();
  }
  
  gGeoManager->SetVisOption(0);
  //  cnod->GetVolume()->SetVisLeaves(!detailed);
  cnod->GetVolume()->VisibleDaughters(visible && detailed);
  cnod->GetVolume()->SetVisibility(visible && !detailed);
  cnod->GetDaughter(offset+lay)->GetVolume()->SetVisibility(visible && detailed);

}
//  set drawing mode :
//  option=0 (default) all nodes drawn down to vislevel
//  option=1           leaves and nodes at vislevel drawn
//  option=2           path is drawn
//  option=4           visibility changed

---