ADAMO_Shell.cxx

Go to the documentation of this file.

// $ID:  ADAMO_Shell.cxx,v 1.2 1997/01/23 16:25 gmieg Exp $
//
// Implement Class ADAMO_Shell -- ADAMO Command Interface G. Irwin 1/97

#include <iostream>
#include <string>

extern "C" int  beltab_(int*);
extern "C" int  coutab_(int*);
extern "C" void fettab_(int*,const int*,int*);
extern "C" void gettab_(int*);
extern "C" int  adamo_read_(const char*,int);

const int ID = 2147483646;

#define __ADAMO_SHELL__
#include "REROOT_Classes/ADAMO_Shell.h"
#undef __ADAMO_SHELL__

ADAMO_Shell::ADAMO_Shell()
{
}

ADAMO_Shell::~ADAMO_Shell()
{
}

void ADAMO_Shell::init()
{
}

int ADAMO_Shell::read(const char* _iniFile)
{
  int rc = adamo_read_(_iniFile,strlen(_iniFile));
  return (rc);
}

int ADAMO_Shell::coutab(DIGITPLN_DEF* /* nr */) {
  int* nnr=&digitpln_.digitpln;  return coutab_(nnr);
}

DIGITPLN_DEF* ADAMO_Shell::gettab(DIGITPLN_DEF* /* nnr */,int id) {
  int* nr=&digitpln_.digitpln;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (DIGITPLN_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find DigitPln row " 
            << id << std::endl;
  return (DIGITPLN_DEF *) 0;
}

int ADAMO_Shell::coutab(EMUDIGIT_DEF* /* nr */) {
  int* nnr=&emudigit_.emudigit;  return coutab_(nnr);
}

EMUDIGIT_DEF* ADAMO_Shell::gettab(EMUDIGIT_DEF* /* nnr */,int id) {
  int* nr=&emudigit_.emudigit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (EMUDIGIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find EmuDigit row " 
            << id << std::endl;
  return (EMUDIGIT_DEF *) 0;
}

int ADAMO_Shell::coutab(EMUHIT_DEF* /* nr */) {
  int* nnr=&emuhit_.emuhit;  return coutab_(nnr);
}

EMUHIT_DEF* ADAMO_Shell::gettab(EMUHIT_DEF* /* nnr */,int id) {
  int* nr=&emuhit_.emuhit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (EMUHIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find EmuHit row " 
            << id << std::endl;
  return (EMUHIT_DEF *) 0;
}

int ADAMO_Shell::coutab(EVENTHISTORY_DEF* /* nr */) {
  int* nnr=&eventhistory_.eventhistory;  return coutab_(nnr);
}

EVENTHISTORY_DEF* ADAMO_Shell::gettab(EVENTHISTORY_DEF* /* nnr */,int id) {
  int* nr=&eventhistory_.eventhistory;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (EVENTHISTORY_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find EventHistory row "
            << id << std::endl;
  return (EVENTHISTORY_DEF *) 0;
}

int ADAMO_Shell::coutab(FLSDIGICELL_DEF* /* nr */) {
  int* nnr=&flsdigicell_.flsdigicell;  return coutab_(nnr);
}

FLSDIGICELL_DEF* ADAMO_Shell::gettab(FLSDIGICELL_DEF* /* nnr */,int id) {
  int* nr=&flsdigicell_.flsdigicell;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLSDIGICELL_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FLSDigiCell row "
            << id << std::endl;
  return (FLSDIGICELL_DEF *) 0;
}

int ADAMO_Shell::coutab(FLSDIGIPLN_DEF* /* nr */) {
  int* nnr=&flsdigipln_.flsdigipln;  return coutab_(nnr);
}

FLSDIGIPLN_DEF* ADAMO_Shell::gettab(FLSDIGIPLN_DEF* /* nnr */,int id) {
  int* nr=&flsdigipln_.flsdigipln;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLSDIGIPLN_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FLSDigiPln row "
            << id << std::endl;
  return (FLSDIGIPLN_DEF *) 0;
}

int ADAMO_Shell::coutab(FLSDIGIT_DEF* /* nr */) {
  int* nnr=&flsdigit_.flsdigit;  return coutab_(nnr);
}

FLSDIGIT_DEF* ADAMO_Shell::gettab(FLSDIGIT_DEF* /* nnr */,int id) {
  int* nr=&flsdigit_.flsdigit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLSDIGIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FLSDigit row " 
            << id << std::endl;
  return (FLSDIGIT_DEF *) 0;
}

int ADAMO_Shell::coutab(FLSDIGIVIEW_DEF* /* nr */) {
  int* nnr=&flsdigiview_.flsdigiview;  return coutab_(nnr);
}

FLSDIGIVIEW_DEF* ADAMO_Shell::gettab(FLSDIGIVIEW_DEF* /* nnr */,int id) {
  int* nr=&flsdigiview_.flsdigiview;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLSDIGIVIEW_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FLSDigiView row "
            << id << std::endl;
  return (FLSDIGIVIEW_DEF *) 0;
}

int ADAMO_Shell::coutab(FLSHIT_DEF* /* nr */) {
  int* nnr=&flshit_.flshit;  return coutab_(nnr);
}

FLSHIT_DEF* ADAMO_Shell::gettab(FLSHIT_DEF* /* nnr */,int id) {
  int* nr=&flshit_.flshit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLSHIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FLSHit row " 
            << id << std::endl;
  return (FLSHIT_DEF *) 0;
}

int ADAMO_Shell::coutab(FLUXINFO_DEF* /* nr */) {
  int* nnr=&fluxinfo_.fluxinfo;  return coutab_(nnr);
}

FLUXINFO_DEF* ADAMO_Shell::gettab(FLUXINFO_DEF* /* nnr */,int id) {
  int* nr=&fluxinfo_.fluxinfo;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLUXINFO_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FluxInfo row " 
            << id << std::endl;
  return (FLUXINFO_DEF *) 0;
}

int ADAMO_Shell::coutab(FLUXWGT_DEF* /* nr */) {
  int* nnr=&fluxwgt_.fluxwgt;  return coutab_(nnr);
}

FLUXWGT_DEF* ADAMO_Shell::gettab(FLUXWGT_DEF* /* nnr */,int id) {
  int* nr=&fluxwgt_.fluxwgt;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLUXWGT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FluxWgt row " 
            << id << std::endl;
  return (FLUXWGT_DEF *) 0;
}

int ADAMO_Shell::coutab(HITPLN_DEF* /* nr */) {
  int* nnr=&hitpln_.hitpln;  return coutab_(nnr);
}

HITPLN_DEF* ADAMO_Shell::gettab(HITPLN_DEF* /* nnr */,int id) {
  int* nr=&hitpln_.hitpln;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (HITPLN_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find HitPln row " 
            << id << std::endl;
  return (HITPLN_DEF *) 0;
}

int ADAMO_Shell::coutab(LSTHIT_DEF* /* nr */) {
  int* nnr=&lsthit_.lsthit;  return coutab_(nnr);
}

LSTHIT_DEF* ADAMO_Shell::gettab(LSTHIT_DEF* /* nnr */,int id) {
  int* nr=&lsthit_.lsthit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (LSTHIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find LSTHit row " 
            << id << std::endl;
  return (LSTHIT_DEF *) 0;
}

int ADAMO_Shell::coutab(LSTPROTO_DEF* /* nr */) {
  int* nnr=&lstproto_.lstproto;  return coutab_(nnr);
}

LSTPROTO_DEF* ADAMO_Shell::gettab(LSTPROTO_DEF* /* nnr */,int id) {
  int* nr=&lstproto_.lstproto;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (LSTPROTO_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find LSTProto row " 
            << id << std::endl;
  return (LSTPROTO_DEF *) 0;
}

int ADAMO_Shell::coutab(LSTSTRIP_DEF* /* nr */) {
  int* nnr=&lststrip_.lststrip;  return coutab_(nnr);
}

LSTSTRIP_DEF* ADAMO_Shell::gettab(LSTSTRIP_DEF* /* nnr */,int id) {
  int* nr=&lststrip_.lststrip;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (LSTSTRIP_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find LSTStrip row " 
            << id << std::endl;
  return (LSTSTRIP_DEF *) 0;
}

int ADAMO_Shell::coutab(LSTWIRE_DEF* /*  nr */) {
  int* nnr=&lstwire_.lstwire;  return coutab_(nnr);
}

LSTWIRE_DEF* ADAMO_Shell::gettab(LSTWIRE_DEF* /* nnr */,int id) {
  int* nr=&lstwire_.lstwire;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (LSTWIRE_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find LSTWire row " 
            << id << std::endl;
  return (LSTWIRE_DEF *) 0;
}

int ADAMO_Shell::coutab(MUONTRKHEADER_DEF* /* nr */) {
  int* nnr=&muontrkheader_.muontrkheader;  return coutab_(nnr);
}

MUONTRKHEADER_DEF* ADAMO_Shell::gettab(MUONTRKHEADER_DEF* /* nnr */,int id) {
  int* nr=&muontrkheader_.muontrkheader;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (MUONTRKHEADER_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find MuonTrkHeader row "
            << id << std::endl;
  return (MUONTRKHEADER_DEF *) 0;
}

int ADAMO_Shell::coutab(MUONTRKPOINT_DEF* /* nr */) {
  int* nnr=&muontrkpoint_.muontrkpoint;  return coutab_(nnr);
}

MUONTRKPOINT_DEF* ADAMO_Shell::gettab(MUONTRKPOINT_DEF* /* nnr */,int id) {
  int* nr=&muontrkpoint_.muontrkpoint;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (MUONTRKPOINT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find MuonTrkPoint row "
            << id << std::endl;
  return (MUONTRKPOINT_DEF *) 0;
}

int ADAMO_Shell::coutab(NEUKIN_DEF* /* nr */) {
  int* nnr=&neukin_.neukin;  return coutab_(nnr);
}

NEUKIN_DEF* ADAMO_Shell::gettab(NEUKIN_DEF* /* nnr */,int id) {
  int* nr=&neukin_.neukin;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (NEUKIN_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find NeuKin row " 
            << id << std::endl;
  return (NEUKIN_DEF *) 0;
}

int ADAMO_Shell::coutab(NEUVTX_DEF* /* nr */) {
  int* nnr=&neuvtx_.neuvtx;  return coutab_(nnr);
}

NEUVTX_DEF* ADAMO_Shell::gettab(NEUVTX_DEF* /* nnr */,int id) {
  int* nr=&neuvtx_.neuvtx;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (NEUVTX_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find NeuVtx row " 
            << id << std::endl;
  return (NEUVTX_DEF *) 0;
}

int ADAMO_Shell::coutab(PEARRIVAL_DEF* /*  nr */) {
  int* nnr=&pearrival_.pearrival;  return coutab_(nnr);
}

PEARRIVAL_DEF* ADAMO_Shell::gettab(PEARRIVAL_DEF* /* nnr */,int id) {
  int* nr=&pearrival_.pearrival;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (PEARRIVAL_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find PEArrival row " 
            << id << std::endl;
  return (PEARRIVAL_DEF *) 0;
}

int ADAMO_Shell::coutab(RECOMUON_DEF* /* nr */) {
  int* nnr=&recomuon_.recomuon;  return coutab_(nnr);
}

RECOMUON_DEF* ADAMO_Shell::gettab(RECOMUON_DEF* /* nnr */,int id) {
  int* nr=&recomuon_.recomuon;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (RECOMUON_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find RecoMuon row " 
            << id << std::endl;
  return (RECOMUON_DEF *) 0;
}

int ADAMO_Shell::coutab(RECOSHWDIR_DEF* /* nr */) {
  int* nnr=&recoshwdir_.recoshwdir;  return coutab_(nnr);
}

RECOSHWDIR_DEF* ADAMO_Shell::gettab(RECOSHWDIR_DEF* /* nnr */,int id) {
  int* nr=&recoshwdir_.recoshwdir;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (RECOSHWDIR_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find RecoShwDir row " 
            << id << std::endl;
  return (RECOSHWDIR_DEF *) 0;
}

int ADAMO_Shell::coutab(RECOSHWENERGY_DEF* /* nr */) {
  int* nnr=&recoshwenergy_.recoshwenergy;  return coutab_(nnr);
}

RECOSHWENERGY_DEF* ADAMO_Shell::gettab(RECOSHWENERGY_DEF* /* nnr */,int id) {
  int* nr=&recoshwenergy_.recoshwenergy;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (RECOSHWENERGY_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find RecoShwEnergy row "
            << id << std::endl;
  return (RECOSHWENERGY_DEF *) 0;
}

int ADAMO_Shell::coutab(RECOVTX_DEF* /* nr */) {
  int* nnr=&recovtx_.recovtx;  return coutab_(nnr);
}

RECOVTX_DEF* ADAMO_Shell::gettab(RECOVTX_DEF* /* nnr */,int id) {
  int* nr=&recovtx_.recovtx;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (RECOVTX_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find RecoVtx row " 
            << id << std::endl;
  return (RECOVTX_DEF *) 0;
}

int ADAMO_Shell::coutab(RPCHIT_DEF* /* nr */) {
  int* nnr=&rpchit_.rpchit;  return coutab_(nnr);
}

RPCHIT_DEF* ADAMO_Shell::gettab(RPCHIT_DEF* /* nnr */,int id) {
  int* nr=&rpchit_.rpchit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (RPCHIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find RPCHit row " 
            << id << std::endl;
  return (RPCHIT_DEF *) 0;
}

int ADAMO_Shell::coutab(STDHEP_DEF* /* nr */) {
  int* nnr=&stdhep_.stdhep;  return coutab_(nnr);
}

STDHEP_DEF* ADAMO_Shell::gettab(STDHEP_DEF* /* nnr */,int id) {
  int* nr=&stdhep_.stdhep;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (STDHEP_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find StdHep row " 
            << id << std::endl;
  return (STDHEP_DEF *) 0;
}

int ADAMO_Shell::coutab(STDHEPHEAD_DEF* /* nr */) {
  int* nnr=&stdhephead_.stdhephead;  return coutab_(nnr);
}

STDHEPHEAD_DEF* ADAMO_Shell::gettab(STDHEPHEAD_DEF* /* nnr */,int id) {
  int* nr=&stdhephead_.stdhephead;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (STDHEPHEAD_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find StdHepHead row "
            << id << std::endl;
  return (STDHEPHEAD_DEF *) 0;
}

int ADAMO_Shell::coutab(TSTHIT_DEF* /* nr */) {
  int* nnr=&tsthit_.tsthit;  return coutab_(nnr);
}

TSTHIT_DEF* ADAMO_Shell::gettab(TSTHIT_DEF* /* nnr */,int id) {
  int* nr=&tsthit_.tsthit;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (TSTHIT_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find TstHit row " 
            << id << std::endl;
  return (TSTHIT_DEF *) 0;
}

int ADAMO_Shell::coutab(AVAILNUCLEI_DEF* /* nr */) {
  int* nnr=&availnuclei_.availnuclei;  return coutab_(nnr);
}

AVAILNUCLEI_DEF* ADAMO_Shell::gettab(AVAILNUCLEI_DEF* /* nnr */,int id) {
  int* nr=&availnuclei_.availnuclei;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (AVAILNUCLEI_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find AvailNuclei row "
            << id << std::endl;
  return (AVAILNUCLEI_DEF *) 0;
}

int ADAMO_Shell::coutab(BEAMSYSTEM_DEF* /* nr */) {
  int* nnr=&beamsystem_.beamsystem;  return coutab_(nnr);
}

BEAMSYSTEM_DEF* ADAMO_Shell::gettab(BEAMSYSTEM_DEF* /* nnr */,int id) {
  int* nr=&beamsystem_.beamsystem;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (BEAMSYSTEM_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find BeamSystem row "
            << id << std::endl;
  return (BEAMSYSTEM_DEF *) 0;
}

int ADAMO_Shell::coutab(CELLPOS_DEF* /* nr */) {
  int* nnr=&cellpos_.cellpos;  return coutab_(nnr);
}

CELLPOS_DEF* ADAMO_Shell::gettab(CELLPOS_DEF* /* nnr */,int id) {
  int* nr=&cellpos_.cellpos;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (CELLPOS_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find CellPos row " 
            << id << std::endl;
  return (CELLPOS_DEF *) 0;
}

int ADAMO_Shell::coutab(COILTUBE_DEF* /* nr */) {
  int* nnr=&coiltube_.coiltube;  return coutab_(nnr);
}

COILTUBE_DEF* ADAMO_Shell::gettab(COILTUBE_DEF* /* nnr */,int id) {
  int* nr=&coiltube_.coiltube;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (COILTUBE_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find CoilTube row " 
            << id << std::endl;
  return (COILTUBE_DEF *) 0;
}

int ADAMO_Shell::coutab(FLSPARAM_DEF* /* nr */) {
  int* nnr=&flsparam_.flsparam;  return coutab_(nnr);
}

FLSPARAM_DEF* ADAMO_Shell::gettab(FLSPARAM_DEF* /* nnr */,int id) {
  int* nr=&flsparam_.flsparam;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (FLSPARAM_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find FLSParam row " 
            << id << std::endl;
  return (FLSPARAM_DEF *) 0;
}

int ADAMO_Shell::coutab(GEOMMISC_DEF* /* nr */) {
  int* nnr=&geommisc_.geommisc;  return coutab_(nnr);
}

GEOMMISC_DEF* ADAMO_Shell::gettab(GEOMMISC_DEF* /* nnr */,int id) {
  int* nr=&geommisc_.geommisc;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (GEOMMISC_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find GeomMisc row " 
            << id << std::endl;
  return (GEOMMISC_DEF *) 0;
}

int ADAMO_Shell::coutab(MASSDISTRIB_DEF* /* nr */) {
  int* nnr=&massdistrib_.massdistrib;  return coutab_(nnr);
}

MASSDISTRIB_DEF* ADAMO_Shell::gettab(MASSDISTRIB_DEF* /* nnr */,int id) {
  int* nr=&massdistrib_.massdistrib;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (MASSDISTRIB_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find MassDistrib row "
            << id << std::endl;
  return (MASSDISTRIB_DEF *) 0;
}

int ADAMO_Shell::coutab(MATERIAL_DEF* /* nr */) {
  int* nnr=&material_.material;  return coutab_(nnr);
}

MATERIAL_DEF* ADAMO_Shell::gettab(MATERIAL_DEF* /* nnr */,int id) {
  int* nr=&material_.material;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (MATERIAL_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find Material row " 
            << id << std::endl;
  return (MATERIAL_DEF *) 0;
}

int ADAMO_Shell::coutab(MDLORG_DEF* /* nr */) {
  int* nnr=&mdlorg_.mdlorg;  return coutab_(nnr);
}

MDLORG_DEF* ADAMO_Shell::gettab(MDLORG_DEF* /* nnr */,int id) {
  int* nr=&mdlorg_.mdlorg;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (MDLORG_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find MdlOrg row " 
            << id << std::endl;
  return (MDLORG_DEF *) 0;
}

int ADAMO_Shell::coutab(MIXTURE_DEF* /* nr */) {
  int* nnr=&mixture_.mixture;  return coutab_(nnr);
}

MIXTURE_DEF* ADAMO_Shell::gettab(MIXTURE_DEF* /* nnr */,int id) {
  int* nr=&mixture_.mixture;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (MIXTURE_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find Mixture row " 
            << id << std::endl;
  return (MIXTURE_DEF *) 0;
}

int ADAMO_Shell::coutab(PLANEPOS_DEF* /* nr */) {
  int* nnr=&planepos_.planepos;  return coutab_(nnr);
}

PLANEPOS_DEF* ADAMO_Shell::gettab(PLANEPOS_DEF* /* nnr */,int id) {
  int* nr=&planepos_.planepos;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (PLANEPOS_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find PlanePos row " 
            << id << std::endl;
  return (PLANEPOS_DEF *) 0;
}

int ADAMO_Shell::coutab(PLANESPEC_DEF* /* nr */) {
  int* nnr=&planespec_.planespec;  return coutab_(nnr);
}

PLANESPEC_DEF* ADAMO_Shell::gettab(PLANESPEC_DEF* /* nnr */,int id) {
  int* nr=&planespec_.planespec;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (PLANESPEC_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find PlaneSpec row " 
            << id << std::endl;
  return (PLANESPEC_DEF *) 0;
}

int ADAMO_Shell::coutab(PLEXUSADD_DEF* /* nr */) {
  int* nnr=&plexusadd_.plexusadd;  return coutab_(nnr);
}

PLEXUSADD_DEF* ADAMO_Shell::gettab(PLEXUSADD_DEF* /* nnr */,int id) {
  int* nr=&plexusadd_.plexusadd;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (PLEXUSADD_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find PlexusAdd row " 
            << id << std::endl;
  return (PLEXUSADD_DEF *) 0;
}

int ADAMO_Shell::coutab(PLN2MUX_DEF* /* nr */) {
  int* nnr=&pln2mux_.pln2mux;  return coutab_(nnr);
}

PLN2MUX_DEF* ADAMO_Shell::gettab(PLN2MUX_DEF* /* nnr */,int id) {
  int* nr=&pln2mux_.pln2mux;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (PLN2MUX_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find Pln2MUX row " 
            << id << std::endl;
  return (PLN2MUX_DEF *) 0;
}

int ADAMO_Shell::coutab(ROTM_DEF* /* nr */) {
  int* nnr=&rotm_.rotm;  return coutab_(nnr);
}

ROTM_DEF* ADAMO_Shell::gettab(ROTM_DEF* /* nnr */,int id) {
  int* nr=&rotm_.rotm;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (ROTM_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find Rotm row " 
            << id << std::endl;
  return (ROTM_DEF *) 0;
}

int ADAMO_Shell::coutab(SUBVOLPOS_DEF* /* nr */) {
  int* nnr=&subvolpos_.subvolpos;  return coutab_(nnr);
}

SUBVOLPOS_DEF* ADAMO_Shell::gettab(SUBVOLPOS_DEF* /* nnr */,int id) {
  int* nr=&subvolpos_.subvolpos;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (SUBVOLPOS_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find SubVolPos row " 
            << id << std::endl;
  return (SUBVOLPOS_DEF *) 0;
}

int ADAMO_Shell::coutab(SUBVOLSPEC_DEF* /* nr */) {
  int* nnr=&subvolspec_.subvolspec;  return coutab_(nnr);
}

SUBVOLSPEC_DEF* ADAMO_Shell::gettab(SUBVOLSPEC_DEF* /* nnr */,int id) {
  int* nr=&subvolspec_.subvolspec;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (SUBVOLSPEC_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find SubVolSpec row "
            << id << std::endl;
  return (SUBVOLSPEC_DEF *) 0;
}

int ADAMO_Shell::coutab(SUPERMODULE_DEF* /* nr */) {
  int* nnr=&supermodule_.supermodule;  return coutab_(nnr);
}

SUPERMODULE_DEF* ADAMO_Shell::gettab(SUPERMODULE_DEF* /* nnr */,int id) {
  int* nr=&supermodule_.supermodule;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (SUPERMODULE_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find SuperModule row "
            << id << std::endl;
  return (SUPERMODULE_DEF *) 0;
}

int ADAMO_Shell::coutab(TMEDIUM_DEF* /* nr */) {
  int* nnr=&tmedium_.tmedium;  return coutab_(nnr);
}

TMEDIUM_DEF* ADAMO_Shell::gettab(TMEDIUM_DEF* /* nnr */,int id) {
  int* nr=&tmedium_.tmedium;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (TMEDIUM_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find TMedium row " 
            << id << std::endl;
  return (TMEDIUM_DEF *) 0;
}

int ADAMO_Shell::coutab(TPAR_DEF* /* nr */) {
  int* nnr=&tpar_.tpar;  return coutab_(nnr);
}

TPAR_DEF* ADAMO_Shell::gettab(TPAR_DEF* /* nnr */,int id) {
  int* nr=&tpar_.tpar;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (TPAR_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find TPar row " 
            << id << std::endl;
  return (TPAR_DEF *) 0;
}

int ADAMO_Shell::coutab(TUBEPIXELINFO_DEF* /* nr */) {
  int* nnr=&tubepixelinfo_.tubepixelinfo;  return coutab_(nnr);
}

TUBEPIXELINFO_DEF* ADAMO_Shell::gettab(TUBEPIXELINFO_DEF* /* nnr */,int id) {
  int* nr=&tubepixelinfo_.tubepixelinfo;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (TUBEPIXELINFO_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find TubePixelInfo row " 
            << id << std::endl;
  return (TUBEPIXELINFO_DEF *) 0;
}

int ADAMO_Shell::coutab(TUBEPIXELMAP_DEF* /* nr */) {
  int* nnr=&tubepixelmap_.tubepixelmap;  return coutab_(nnr);
}

TUBEPIXELMAP_DEF* ADAMO_Shell::gettab(TUBEPIXELMAP_DEF* /* nnr */,int id) {
  int* nr=&tubepixelmap_.tubepixelmap;  fettab_(nr,&ID,&id);
  if (beltab_(nr)) return (TUBEPIXELMAP_DEF *) nr;
  std::cout << "ADAMO_Shell:  ADAMO can't find TubePixelMap row "
            << id << std::endl;
  return (TUBEPIXELMAP_DEF *) 0;
}

int ADAMO_Shell::coutab(GAFKEY_DEF* /* nr */) {
//int* nnr=&gafkey_.gafkey;  return coutab_(nnr);       // GAFKey kludge
  return 1;                                             // GAFKey kludge
}

GAFKEY_DEF* ADAMO_Shell::gettab(GAFKEY_DEF* /* nnr */,int id) {
  int* nr=&gafkey_.gafkey;  gafkey_.ID=id;
  if (id==1) {                                          // GAFKey kludge
//      gettab_(nr);                                    // GAFKey kludge
        return (GAFKEY_DEF *) nr;
  }
  std::cout << "ADAMO_Shell:  ADAMO can't find GAFKey row " 
            << id << std::endl;
  return (GAFKEY_DEF *) 0;
}

---