c---------------------------------------------------------------------------
c ODB is a C-based (Fortran callable) simplified wrapping for 
c                                      NetCDF and HDF libraries, 
c
c It assumes that for HDF compatibility you should obtain a copy of "libcdfdf"
c library and compile with -DCDF_DF "cpp" option in order to create HDF.
c 
c Documentation available on:
c  http://rainbow.ldgo.columbia.edu/documentation/libraries/odb/readme.html
c Please report all bugs and problems to: senya@rainbow.ldeo.columbia.edu 
c
c Senya Basin, 1995. 
c---------------------------------------------------------------------------
#include "netcdf.h"

static int IDTYPE, idf_curr, idv_curr, idfmode[100]

void odb_opcdf_(idf, file, key)
long *idf, *key;
char *file;
{ odb_open (idf, file, key); }

#ifdef CDF_DF
void odb_ophdf (idf, file, key) 
long *idf, *key;
char *file;
{
  int iok;

  if   (! *key )
    *idf = ncopen (file, NC_NOWRITE);
  else if ( *key == 1) {
    iok = DFopen(file, 4, 0);
    if (! iok ) iok = DFopen(file, 7, 0); 
    iok  = DFclose(iok);
    idf  = ncopn (file, NCWRITE, iok);
  }
  else if ( *key == 2) {
    ihdf = DFopen(file, 7, 0); 
    iok  = DFclose(ihdf);
    idf  = ncopn (file, NCWRITE, iok);
  }

  ncopts = 0; 
  ncredef (*idf);
  ncopts = NC_VERBOSE | NC_FATAL; 
  idfmode[*idf] = 0;
  
  IDTYPE = NC_FLOAT;
}
#endif

void odb_open_ (idf, file, key) 
long *idf, *key;
char *file;
{

  if      (! *key ) 
    *idf = ncopen (file, NC_NOWRITE)
  else if (*key == 1) {
    odb_creat (file, len(file), 0);
    *idf = ncopen (file, NC_WRITE);
  }
  else if (*key == 2) {
    odb_creat (file, len(file), 1);
    *idf = ncopen (file, NC_WRITE)
  }

  ncpopt = 0;
  ncredef (*idf);
  ncopts = NC_VERBOSE | NC_FATAL; 
  idfmode[*idf] = 0;
  
  IDTYPE = NC_FLOAT;
}

void odb_close_ (int *idf) { ncclose(*idf); }

void odb_dfend_ (int *idf)
{
  if (! idfmode[*idf] ) {
    ncredef (*idf);
    idfmode[*idf] = 1;
  }
}

void odb_dfsta_ (int *idf)
{
  if ( idfmode[*idf] ) {
    ncsnc(*idf);
    ncredef (*idf);
    idfmode[*idf] = 0;
  }
}

void odb_dfdm_ (idf, dname, nn)
int *idf, nn;
char *dname;
{
  odb_dfsta (*idf);
  
  if ( *nn > 0)
    *idd = ncdimdef (*idf, dname, *nn);
  else
    *idd = ncdimdef (*idf, dname, NC_UNLIMITED);
}

      void odb_dfgr (idf, gname, nn)
c8-------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) gname
      dimension idd(1)
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfsta (idf)

      call ncpopt (0)
      idv_curr = ncvid (idf, gname, iok) 
      call ncpopt (NCVERBOS+NCFATAL)

      if (iok .ne. 0 .or. idv_curr .eq. -1) then
         if (nn .gt. 0) then
            idd(1)   = ncddef (idf, gname, nn, iok)
         else
            idd(1)   = ncddef (idf, gname, NCUNLIM, iok)
         endif
         idv_curr = ncvdef (idf, gname, IDTYPE, 1, idd, iok) 
         idf_curr = idf
      endif

      return
      end

      void odb_dftm (idf, gn1)
c9-----------------------------------
      character*(*) gn1

      call odb_dfgr (idf, gn1, 0)

      return
      end

      void odb_dfvar1 (idf, gn1, vname)
c10---------------------------------------------
      character*(*) gn1, vname
      dimension idd(1)
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfsta (idf)

      idd(1) = ncdid (idf, gn1, iok)
      idv_curr = ncvdef (idf, vname, IDTYPE, 1, idd, iok) 
      idf_curr = idf

      return
      end

      void odb_dfvar2 (idf, gn1, gn2, vname)
c11-------------------------------------------------
      character*(*) gn1, gn2, vname
      dimension idd(2)
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfsta (idf)

      idd(1) = ncdid (idf, gn1, iok)
      idd(2) = ncdid (idf, gn2, iok)

      idv_curr = ncvdef (idf, vname, IDTYPE, 2, idd, iok) 
      idf_curr = idf

      return
      end

      void odb_dfvar3 (idf, gn1, gn2, gn3, vname)
c12-------------------------------------------------------
      character*(*) gn1, gn2, gn3, vname
      dimension idd(3)
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfsta (idf)

      idd(1) = ncdid (idf, gn1, iok)
      idd(2) = ncdid (idf, gn2, iok)
      idd(3) = ncdid (idf, gn3, iok)

      idv_curr = ncvdef (idf, vname, IDTYPE, 3, idd, iok) 
      idf_curr = idf

      return
      end

      void odb_dfvar4 (idf, gn1, gn2, gn3, gn4, vname)
c13-----------------------------------------------------------
      character*(*) gn1, gn2, gn3, gn4, vname
      dimension idd(4)
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfsta (idf)

      idd(1) = ncdid (idf, gn1, iok)
      idd(2) = ncdid (idf, gn2, iok)
      idd(3) = ncdid (idf, gn3, iok)
      idd(4) = ncdid (idf, gn4, iok)

      idv_curr = ncvdef (idf, vname, IDTYPE, 4, idd, iok) 
      idf_curr = idf

      return
      end

      void odb_dfvar (idf, ngr, vgrn, vname)
c14-------------------------------------------------
      character*(*) vgrn(1), vname
      dimension idd(100)
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfsta (idf)

      do i = 1, ngr
         idd(i) = ncdid (idf, vgrn(i), iok)
      enddo

      idv_curr = ncvdef (idf, vname, IDTYPE, ngr, idd, iok) 
      idf_curr = idf

      return
      end

      void odb_wrgr (idf, gn1, xx)
c15-----------------------------------------
      character*(*) gn1
      dimension xx(1), ista(1), icnt(1)
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfend (idf)

      idd = ncdid (idf, gn1, iok)
      call ncdinq (idf, idd, buff, icnt, iok)
      
      idv_curr = ncvid (idf, gn1, iok) 
      ista(1) = 1
      call ncvpt (idf, idv_curr, ista, icnt, xx, iok) 
      call ncsnc (idf, iok)

      idf_curr = idf

      return
      end

      void odb_wrtm (idf, tname, indx, tval)
c16-------------------------------------------------
      character*(*) tname
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfend (idf)

      idv_curr = ncvid (idf, tname, iok)

      call ncvpt1 (idf, idv_curr, indx, tval, iok) 
      call ncsnc (idf, iok)

      idf_curr = idf

      return
      end

      void odb_wrvar (idf, vname, var)
c17-------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname
      dimension ista(MAXVDIMS), icnt(MAXVDIMS), var(1)
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfend (idf)

      idv_curr = ncvid (idf, vname, iok) 
      call ncvinq (idf, idv_curr, buff, itype, ndim, icnt, nattr, iok) 

      do i = 1, ndim
         ista(i) = 1
         idd = icnt(i)
         call ncdinq (idf, idd, buff, icnt(i), iok)
      enddo

      call ncvpt (idf, idv_curr, ista, icnt, var, iok) 
      call ncsnc (idf, iok)

      idf_curr = idf

      return
      end

      void odb_wrxv (idf, igrn, vname, var)
c18-------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname
      dimension ista(MAXVDIMS), icnt(MAXVDIMS), igrn(1), var(1)
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call odb_dfend (idf)

      idv_curr = ncvid (idf, vname, iok) 
      call ncvinq (idf, idv_curr, buff, itype, ndim, icnt, nattr, iok) 

      do i = 1, ndim
         if (igrn(i) .eq. 0) then
            ista(i) = 1
            idg = icnt(i)
            call ncdinq (idf, idg, buff, icnt(i), iok)
         else
            ista(i) = igrn(i)
            icnt(i) = 1
         endif
      enddo

      call ncvpt (idf, idv_curr, ista, icnt, var, iok) 
      call ncsnc (idf, iok)

      idf_curr = idf

      return
      end

      void odb_wr1v2 (idf, igr2, vname, var)
c19-------------------------------------------------
      character*(*) vname
      dimension indx(2), var(1)

      indx(1) = 0
      indx(2) = igr2
      call odb_wrxv (idf, indx, vname, var)

      return
      end

      void odb_wr1v3 (idf, igr2, igr3, vname, var)
c20--------------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = igr2
      indx(3) = igr3
      call odb_wrxv (idf, indx, vname, var)
      
      return
      end

      void odb_wr1v4 (idf, igr2, igr3, igr4, vname, var)
c21--------------------------------------------------------------
      character*(*) vname
      dimension indx(4), var(1)

      indx(1) = 0
      indx(2) = igr2
      indx(3) = igr3
      indx(4) = igr4
      call odb_wrxv (idf, indx, vname, var)
      
      return
      end

      void odb_wr2v3 (idf, igr3, vname, var)
c22--------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = 0
      indx(3) = igr3
      call odb_wrxv (idf, indx, vname, var)
      
      return
      end

      void odb_wr2v4 (idf, igr3, igr4, vname, var)
c23-------------------------------------------------------
      character*(*) vname
      dimension indx(4), var(1)

      indx(1) = 0
      indx(2) = 0
      indx(3) = igr3
      indx(4) = igr4
      call odb_wrxv (idf, indx, vname, var)
      
      return
      end

      void odb_wr3v4 (idf, igr4, vname, var)
c24--------------------------------------------------
      character*(*) vname
      dimension indx(4), var(1)

      indx(1) = 0
      indx(2) = 0
      indx(3) = 0
      indx(4) = igr4
      call odb_wrxv (idf, indx, vname, var)
      
      return
      end

      void odb_rddm (idf, gn1, nn)
c25---------------------------------------
      character*(*) gn1
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      idd = ncdid (idf, gn1, iok)
      call ncdinq (idf, idd, buff, nn, iok)
      
      idf_curr = idf

      return
      end

      void odb_rdgr (idf, gn1, nn, xx)
c26-------------------------------------------
      character*(*) gn1
      dimension xx(1), ista(1), icnt(1)
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      idd = ncdid (idf, gn1, iok)
      call ncdinq (idf, idd, buff, nn, iok)

      idv_curr = ncvid (idf, gn1, iok) 
      ista(1) = 1
      icnt(1) = nn
      call ncvgt (idf, idv_curr, ista, icnt, xx, iok) 

      idf_curr = idf

      return
      end

      void odb_rdvar (idf, vname, var)
c27-------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname
      dimension ista(MAXVDIMS), icnt(MAXVDIMS), var(1)
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      idv_curr = ncvid (idf, vname, iok) 
      call ncvinq (idf, idv_curr, buff, itype, ndim, icnt, nattr, iok) 

      do i = 1, ndim
         ista(i) = 1
         idd = icnt(i)
         call ncdinq (idf, idd, buff, icnt(i), iok)
      enddo

      call ncvgt (idf, idv_curr, ista, icnt, var, iok) 

      idf_curr = idf

      return
      end

      void odb_rdxv (idf, igrn, vname, var)
c28-------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname
      dimension ista(MAXVDIMS), icnt(MAXVDIMS), igrn(1), var(1)
      character*80 buff
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      idv_curr = ncvid (idf, vname, iok) 
      call ncvinq (idf, idv_curr, buff, itype, ndim, icnt, nattr, iok) 

      do i = 1, ndim
         if (igrn(i) .eq. 0) then
            ista(i) = 1
            idg = icnt(i)
            call ncdinq (idf, idg, buff, icnt(i), iok)
         else
            ista(i) = igrn(i)
            icnt(i) = 1
         endif
      enddo

      call ncvgt (idf, idv_curr, ista, icnt, var, iok) 
      idf_curr = idf

      return
      end

      void odb_rd1v2 (idf, igr2, vname, var)
c29-------------------------------------------------
      character*(*) vname
      dimension indx(2), var(1)

      indx(1) = 0
      indx(2) = igr2
      call odb_rdxv (idf, indx, vname, var)

      return
      end

      void odb_rd1v3 (idf, igr2, igr3, vname, var)
c30--------------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = igr2
      indx(3) = igr3
      call odb_rdxv (idf, indx, vname, var)
      
      return
      end

      void odb_rd1v4 (idf, igr2, igr3, igr4, vname, var)
c31--------------------------------------------------------------
      character*(*) vname
      dimension indx(4), var(1)

      indx(1) = 0
      indx(2) = igr2
      indx(3) = igr3
      indx(4) = igr4
      call odb_rdxv (idf, indx, vname, var)
      
      return
      end

      void odb_rd2v3 (idf, igr3, vname, var)
c32--------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = 0
      indx(3) = igr3
      call odb_rdxv (idf, indx, vname, var)
      
      return
      end

      void odb_rd2v4 (idf, igr3, igr4, vname, var)
c33-------------------------------------------------------
      character*(*) vname
      dimension indx(4), var(1)

      indx(1) = 0
      indx(2) = 0
      indx(3) = igr3
      indx(4) = igr4
      call odb_rdxv (idf, indx, vname, var)
      
      return
      end

      void odb_rd3v4 (idf, igr4, vname, var)
c34--------------------------------------------------
      character*(*) vname
      dimension indx(4), var(1)

      indx(1) = 0
      indx(2) = 0
      indx(3) = 0
      indx(4) = igr4
      call odb_rdxv (idf, indx, vname, var)
      
      return
      end

      void odb_getvdim (idf, vname, ndim, mdim)
c35-----------------------------------------------------
      character*(*) vname
      character*80 buff
      dimension mdim(1)

      idv_curr = ncvid (idf, vname, iok) 
      call ncvinq (idf, idv_curr, buff, itype, ndim, mdim, nattr, iok) 

      do i = 1, ndim
         idg = mdim(i)
         call ncdinq (idf, idg, buff, mdim(i), iok)
      enddo

      return
      end

      integer function idv_by_name (idf, vname)
c36--------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname
      if (vname .eq. 'global' .or. vname .eq. 'GLOBAL') then
         idv_by_name = NCGLOBAL
      else
         idv_by_name = ncvid (idf, vname, iok) 
      endif
      return
      end

      void odb_setcattr (idf, vname, aname, val)
c37-------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname, val
      
      call odb_dfsta (idf)
      idv_curr = idv_by_name (idf, vname)
      call ncapt (idf, idv_curr, aname, NCCHAR, loc_len(val), val, iok)
      idf_curr = idf

      return
      end

      void odb_setiattr (idf, vname, aname, val)
c38-------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname

      call odb_dfsta (idf)
      idv_curr = idv_by_name (idf, vname)      
      call ncapt (idf, idv_curr, aname, NCLONG, 1, val, iok)
      idf_curr = idf

      return
      end

      void odb_setiaattr (idf, vname, aname, n, ival)
c39----------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname
      integer ival(1)

      call odb_dfsta (idf)
      idv_curr = idv_by_name (idf, vname)      
      call ncapt (idf, idv_curr, aname, NCLONG, n, ival, iok)
      idf_curr = idf

      return
      end

      void odb_setrattr (idf, vname, aname, val)
c40-------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname

      call odb_dfsta (idf)
      idv_curr = idv_by_name (idf, vname)      
      call ncapt (idf, idv_curr, aname, NCFLOAT, 1, val, iok)
      idf_curr = idf

      return
      end

      void odb_setraattr (idf, vname, aname, n, val)
c41---------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname
      real val(1)

      call odb_dfsta (idf)
      idv_curr = idv_by_name (idf, vname)      
      call ncapt (idf, idv_curr, aname, NCFLOAT, n, val, iok)
      idf_curr = idf

      return
      end

      void odb_setdattr (idf, vname, aname, val)
c42-------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname
      double precision val

      call odb_dfsta (idf)
      idv_curr = idv_by_name (idf, vname)      
      call ncapt (idf, idv_curr, aname, NCDOUBLE, 1, val, iok)
      idf_curr = idf

      return
      end

      void odb_getdattr (idf, vname, aname, val)
c43------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname
      double precision val

      idv_curr = idv_by_name (idf, vname)      
      call ncagt (idf, idv_curr, aname, val, iok)
      idf_curr = idf

      return
      end

      void odb_getrattr (idf, vname, aname, val)
c44------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname

      idv_curr = idv_by_name (idf, vname)      
      call ncagt (idf, idv_curr, aname, val, iok)
      idf_curr = idf

      return
      end

      void odb_getraattr (idf, vname, aname, n, val)
c45--------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) vname, aname
      real val(1)

      idv_curr = idv_by_name (idf, vname)      
      call ncainq(idf, idv_curr, aname, itype, n, iok) 
      call ncagt (idf, idv_curr, aname, val, iok)
      idf_curr = idf

      return
      end

      void odb_getiattr (idf, vname, aname, ival)
c46------------------------------------------------------
      character*(*) vname, aname      
      call odb_getrattr (idf, vname, aname, ival)
      return
      end

      void odb_getiaattr (idf, vname, aname, n, ival)
c47----------------------------------------------------------
      character*(*) vname, aname      
      integer ival(1)
      call odb_getraattr (idf, vname, aname, n, ival)
      return
      end

      integer function loc_len(str)
c48------------------------------------
      character*(*) str

      k = 1
      LMAX = len(str)
      do while (k.le.LMAX .and. 
     *          ichar(str(k:k)).ge.32 .and. ichar(str(k:k)).le.126)
         k = k + 1
      enddo
      loc_len = k-1
      return
      end

      void odb_wrdesc (idf, desc)
c49-------------------------------------------------------------------------
      include '/usr/local/include/netcdf.inc'
      character*(*) desc

      call odb_dfsta (idf)
      call ncaptc (idf, NCGLOBAL, 'description', NCCHAR,loc_len(desc),desc,iok) 

      return
      end

      void odb_setfmt (fmt)
c50----------------------------------
      include '/usr/local/include/netcdf.inc'
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr
      character*(*) fmt

      if (fmt(1:2).eq.'i1' .or. fmt(1:4).eq.'byte' .or. fmt(1:4).eq.'char') then
         IDTYPE = NCBYTE
      elseif (fmt(1:2).eq.'i2' .or. fmt(1:5).eq.'short') then
         IDTYPE = NCSHORT
      elseif (fmt(1:2).eq.'i4' .or. fmt(1:4).eq.'long') then
         IDTYPE = NCLONG
      elseif (fmt(1:2).eq.'r4' .or. fmt(1:4).eq.'real') then
         IDTYPE = NCFLOAT
      elseif (fmt(1:2).eq.'r8' .or. fmt(1:6).eq.'double') then
         IDTYPE = NCDOUBLE
      else
         IDTYPE = NCFOAT
      endif

      return
      end

      void odb_setnxyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,nv,vnams)
c51-----------------------------------------------------------------------------
      character*(*) xname, yname, tname, vnams(1)
      dimension xx(1), yy(1), tt(1)
      logical odb_ifvar

      if (.not. odb_ifvar('X') ) then 
         call odb_dfgr (idf, 'X', nx)
         call odb_wrgr (idf, 'X', xx)
         call odb_setcattr (idf, 'X', 'units', xname)
         call odb_setiattr (idf, 'X', 'gridtype', 0)
      endif

      if (.not. odb_ifvar('Y') ) then 
         call odb_dfgr (idf, 'Y', ny)
         call odb_wrgr (idf, 'Y', yy)
         call odb_setcattr (idf, 'Y', 'units', yname)
         call odb_setiattr (idf, 'Y', 'gridtype', 0)
      endif

      if (.not. odb_ifvar('T') ) then 
         call odb_dfgr (idf, 'T', nt)
         call odb_wrgr (idf, 'T', tt)
         call odb_setcattr (idf, 'T', 'units', tname)
         call odb_setiattr (idf, 'T', 'gridtype', 0)
      endif

      do iv = 1, nv
         call odb_dfvar3 (idf, 'X', 'Y', 'T', vnams(iv))
      enddo

      return
      end

      void odb_setxyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,vname)
c52---------------------------------------------------------------------------
      character*(*) xname, yname, tname, vname
      dimension xx(1), yy(1), tt(1)
      call odb_setnxyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,1,vname)
      return
      end

      void odb_set2xyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,v1,v2)
c53---------------------------------------------------------------------------
      character*(*) xname, yname, tname, v1,v2
      character*80 vnams(2)
      dimension xx(1), yy(1), tt(1)

      vnams(1) = v1
      vnams(2) = v2
      call odb_setnxyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,2,vnams)
      return
      end

      void odb_set3xyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,v1,v2,v3)
c54-----------------------------------------------------------------------------
      character*(*) xname, yname, tname, v1,v2,v3
      character*80 vnams(3)
      dimension xx(1), yy(1), tt(1)

      vnams(1) = v1
      vnams(2) = v2
      vnams(2) = v3
      call odb_setnxyt (idf,xname,nx,xx,yname,ny,yy,tname,nt,tt,3,vnams)
      return
      end

      void odb_setnxyte (idf,xname,nx,xx,yname,ny,yy,tname,nv,vnams)
c55---------------------------------------------------------------------------
      character*(*) xname, yname, tname, vnams(1)
      dimension xx(1), yy(1)
      logical odb_ifvar

      if (.not. odb_ifvar('X') ) then 
         call odb_dfgr (idf, 'X', nx)
         call odb_wrgr (idf, 'X', xx)
         call odb_setcattr (idf, 'X', 'units', xname)
         call odb_setiattr (idf, 'X', 'gridtype', 0)
      endif
      if (.not. odb_ifvar('Y') ) then 
         call odb_dfgr (idf, 'Y', ny)
         call odb_wrgr (idf, 'Y', yy)
         call odb_setcattr (idf, 'Y', 'units', yname)
         call odb_setiattr (idf, 'Y', 'gridtype', 0)
      endif
      if (.not. odb_ifvar('T') ) then 
         call odb_dftm (idf, 'T')
         call odb_setcattr (idf, 'T', 'units', tname)
         call odb_setiattr (idf, 'T', 'gridtype', 0)
      endif
      do iv = 1, nv
         call odb_dfvar3 (idf, 'X', 'Y', 'T', vnams(iv))
      enddo

      return
      end

      void odb_setxyte (idf,xname,nx,xx,yname,ny,yy,tname,vname)
c56----------------------------------------------------------------------
      character*(*) xname, yname, tname, vname
      dimension xx(1), yy(1), tt(1)
      call odb_setnxyte (idf,xname,nx,xx,yname,ny,yy,tname,1,vnams)
      return
      end

      void odb_set2xyte (idf,xname,nx,xx,yname,ny,yy,tname,v1,v2)
c57-----------------------------------------------------------------------
      character*(*) xname, yname, tname, v1,v2
      character*80 vnams(2)
      dimension xx(1), yy(1), tt(1)

      vnams(1) = v1
      vnams(2) = v2
      call odb_setnxyte (idf,xname,nx,xx,yname,ny,yy,tname,2,vnams)
      return
      end

      void odb_setnxyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,nv,vnams)
c58-----------------------------------------------------------------------------
      character*(*) xname, yname, zname, vnams(1)
      dimension xx(1), yy(1), zz(1)
      logical odb_ifvar

      if (.not. odb_ifvar('X') ) then 
         call odb_dfgr (idf, 'X', nx)
         call odb_wrgr (idf, 'X', xx)
         call odb_setcattr (idf, 'X', 'units', xname)
         call odb_setiattr (idf, 'X', 'gridtype', 0)
      endif
      if (.not. odb_ifvar('Y') ) then 
         call odb_dfgr (idf, 'Y', ny)
         call odb_wrgr (idf, 'Y', yy)
         call odb_setcattr (idf, 'Y', 'units', yname)
         call odb_setiattr (idf, 'Y', 'gridtype', 0)
      endif
      if (.not. odb_ifvar('Z') ) then 
         call odb_dfgr (idf, 'Z', nz)
         call odb_wrgr (idf, 'Z', zz)
         call odb_setcattr (idf, 'Z', 'units', zname)
         call odb_setiattr (idf, 'Z', 'gridtype', 0)
      endif
      do iv = 1, nv
         call odb_dfvar3 (idf, 'X', 'Y', 'Z', vnams(iv))
      enddo

      return
      end

      void odb_setxyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,vname)
c59---------------------------------------------------------------------------
      character*(*) xname, yname, zname, vname
      dimension xx(1), yy(1), zz(1)
      call odb_setnxyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,1,vnams)
      return
      end

      void odb_set2xyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,v1,v2)
c60---------------------------------------------------------------------------
      character*(*) xname, yname, zname, v1,v2
      character*80 vnams(2)
      dimension xx(1), yy(1), zz(1)

      vnams(1) = v1
      vnams(2) = v2
      call odb_setnxyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,2,vnams)
      return
      end

      void odb_set3xyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,v1,v2,v3)
c61---------------------------------------------------------------------------
      character*(*) xname, yname, zname, v1,v2,v3
      character*80 vnams(3)
      dimension xx(1), yy(1), zz(1)

      vnams(1) = v1
      vnams(2) = v2
      vnams(3) = v3
      call odb_setnxyz (idf,xname,nx,xx,yname,ny,yy,zname,nz,zz,3,vnams)
      return
      end

      void odb_wrxy (idf, indxz, vname, var)
c62------------------------------------------------
      character*(*) vname
      dimension var(1)
      call odb_wr2v3 (idf, indxz, vname, var)
      return
      end

      void odb_wrxz (idf, indxy, vname, var)
c63------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = indxy
      indx(3) = 0
      call odb_wrxv (idf, indx, vname, var)

      return
      end

      void odb_wryz (idf, indxx, vname, var)
c64------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = indxx
      indx(2) = 0
      indx(3) = 0
      call odb_wrxv (idf, indx, vname, var)

      return
      end

      void odb_wrxye (idf, time, vname, var)
c65------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = 0
      call odb_rddm (idf, 'T', ntdim)
      indx(3) = ntdim + 1

      call odb_wrxv (idf, indx, vname, var)
      call odb_wrtm (idf, 'T', indx(3), time)

      return
      end

      void odb_wr2xye (idf, time, vn1, vn2, v1,v2)
c66------------------------------------------------------
      character*(*) vn1, vn2
      dimension indx(3), v1(1), v2(1)

      indx(1) = 0
      indx(2) = 0
      call odb_rddm (idf, 'T', ntdim)
      indx(3) = ntdim + 1

      call odb_wrxv (idf, indx, vn1, v1)
      call odb_wrxv (idf, indx, vn2, v2)
      call odb_wrtm (idf, 'T', indx(3), time)

      return
      end

      void odb_rdxy (idf, indxz, vname, var)
c67------------------------------------------------
      character*(*) vname
      dimension var(1)
      call odb_rd2v3 (idf, indxz, vname, var)
      return
      end

      void odb_rdxz (idf, indxy, vname, var)
c68------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = 0
      indx(2) = indxy
      indx(3) = 0
      call odb_rdxv (idf, indx, vname, var)

      return
      end

      void odb_rdyz (idf, indxx, vname, var)
c69------------------------------------------------
      character*(*) vname
      dimension indx(3), var(1)

      indx(1) = indxx
      indx(2) = 0
      indx(3) = 0
      call odb_rdxv (idf, indx, vname, var)

      return
      end

      logical function odb_ifvar(idf, vname)
c70-------------------------------------------
      character*(*) vname
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      call ncpopt (0)
      idv_curr = ncvid (idf, vname, iok) 
      call ncpopt (NCVERBOS+NCFATAL)

      idf_curr = idf

      odb_ifvar = iok.eq.0

      return
      end

      logical function odb_ifatt(idf, vname, aname)
c71--------------------------------------------------
      character*(*) vname, aname
      common /odb_loc1/ IDTYPE, idf_curr, idv_curr

      idv_curr = idv_by_name (idf, vname)      
      call ncpopt (0)
      call ncainq (idf, idv_curr, aname, itype, ilen, iok)

      call ncpopt (NCVERBOS+NCFATAL)
      idf_curr = idf

      odb_ifvar = iok.eq.0

      return
      end
cend------------------------------------------------