REROOT_Geom.cxx

Go to the documentation of this file.

//
// $Id: REROOT_Geom.cxx,v 1.15 2002/12/13 17:33:59 rhatcher Exp $
//
//
// REROOT_Geom
//
//Begin_Html<img src="../../pedestrians.gif" align=center>  <a href="../source_warning.html">Warning for beginners</a>.<br>
//Also see <a href="../../root_crib/index.html">The ROOT Crib</a> and <a href="../index.html">The MINOS Class User Guide</a>End_Html
//
//This single object corresponds to the ADAMO geometry data flow. It collects
//all the geometry ADAMO class objects into a single object for I/O and has a
//set of member functions to provide access to these objects.
//
//Its I/O is via a ROOT TTree object and this allows plotting of all its
//ADAMO objects using the TTree:Draw command.
//
//For more details see the Begin_Html<a href = "../index.html#REROOT_Event">The REROOT_Event and REROOT_Geom Classes</a> section<br> 
//of the <a href = "../index.html#REROOT">Overview: REROOT - OO Equivalent of the ADAMO Entity Sets</a>End_Html
//
//
//Access to Objects
//-----------------
//
//The current REROOT_Geom object can be retrieved from the global MINFAST
//object pointer gMINFast by:-
//
//     REROOT_Geom *rgeo= gMINFast->GetREROOTEvent();
//
//Once a pointer to the REROOT_Geom object has been obtained, its ADAMO
//objects can accessed, e.g.:-
//
//    TClonesArray *planespecs = rgeo->planspecs();
//
//
//Member Functions
//----------------
//
//For a list of member functions look up to the top of the current page
//
//
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;

#include "REROOT_Classes/REROOT_Geom.h"

//rwh: allocate a location for global pointer
REROOT_Geom *gREROOT_Geom = 0;

ClassImp(REROOT_Geom)

// Define Static Variables
  Bool_t REROOT_Geom::AvailNuclei_isWanted;
  Bool_t REROOT_Geom::BeamSystem_isWanted;
  Bool_t REROOT_Geom::CellPos_isWanted;
  Bool_t REROOT_Geom::CoilTube_isWanted;       
  Bool_t REROOT_Geom::FLSParam_isWanted;
  Bool_t REROOT_Geom::GAFKey_isWanted;
  Bool_t REROOT_Geom::GeomMisc_isWanted;
  Bool_t REROOT_Geom::MassDistrib_isWanted;
  Bool_t REROOT_Geom::Material_isWanted;
  Bool_t REROOT_Geom::MdlOrg_isWanted;
  Bool_t REROOT_Geom::Mixture_isWanted;
  Bool_t REROOT_Geom::PlanePos_isWanted;
  Bool_t REROOT_Geom::PlaneSpec_isWanted;
  Bool_t REROOT_Geom::PlexusAdd_isWanted;
  Bool_t REROOT_Geom::Pln2MUX_isWanted;
  Bool_t REROOT_Geom::Rotm_isWanted;
  Bool_t REROOT_Geom::SubVolPos_isWanted;
  Bool_t REROOT_Geom::SubVolSpec_isWanted;
  Bool_t REROOT_Geom::SuperModule_isWanted;
  Bool_t REROOT_Geom::TMedium_isWanted;
  Bool_t REROOT_Geom::TPar_isWanted;
  Bool_t REROOT_Geom::TubePixelInfo_isWanted;
  Bool_t REROOT_Geom::TubePixelMap_isWanted;

  REROOT_Geom *REROOT_Geom::s_curgeom;

  TClonesArray *REROOT_Geom::s_availnucleis;
  TClonesArray *REROOT_Geom::s_beamsystems;
  TClonesArray *REROOT_Geom::s_cellposs;
  TClonesArray *REROOT_Geom::s_coiltubes;       
  TClonesArray *REROOT_Geom::s_flsparams;
  TClonesArray *REROOT_Geom::s_gafkeys;
  TClonesArray *REROOT_Geom::s_geommiscs;
  TClonesArray *REROOT_Geom::s_massdistribs;
  TClonesArray *REROOT_Geom::s_materials;
  TClonesArray *REROOT_Geom::s_mdlorgs;
  TClonesArray *REROOT_Geom::s_mixtures;
  TClonesArray *REROOT_Geom::s_planeposs;
  TClonesArray *REROOT_Geom::s_planespecs;
  TClonesArray *REROOT_Geom::s_plexusadds;
  TClonesArray *REROOT_Geom::s_pln2muxs;
  TClonesArray *REROOT_Geom::s_rotms;
  TClonesArray *REROOT_Geom::s_subvolposs;
  TClonesArray *REROOT_Geom::s_subvolspecs;
  TClonesArray *REROOT_Geom::s_supermodules;
  TClonesArray *REROOT_Geom::s_tmediums;
  TClonesArray *REROOT_Geom::s_tpars;
  TClonesArray *REROOT_Geom::s_tubepixelinfos;
  TClonesArray *REROOT_Geom::s_tubepixelmaps;

  Int_t   REROOT_Geom::fNumberOfGeomRead = 0;  // initialize it once
  Float_t REROOT_Geom::fGlobalZ0Shift    = 0.0;

REROOT_Geom::REROOT_Geom()
{
        s_curgeom = this;

        if (!s_availnucleis)
           s_availnucleis = new TClonesArray("REROOT_AvailNuclei",5);
        m_availnucleis = s_availnucleis;
        if (!s_beamsystems)
           s_beamsystems = new TClonesArray("REROOT_BeamSystem",1);
        m_beamsystems = s_beamsystems;
        if (!s_cellposs)
           s_cellposs = new TClonesArray("REROOT_CellPos",1000);
        m_cellposs = s_cellposs;
        if (!s_coiltubes)
           s_coiltubes = new TClonesArray("REROOT_CoilTube",100);
        m_coiltubes = s_coiltubes;
        if (!s_flsparams)
           s_flsparams = new TClonesArray("REROOT_FLSParam",45);
        m_flsparams = s_flsparams;
        if (!s_gafkeys)
           s_gafkeys = new TClonesArray("REROOT_GAFKey",1);
        m_gafkeys = s_gafkeys;
        if (!s_geommiscs)
           s_geommiscs = new TClonesArray("REROOT_GeomMisc",1);
        m_geommiscs = s_geommiscs;
        if (!s_massdistribs)
           s_massdistribs = new TClonesArray("REROOT_MassDistrib",5);
        m_massdistribs = s_massdistribs;
        if (!s_materials)
           s_materials = new TClonesArray("REROOT_Material",100);
        m_materials = s_materials;
        if (!s_mdlorgs)
           s_mdlorgs = new TClonesArray("REROOT_MdlOrg",50);
        m_mdlorgs = s_mdlorgs;
        if (!s_mixtures)
           s_mixtures = new TClonesArray("REROOT_Mixture",100);
        m_mixtures = s_mixtures;
        if (!s_planeposs)
           s_planeposs = new TClonesArray("REROOT_PlanePos",1000);
        m_planeposs = s_planeposs;
        if (!s_planespecs)
           s_planespecs = new TClonesArray("REROOT_PlaneSpec",10);
        m_planespecs = s_planespecs;
        if (!s_plexusadds)
           s_plexusadds = new TClonesArray("REROOT_PlexusAdd",5);
        m_plexusadds = s_plexusadds;
        if (!s_pln2muxs)
           s_pln2muxs = new TClonesArray("REROOT_Pln2MUX",5);
        m_pln2muxs = s_pln2muxs;
        if (!s_rotms)
           s_rotms = new TClonesArray("REROOT_Rotm",20);
        m_rotms = s_rotms;
        if (!s_subvolposs)
           s_subvolposs = new TClonesArray("REROOT_SubVolPos",5);
        m_subvolposs = s_subvolposs;
        if (!s_subvolspecs)
           s_subvolspecs = new TClonesArray("REROOT_SubVolSpec",5);
        m_subvolspecs = s_subvolspecs;
        if (!s_supermodules)
           s_supermodules = new TClonesArray("REROOT_SuperModule",10);
        m_supermodules = s_supermodules;
        if (!s_tmediums)
           s_tmediums = new TClonesArray("REROOT_TMedium",50);
        m_tmediums = s_tmediums;
        if (!s_tpars)
           s_tpars = new TClonesArray("REROOT_TPar",1);
        m_tpars = s_tpars;
        if (!s_tubepixelinfos)
           s_tubepixelinfos=new TClonesArray("REROOT_TubePixelInfo",5);
        m_tubepixelinfos = s_tubepixelinfos;
        if (!s_tubepixelmaps)
           s_tubepixelmaps = new TClonesArray("REROOT_TubePixelMap",5);
        m_tubepixelmaps = s_tubepixelmaps;

        fGlobalZ0Shift = 0.0;
}

REROOT_Geom::~REROOT_Geom()
{
   Clear();
}

void sizes_of_geom_clones(Int_t i, const Char_t* name, const TClonesArray* tca)
{
   if (i == 0) 
      cout << "new REROOT_Geom record" << endl;
   cout << setw(15) << name << " "
        << setw(5) << tca->Capacity()
        << setw(5) << tca->GetEntries()
        << setw(5) << tca->GetEntriesFast()
        << setw(5) << tca->GetLast();
   if (i >= 0) cout << endl;
}
void REROOT_Geom::Print(Option_t * /* option */) const
{
   sizes_of_geom_clones(0,"AvailNuclei",m_availnucleis);
   sizes_of_geom_clones(1,"BeamSystem",m_beamsystems);
   sizes_of_geom_clones(2,"CellPos",m_cellposs);
   sizes_of_geom_clones(3,"CoilTube",m_coiltubes);
   sizes_of_geom_clones(4,"FLSParam",m_flsparams);
   sizes_of_geom_clones(5,"GAFKey",m_gafkeys);
   sizes_of_geom_clones(6,"GeomMisc",m_geommiscs);
   sizes_of_geom_clones(7,"MassDistrib",m_massdistribs);
   sizes_of_geom_clones(8,"Material",m_materials);
   sizes_of_geom_clones(9,"MdlOrg",m_mdlorgs);
   sizes_of_geom_clones(10,"Mixture",m_mixtures);
   sizes_of_geom_clones(11,"PlanePos",m_planeposs);
   sizes_of_geom_clones(12,"PlaneSpec",m_planespecs);
   sizes_of_geom_clones(13,"PlexusAdd",m_plexusadds);
   sizes_of_geom_clones(14,"Pln2Mux",m_pln2muxs);
   sizes_of_geom_clones(15,"Rotm",m_rotms);
   sizes_of_geom_clones(16,"SubVolPos",m_subvolposs);
   sizes_of_geom_clones(17,"SubVolSpec",m_subvolspecs);
   sizes_of_geom_clones(18,"SuperModule",m_supermodules);
   sizes_of_geom_clones(19,"TMedium",m_tmediums);
   sizes_of_geom_clones(20,"TPar",m_tpars);
   sizes_of_geom_clones(21,"TubePixelInfo",m_tubepixelinfos);
   sizes_of_geom_clones(22,"TubePixelMap",m_tubepixelmaps);
}

void REROOT_Geom::init()
{
}

void REROOT_Geom::Clear(Option_t * /* option */)
{
  if (m_availnucleis)  m_availnucleis->Clear();
  if (m_beamsystems)   m_beamsystems->Clear();
  if (m_cellposs)      m_cellposs->Clear();
  if (m_coiltubes)     m_coiltubes->Clear();
  if (m_flsparams)     m_flsparams->Clear();
  if (m_gafkeys)       m_gafkeys->Clear();
  if (m_geommiscs)     m_geommiscs->Clear();
  if (m_massdistribs)  m_massdistribs->Clear();
  if (m_materials)     m_materials->Clear();
  if (m_mdlorgs)       m_mdlorgs->Clear();
  if (m_mixtures)      m_mixtures->Clear();
  if (m_planeposs)     m_planeposs->Clear();
  if (m_planespecs)    m_planespecs->Clear();
  if (m_plexusadds)    m_plexusadds->Clear();
  if (m_pln2muxs)      m_pln2muxs->Clear();
  if (m_rotms)         m_rotms->Clear();
  if (m_subvolposs)    m_subvolposs->Clear();
  if (m_subvolspecs)   m_subvolspecs->Clear();
  if (m_supermodules)  m_supermodules->Clear();
  if (m_tmediums)      m_tmediums->Clear();
  if (m_tpars)         m_tpars->Clear();
  if (m_tubepixelinfos) m_tubepixelinfos->Clear();
  if (m_tubepixelmaps)  m_tubepixelmaps->Clear();
}

void REROOT_Geom::fill_objects_from_GAF(ADAMO_Shell* ads)
{
  if (AvailNuclei_isWanted) {
//gmi   if (m_availnucleis) m_availnucleis->Clear();
        int n_availnucleis = ads->coutab((AVAILNUCLEI_DEF *) 0);
        AVAILNUCLEI_DEF* nr;
        for (int i=0; i<n_availnucleis; i++) {
          nr=ads->gettab((AVAILNUCLEI_DEF *) 0,i+1);
          if (nr) new((*m_availnucleis)[i]) REROOT_AvailNuclei(nr);
  }     }
  if (BeamSystem_isWanted) {
//gmi   if (m_beamsystems)  m_beamsystems->Clear();
        int n_beamsystems  = ads->coutab((BEAMSYSTEM_DEF *) 0);
        BEAMSYSTEM_DEF* nr;
        for (int i=0; i<n_beamsystems; i++) {
          nr = ads->gettab((BEAMSYSTEM_DEF *) 0,i+1);
          if (nr) new((*m_beamsystems)[i]) REROOT_BeamSystem(nr);
  }     }
  if (CellPos_isWanted) {
//gmi   if (m_cellposs)     m_cellposs->Clear();
        int n_cellposs     = ads->coutab((CELLPOS_DEF *) 0);
        CELLPOS_DEF* nr;
        for (int i=0; i<n_cellposs; i++) {
          nr = ads->gettab((CELLPOS_DEF *) 0,i+1);
          if (nr) new((*m_cellposs)[i]) REROOT_CellPos(nr);
  }     }
  if (CoilTube_isWanted) {
//gmi   if (m_coiltubes) m_coiltubes->Clear();
        int n_coiltubes = ads->coutab((COILTUBE_DEF *) 0);
        COILTUBE_DEF* nr;
        for (int i=0; i<n_coiltubes; i++) {
          nr=ads->gettab((COILTUBE_DEF *) 0,i+1);
          if (nr) new((*m_coiltubes)[i]) REROOT_CoilTube(nr);
  }     }
  if (FLSParam_isWanted) {
//gmi   if (m_flsparams) m_flsparams->Clear();
        int n_flsparams = ads->coutab((FLSPARAM_DEF *) 0);
        FLSPARAM_DEF* nr;
        for (int i=0; i<n_flsparams; i++) {
          nr=ads->gettab((FLSPARAM_DEF *) 0,i+1);
          if (nr) new((*m_flsparams)[i]) REROOT_FLSParam(nr);
  }     }
  if (GAFKey_isWanted) {
//gmi   if (m_gafkeys)      m_gafkeys->Clear();
        int n_gafkeys      = ads->coutab((GAFKEY_DEF *) 0);
        GAFKEY_DEF* nr;
        for (int i=0; i<n_gafkeys; i++) {
          nr = ads->gettab((GAFKEY_DEF *) 0,i+1);
          if (nr) new((*m_gafkeys)[i]) REROOT_GAFKey(nr);
  }     }
  if (GeomMisc_isWanted) {
//gmi   if (m_geommiscs)    m_geommiscs->Clear();
        int n_geommiscs    = ads->coutab((GEOMMISC_DEF *) 0);
        GEOMMISC_DEF* nr;
        for (int i=0; i<n_geommiscs; i++) {
          nr = ads->gettab((GEOMMISC_DEF *) 0,i+1);
          if (nr) new((*m_geommiscs)[i]) REROOT_GeomMisc(nr);
  }     }
  if (MassDistrib_isWanted) {
//gmi   if (m_massdistribs) m_massdistribs->Clear();
        int n_massdistribs = ads->coutab((MASSDISTRIB_DEF *) 0);
        MASSDISTRIB_DEF* nr;
        for (int i=0; i<n_massdistribs; i++) {
          nr=ads->gettab((MASSDISTRIB_DEF *) 0,i+1);
          if (nr) new((*m_massdistribs)[i]) REROOT_MassDistrib(nr);
  }     }
  if (Material_isWanted) {
//gmi   if (m_materials)    m_materials->Clear();
        int n_materials    = ads->coutab((MATERIAL_DEF *) 0);
        MATERIAL_DEF* nr;
        for (int i=0; i<n_materials; i++) {
          nr = ads->gettab((MATERIAL_DEF *) 0,i+1);
          if (nr) new((*m_materials)[i]) REROOT_Material(nr);
  }     }
  if (MdlOrg_isWanted) {
//gmi   if (m_mdlorgs)      m_mdlorgs->Clear();
        int n_mdlorgs      = ads->coutab((MDLORG_DEF *) 0);
        MDLORG_DEF* nr;
        for (int i=0; i<n_mdlorgs; i++) {
          nr = ads->gettab((MDLORG_DEF *) 0,i+1);
          if (nr) new((*m_mdlorgs)[i]) REROOT_MdlOrg(nr);
  }     }
  if (Mixture_isWanted) {
//gmi   if (m_mixtures)     m_mixtures->Clear();
        int n_mixtures     = ads->coutab((MIXTURE_DEF *) 0);
        MIXTURE_DEF* nr;
        for (int i=0; i<n_mixtures; i++) {
          nr = ads->gettab((MIXTURE_DEF *) 0,i+1);
          if (nr) new((*m_mixtures)[i]) REROOT_Mixture(nr);
  }     }
  if (PlanePos_isWanted) {
//gmi   if (m_planeposs)    m_planeposs->Clear();
        int n_planeposs    = ads->coutab((PLANEPOS_DEF *) 0);
        PLANEPOS_DEF* nr;
        for (int i=0; i<n_planeposs; i++) {
          nr = ads->gettab((PLANEPOS_DEF *) 0,i+1);
          if (nr) new((*m_planeposs)[i]) REROOT_PlanePos(nr);
  }
        }
  if (PlaneSpec_isWanted) {
//gmi   if (m_planespecs)   m_planespecs->Clear();
        int n_planespecs   = ads->coutab((PLANESPEC_DEF *) 0);
        PLANESPEC_DEF* nr;
        for (int i=0; i<n_planespecs; i++) {
          nr = ads->gettab((PLANESPEC_DEF *) 0,i+1);
          if (nr) new((*m_planespecs)[i]) REROOT_PlaneSpec(nr);
  }     }
  if (PlexusAdd_isWanted) {
//gmi   if (m_plexusadds) m_plexusadds->Clear();
        int n_plexusadds = ads->coutab((PLEXUSADD_DEF *) 0);
        PLEXUSADD_DEF* nr;
        for (int i=0; i<n_plexusadds; i++) {
          nr=ads->gettab((PLEXUSADD_DEF *) 0,i+1);
          if (nr) new((*m_plexusadds)[i]) REROOT_PlexusAdd(nr);
  }     }
  if (Pln2MUX_isWanted) {
//gmi   if (m_pln2muxs) m_pln2muxs->Clear();
        int n_pln2muxs = ads->coutab((PLN2MUX_DEF *) 0);
        PLN2MUX_DEF* nr;
        for (int i=0; i<n_pln2muxs; i++) {
          nr=ads->gettab((PLN2MUX_DEF *) 0,i+1);
          if (nr) new((*m_pln2muxs)[i]) REROOT_Pln2MUX(nr);
  }     }
  if (Rotm_isWanted) {
//gmi   if (m_rotms)        m_rotms->Clear();
        int n_rotms        = ads->coutab((ROTM_DEF *) 0);
        ROTM_DEF* nr;
        for (int i=0; i<n_rotms; i++) {
        nr = ads->gettab((ROTM_DEF *) 0,i+1);
          if (nr) new((*m_rotms)[i]) REROOT_Rotm(nr);
  }     }
  if (SubVolPos_isWanted) {
//gmi   if (m_subvolposs)   m_subvolposs->Clear();
        int n_subvolposs   = ads->coutab((SUBVOLPOS_DEF *) 0);
        SUBVOLPOS_DEF* nr;
        for (int i=0; i<n_subvolposs; i++) {
        nr = ads->gettab((SUBVOLPOS_DEF *) 0,i+1);
          if (nr) new((*m_subvolposs)[i]) REROOT_SubVolPos(nr);
  }     }
  if (SubVolSpec_isWanted) {
//gmi   if (m_subvolspecs)  m_subvolspecs->Clear();
        int n_subvolspecs  = ads->coutab((SUBVOLSPEC_DEF *) 0);
        SUBVOLSPEC_DEF* nr;
        for (int i=0; i<n_subvolspecs; i++) {
        nr = ads->gettab((SUBVOLSPEC_DEF *) 0,i+1);
          if (nr) new((*m_subvolspecs)[i]) REROOT_SubVolSpec(nr);
  }     }
  if (SuperModule_isWanted) {
//gmi   if (m_supermodules) m_supermodules->Clear();
        int n_supermodules = ads->coutab((SUPERMODULE_DEF *) 0);
        SUPERMODULE_DEF* nr;
        for (int i=0; i<n_supermodules; i++) {
          nr=ads->gettab((SUPERMODULE_DEF *) 0,i+1);
          if (nr) new((*m_supermodules)[i]) REROOT_SuperModule(nr);
  }     }
  if (TMedium_isWanted) {
//gmi   if (m_tmediums)     m_tmediums->Clear();
        int n_tmediums     = ads->coutab((TMEDIUM_DEF *) 0);
        TMEDIUM_DEF* nr;
        for (int i=0; i<n_tmediums; i++) {
          nr = ads->gettab((TMEDIUM_DEF *) 0,i+1);
          if (nr) new((*m_tmediums)[i]) REROOT_TMedium(nr);
  }     }
  if (TPar_isWanted) {
//gmi   if (m_tpars)        m_tpars->Clear();
        int n_tpars        = ads->coutab((TPAR_DEF *) 0);
        TPAR_DEF* nr;
        for (int i=0; i<n_tpars; i++) {
          nr = ads->gettab((TPAR_DEF *) 0,i+1);
          if (nr) new((*m_tpars)[i]) REROOT_TPar(nr);
  }     }
  if (TubePixelInfo_isWanted) {
//gmi   if (m_tubepixelinfos) m_tubepixelinfos->Clear();
        int n_tubepixelinfos = ads->coutab((TUBEPIXELINFO_DEF *) 0);
        TUBEPIXELINFO_DEF* nr;
        for (int i=0; i<n_tubepixelinfos; i++) {
          nr=ads->gettab((TUBEPIXELINFO_DEF *) 0,i+1);
          if (nr) new((*m_tubepixelinfos)[i]) REROOT_TubePixelInfo(nr);
  }     }
  if (TubePixelMap_isWanted) {
//gmi   if (m_tubepixelmaps) m_tubepixelmaps->Clear();
        int n_tubepixelmaps = ads->coutab((TUBEPIXELMAP_DEF *) 0);
        TUBEPIXELMAP_DEF* nr;
        for (int i=0; i<n_tubepixelmaps; i++) {
          nr=ads->gettab((TUBEPIXELMAP_DEF *) 0,i+1);
          if (nr) new((*m_tubepixelmaps)[i]) REROOT_TubePixelMap(nr);
  }     }
}

REROOT_Geom::AvailNuclei_list_size_type 
                                     REROOT_Geom::n_availnucleis() const
{
  if (!m_availnucleis) return 0;
  return m_availnucleis->GetLast() + 1;
}
REROOT_Geom::BeamSystem_list_size_type REROOT_Geom::n_beamsystems()const
{
  if (!m_beamsystems) return 0;
  return m_beamsystems->GetLast() + 1;
}
REROOT_Geom::CellPos_list_size_type   REROOT_Geom::n_cellposs()    const
{
  if (!m_cellposs) return 0;
  return m_cellposs->GetLast() + 1;
}
REROOT_Geom::CoilTube_list_size_type  REROOT_Geom::n_coiltubes()   const
{
  if (!m_coiltubes) return 0;
  return m_coiltubes->GetLast() + 1;
}
REROOT_Geom::FLSParam_list_size_type  REROOT_Geom::n_flsparams()   const
{
  if (!m_flsparams) return 0;
  return m_flsparams->GetLast() + 1;
}
REROOT_Geom::GAFKey_list_size_type    REROOT_Geom::n_gafkeys()     const
{
  if (!m_gafkeys) return 0;
  return m_gafkeys->GetLast() + 1;
}
REROOT_Geom::GeomMisc_list_size_type  REROOT_Geom::n_geommiscs()   const
{
  if (!m_geommiscs) return 0;
  return m_geommiscs->GetLast() + 1;
}
REROOT_Geom::MassDistrib_list_size_type 
                                     REROOT_Geom::n_massdistribs() const
{
  if (!m_massdistribs) return 0;
  return m_massdistribs->GetLast() + 1;
}
REROOT_Geom::Material_list_size_type  REROOT_Geom::n_materials()   const
{
  if (!m_materials) return 0;
  return m_materials->GetLast() + 1;
}
REROOT_Geom::MdlOrg_list_size_type    REROOT_Geom::n_mdlorgs()     const
{
  if (!m_mdlorgs) return 0;
  return m_mdlorgs->GetLast() + 1;
}
REROOT_Geom::Mixture_list_size_type   REROOT_Geom::n_mixtures()    const
{
  if (!m_mixtures) return 0;
  return m_mixtures->GetLast() + 1;
}
REROOT_Geom::PlanePos_list_size_type  REROOT_Geom::n_planeposs()   const
{
  if (!m_planeposs) return 0;
  return m_planeposs->GetLast() + 1;
}
REROOT_Geom::PlaneSpec_list_size_type REROOT_Geom::n_planespecs()  const
{
  if (!m_planespecs) return 0;
  return m_planespecs->GetLast() + 1;
}
REROOT_Geom::PlexusAdd_list_size_type REROOT_Geom::n_plexusadds()  const
{
  if (!m_plexusadds) return 0;
  return m_plexusadds->GetLast() + 1;
}
REROOT_Geom::Pln2MUX_list_size_type   REROOT_Geom::n_pln2muxs()    const
{
  if (!m_pln2muxs) return 0;
  return m_pln2muxs->GetLast() + 1;
}
REROOT_Geom::Rotm_list_size_type      REROOT_Geom::n_rotms()       const
{
  if (!m_rotms) return 0;
  return m_rotms->GetLast() + 1;
}
REROOT_Geom::SubVolPos_list_size_type REROOT_Geom::n_subvolposs()  const
{
  if (!m_subvolposs) return 0;
  return m_subvolposs->GetLast() + 1;
}
REROOT_Geom::SubVolSpec_list_size_type REROOT_Geom::n_subvolspecs()const
{
  if (!m_subvolspecs) return 0;
  return m_subvolspecs->GetLast() + 1;
}
REROOT_Geom::SuperModule_list_size_type 
                                      REROOT_Geom::n_supermodules()const
{
  if (!m_supermodules) return 0;
  return m_supermodules->GetLast() + 1;
}
REROOT_Geom::TMedium_list_size_type   REROOT_Geom::n_tmediums()    const
{
  if (!m_tmediums) return 0;
  return m_tmediums->GetLast() + 1;
}
REROOT_Geom::TPar_list_size_type      REROOT_Geom::n_tpars()       const
{
  if (!m_tpars) return 0;
  return m_tpars->GetLast() + 1;
}
REROOT_Geom::TubePixelInfo_list_size_type 
                                   REROOT_Geom::n_tubepixelinfos() const
{
  if (!m_tubepixelinfos) return 0;
  return m_tubepixelinfos->GetLast() + 1;
}
REROOT_Geom::TubePixelMap_list_size_type 
                                    REROOT_Geom::n_tubepixelmaps() const
{
  if (!m_tubepixelmaps) return 0;
  return m_tubepixelmaps->GetLast() + 1;
}

//___________________________________________________________________________

void REROOT_Geom::FillGlobalZ0Shift(void)
{
   // This is part of a hack used to reposition the REROOT objects
   // so that z=0 (global) is now at the front of the first plane
   // rather than a the front face of the hall

   REROOT_PlanePos *firstplane = 
        dynamic_cast<REROOT_PlanePos *>(m_planeposs->At(0));
   if ( ! firstplane ) {
     cout << " REROOT_Geom::FillGobalZ0Shift failed " << endl;
     return;
   }

   // !!!! Peek at the private data to bypass the methods
   // !!!! that would eventually call this one...
   fGlobalZ0Shift = -(firstplane->m_PairZmin);

}

---