mod_ncll.f90

Go to the documentation of this file.

!/===========================================================================/
! Copyright (c) 2007, The University of Massachusetts Dartmouth 
! Produced at the School of Marine Science & Technology 
! Marine Ecosystem Dynamics Modeling group
! All rights reserved.
!
! FVCOM has been developed by the joint UMASSD-WHOI research team. For 
! details of authorship and attribution of credit please see the FVCOM
! technical manual or contact the MEDM group.
!
! 
! This file is part of FVCOM. For details, see http://fvcom.smast.umassd.edu 
! The full copyright notice is contained in the file COPYRIGHT located in the 
! root directory of the FVCOM code. This original header must be maintained
! in all distributed versions.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
! AND ANY EXPRESS OR  IMPLIED WARRANTIES, INCLUDING,  BUT NOT  LIMITED TO,
! THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS FOR A PARTICULAR
! PURPOSE ARE DISCLAIMED.  
!
!/---------------------------------------------------------------------------/
! CVS VERSION INFORMATION
! $Id$
! $Name$
! $Revision$
!/===========================================================================/

MODULE mod_ncll ! NETCDF FILE CROSS LINKED LIST
  USE netcdf
  USE mod_time
  USE mod_utils
  USE mod_interp
  IMPLICIT NONE


  INTEGER, PARAMETER :: tmtype_unknown = 0
  INTEGER, PARAMETER :: tmtype_char_date = 1
  INTEGER, PARAMETER :: tmtype_int2_mjd  = 2
  INTEGER, PARAMETER :: tmtype_float_days  = 3
  INTEGER, PARAMETER :: tmtype_float_seconds  = 4



  TYPE ncdim
     INTEGER :: dimid
     CHARACTER(Len=NF90_MAX_NAME+1) :: dimname
     INTEGER :: dim
     LOGICAL :: unlimited
!     LOGICAL :: POINTING    ! To test if two DIM POINTERS go to the same memory
  END TYPE ncdim

  TYPE ncdimp
     TYPE(ncdim), POINTER  :: dim
     TYPE(ncdimp), POINTER :: next
  END TYPE ncdimp

  integer, parameter :: char_max_attlen = 160
  TYPE ncatt
     CHARACTER(Len=NF90_MAX_NAME+1)  attname
     INTEGER    xtype
     INTEGER    len
     INTEGER    attid
     INTEGER,   ALLOCATABLE, DIMENSION(:) :: int
     REAL(spa), ALLOCATABLE, DIMENSION(:) :: flt
     REAL(dp), ALLOCATABLE, DIMENSION(:) :: dbl
     CHARACTER(LEN=char_max_attlen), ALLOCATABLE, DIMENSION(:) :: chr
  END TYPE ncatt
  
  TYPE ncattp
     TYPE(ncatt), POINTER  :: att
     TYPE(ncattp), POINTER :: next
  END TYPE ncattp
  

  ! NCVAR IS THE HEAD NODE FOR THE LIST: DIMS, ATTS
  TYPE ncvar
     LOGICAL connected
     INTEGER, POINTER :: ncid ! THIS IS NEVER ALLOCATED, ONLY ASSOCIATED
     INTEGER varid
     CHARACTER(Len=NF90_MAX_NAME+1) varname
     INTEGER xtype
     ! THE DIMIDS ARE DETERMINED BY WHICH DIMS ARE ASSOCIATED AND IN
     ! WHAT ORDER - THERE IS NO EXPLICIT DIMIDS VARIABLE
!     INTEGER, allocatable :: dimids(:)
     TYPE(ncdimp), POINTER :: dims
     TYPE(ncattp), POINTER :: atts

     ! Data pointers
     INTEGER :: curr_stkcnt
     
     ! THE DATA POINTERS ARE NEVER ALLOCATED, ONLY ASSOCIATED!

     INTEGER, POINTER                        :: scl_int
     INTEGER, POINTER,DIMENSION(:)           :: vec_int
     INTEGER, POINTER,DIMENSION(:,:)         :: arr_int
     INTEGER, POINTER,DIMENSION(:,:,:)       :: cub_int
     INTEGER, POINTER,DIMENSION(:,:,:,:)     :: fda_int

     REAL(spa), POINTER                      :: scl_flt
     REAL(spa), POINTER,DIMENSION(:)         :: vec_flt
     REAL(spa), POINTER,DIMENSION(:,:)       :: arr_flt
     REAL(spa), POINTER,DIMENSION(:,:,:)     :: cub_flt
     REAL(spa), POINTER,DIMENSION(:,:,:,:)   :: fda_flt

     REAL(dp), POINTER                       :: scl_dbl
     REAL(dp), POINTER,DIMENSION(:)          :: vec_dbl
     REAL(dp), POINTER,DIMENSION(:,:)        :: arr_dbl
     REAL(dp), POINTER,DIMENSION(:,:,:)      :: cub_dbl
     REAL(dp), POINTER,DIMENSION(:,:,:,:)    :: fda_dbl

     CHARACTER(LEN=80), POINTER              :: scl_chr
     CHARACTER(LEN=80), POINTER,DIMENSION(:) :: vec_chr
  END TYPE ncvar
  
  TYPE ncvarp
     TYPE(ncvar), POINTER :: var
     TYPE(ncvarp), POINTER :: next
  END TYPE ncvarp
  
  TYPE ncftime
     INTEGER :: tmtype=0
     TYPE(ncvar), POINTER :: tm1
     TYPE(ncvar), POINTER :: tm2

     INTEGER :: stk_len=0

     INTEGER    ::  prev_stkcnt=0
     INTEGER    ::  next_stkcnt=0
     INTEGER    ::  max_stkcnt=0
     TYPE(time) :: prev_io
     TYPE(time) :: next_io  
     REAL(sp)   :: prev_wght=0.0_sp
     REAL(sp)   :: next_wght=0.0_sp
     TYPE(time) :: interval
     CHARACTER(len=80)  :: timezone ="none"

  END TYPE ncftime


  ! NCFILE IS THE FIRST HEAD NODE FOR THE LISTS: DIMS,ATTS,VARS
  TYPE ncfile
     INTEGER, POINTER :: ncid ! EACH VARIABLE NEED TO POINT AT THIS!
     CHARACTER(LEN=160) fname
     LOGICAL writable
     LOGICAL open
     LOGICAL connected
     LOGICAL indefmode
     INTEGER :: unlimdimid
     
     TYPE(ncdimp), POINTER :: dims
     TYPE(ncattp), POINTER :: atts
     TYPE(ncvarp), POINTER :: vars

     TYPE(ncftime), POINTER :: ftime
     TYPE(interp_weights),POINTER :: interp_n
     TYPE(interp_weights),POINTER :: interp_c
  END TYPE ncfile
    
  TYPE ncfilep
     TYPE(ncfile), pointer :: ncf
     TYPE(ncfilep), pointer :: next
  END TYPE ncfilep

  TYPE ncfilelist
     TYPE(ncfilep), pointer :: first
  END TYPE ncfilelist
  

!DO NOT OVERLOAD THE OPERATORS - BE EXPLICIT ABOUT HOW DIMS,VARS,ATTS AND FILES ARE FOUND
!!$  INTERFACE OPERATOR(==)
!!$     MODULE PROCEDURE NAME_EQ_NCF
!!$     MODULE PROCEDURE NCF_EQ_NAME
!!$  END INTERFACE


!!!!!!
!!!!!!  list of module procedures
!!!!!!
! NEW_FILE
! NEW_FILE_LIST
  INTERFACE delete_file_link
     MODULE PROCEDURE delete_filep_byname
     MODULE PROCEDURE delete_filep_byncid
  END INTERFACE
  ! DELETE_FILE_LIST
  ! KILL_VAR

  INTERFACE insert_file_link
!     MODULE PROCEDURE INSERT_FILEP_BYNAME
     MODULE PROCEDURE insert_filep_byncf
  END INTERFACE

  INTERFACE find_file
     MODULE PROCEDURE find_file_byname
     MODULE PROCEDURE find_file_byncid
  END INTERFACE
! COUNT_FILE_LIST
! PRINT_FILE_LIST


! NEW_VAR
! NEW_VARP
! Reference_Var
! COPY_VAR
  INTERFACE delete_var_link
     MODULE PROCEDURE delete_varp_byname
     MODULE PROCEDURE delete_varp_byvarid
  END INTERFACE
  ! DELETE_VAR_LIST
  ! KILL_VAR

  INTERFACE insert_var_link
!     MODULE PROCEDURE INSERT_VARP_BYNAME
     MODULE PROCEDURE insert_varp_byvar
  END INTERFACE

  INTERFACE find_var
     MODULE PROCEDURE find_var_byname
     MODULE PROCEDURE find_var_byvarid
  END INTERFACE

! COUNT_VAR_LIST
! PRINT_VAR_LIST
  

! NEW_ATT
! NEW_ATTP
! COPY_ATT
! COPY_ATT_LIST
  INTERFACE delete_att_link
     MODULE PROCEDURE delete_ncf_attp_byname
     MODULE PROCEDURE delete_ncf_attp_byattid
     MODULE PROCEDURE delete_var_attp_byname
     MODULE PROCEDURE delete_var_attp_byattid     
  END INTERFACE

  INTERFACE delete_att_list
     MODULE PROCEDURE delete_ncf_attp_list
     MODULE PROCEDURE delete_var_attp_list
  END INTERFACE
  ! KILL_VAR

  INTERFACE insert_att_link
!     MODULE PROCEDURE INSERT_NCF_ATTP_BYNAME
     MODULE PROCEDURE insert_ncf_attp_byatt
!     MODULE PROCEDURE INSERT_VAR_ATTP_BYNAME
     MODULE PROCEDURE insert_var_attp_byatt
  END INTERFACE

  INTERFACE find_att
     MODULE PROCEDURE find_ncf_att_byname
     MODULE PROCEDURE find_ncf_att_byattid
     MODULE PROCEDURE find_var_att_byname
     MODULE PROCEDURE find_var_att_byattid
  END INTERFACE

  INTERFACE count_att_list
     MODULE PROCEDURE count_ncf_att_list
     MODULE PROCEDURE count_var_att_list
  END INTERFACE

  INTERFACE print_att_list
     MODULE PROCEDURE print_ncf_att_list
     MODULE PROCEDURE print_var_att_list
  END INTERFACE


! NEW_DIM
! NEW_DIMP
! COPY_DIM
  INTERFACE delete_dim_link
     MODULE PROCEDURE delete_ncf_dimp_byname
     MODULE PROCEDURE delete_ncf_dimp_bydimid
     MODULE PROCEDURE delete_var_dimp_byname
     MODULE PROCEDURE delete_var_dimp_bydimid     
  END INTERFACE

  INTERFACE delete_dim_list
     MODULE PROCEDURE delete_ncf_dimp_list
     MODULE PROCEDURE delete_var_dimp_list
  END INTERFACE
! KILL_DIM

  INTERFACE insert_dim_link
!     MODULE PROCEDURE INSERT_NCF_DIMP_BYNAME - NOT IMPLIMENTED- DANGEROUS
     MODULE PROCEDURE insert_ncf_dimp_bydim
!     MODULE PROCEDURE INSERT_VAR_DIMP_BYNAME - NOT IMPLIMENTED- DANGEROUS
     MODULE PROCEDURE insert_var_dimp_bydim
  END INTERFACE

  INTERFACE find_dim
     MODULE PROCEDURE find_ncf_dim_byname
     MODULE PROCEDURE find_ncf_dim_bydimid
     MODULE PROCEDURE find_var_dim_byname
     MODULE PROCEDURE find_var_dim_bydimid
  END INTERFACE

  INTERFACE find_unlimited
     MODULE PROCEDURE find_ncf_dim_unlimited
     MODULE PROCEDURE find_var_dim_unlimited
  END INTERFACE
  
  INTERFACE has_unlimited
     MODULE PROCEDURE has_unlimited_ncf
     MODULE PROCEDURE has_unlimited_var
  END INTERFACE

  INTERFACE count_dim_list
     MODULE PROCEDURE count_ncf_dim_list
     MODULE PROCEDURE count_var_dim_list
  END INTERFACE

  INTERFACE count_nonsingleton_dim_list
     MODULE PROCEDURE count_ncf_ns_dim_list
     MODULE PROCEDURE count_var_ns_dim_list
  END INTERFACE

  INTERFACE print_dim_list
     MODULE PROCEDURE print_ncf_dim_list
     MODULE PROCEDURE print_var_dim_list
  END INTERFACE


!!!
!!! Note: tried to add interface operator to addition(+) and
!!! subtraction(-) of nc objects but intent(in) is required 
!!! for both arguments of the function. That is not practical. 
!!!
  INTERFACE add
     MODULE PROCEDURE var_plus_dim
     MODULE PROCEDURE var_plus_att
     MODULE PROCEDURE ncf_plus_var
     MODULE PROCEDURE ncf_plus_att
     MODULE PROCEDURE ncf_plus_dim
     MODULE PROCEDURE ncf_plus_ncf
     MODULE PROCEDURE ncflist_plus_ncf
  END INTERFACE
  
  INTERFACE ASSIGNMENT(=)
     MODULE PROCEDURE copy_dim_list
     MODULE PROCEDURE copy_att_list
     MODULE PROCEDURE copy_ftime
  END INTERFACE

CONTAINS
!====================================================================
!====================================================================
!============================ FILES =================================
!====================================================================
!====================================================================
  FUNCTION new_file(fname) RESULT(NCF)
    IMPLICIT NONE
!    CHARACTER(LEN=160), INTENT(IN)  :: NAME
    TYPE(ncfile), POINTER :: ncf
    CHARACTER(len=*), OPTIONAL, INTENT(IN) :: fname
    integer status
    
    nullify(ncf)
    ALLOCATE(ncf,stat=status)
    if(status/=0) CALL fatal_error("NEW_FILE: COULD NOT ALLOCATE!")
    
    Nullify(ncf%NCID)
    ALLOCATE(ncf%NCID)
    ncf%NCID      = -1
    ncf%FNAME     = ' '
    IF (PRESENT(fname)) ncf%FNAME=fname
    ncf%WRITABLE = .false.
    ncf%OPEN      = .false.
    ncf%CONNECTED = .false.
    ncf%UNLIMDIMID = -1

    NULLIFY(ncf%FTIME)
    NULLIFY(ncf%INTERP_N)
    NULLIFY(ncf%INTERP_C)

    ! TIME VARIABLES ARE ALL INTEGER => AUTOMATICALLY INITIALIZED TO ZERO

    ! MAKE NEW LISTS FOR THE NCFILE
    ncf%DIMS => new_dimp()
    ncf%ATTS => new_attp()
    ncf%VARS => new_varp()
  END FUNCTION new_file
!====================================================================
!====================================================================
  FUNCTION copy_file(NCFIN) RESULT(NCFOUT)
    IMPLICIT NONE
!    CHARACTER(LEN=160), INTENT(IN)  :: NAME
    TYPE(ncfile), POINTER,INTENT(IN) :: ncfin
    TYPE(ncfile), POINTER :: ncfout
    TYPE(ncvar), POINTER :: ncfout1
    TYPE(ncvarp), POINTER :: current
    integer status

    IF(.not. Associated(ncfin)) Call fatal_error &
         ("COPY_NCF: INPUT FILE IS NOT ASSOCIATED!")
    
    ncfout => new_file()
    
    ncfout%NCID      = -1
    ncfout%FNAME     = ncfin%FNAME  
    ncfout%WRITABLE = .false.
    ncfout%OPEN      = .false.
    ncfout%CONNECTED = .false.
    ncfout%UNLIMDIMID = ncfin%UNLIMDIMID

!!$
!!$    IF(Associated(NCFIN%INTERP_N)) NCFOUT%INTERP_N => COPY_INTERP(NCFIN%INTERP_N)
!!$
!!$    IF(Associated(NCFIN%INTERP_C)) NCFOUT%INTERP_C => COPY_INTERP(NCFIN%INTERP_C)
!!$

    ! TIME VARIABLES ARE ALL INTEGER => AUTOMATICALLY INITIALIZED TO ZERO

    ! MAKE NEW LISTS FOR THE NCFILE
    IF(.not. Associated(ncfin%DIMS)) Call fatal_error &
         ("COPY_NCF: INPUT FILE DIMS LIST IS NOT ASSOCIATED!")

    IF(.not. Associated(ncfin%ATTS)) Call fatal_error &
         ("COPY_NCF: INPUT FILE ATTS LIST IS NOT ASSOCIATED!")

    IF(.not. Associated(ncfin%VARS)) Call fatal_error &
         ("COPY_NCF: INPUT FILE VARS LIST IS NOT ASSOCIATED!")

    ! USE OVERLOADED ASSIGNMENT OPERATOR
    ncfout%DIMS = ncfin%DIMS
    ncfout%ATTS = ncfin%ATTS

    current => ncfin%VARS%NEXT
    DO
       IF(.NOT. ASSOCIATED(current)) THEN
          EXIT ! END OF VAR LIST
       END IF

       IF(.NOT. ASSOCIATED(current%VAR)) THEN
          CALL fatal_error("COPY_FILE: FOUND NULL VAR POINTER IN THE LIST")
       END IF

       ncfout1 => copy_var(current%VAR)
       ncfout => add(ncfout,ncfout1)
!!$       NCFOUT => ADD(NCFOUT,COPY_VAR(CURRENT%VAR))

       current => current%NEXT

    END DO


    ! NOTE - THIS ONLY SETS THE INTEGER VALUES THE TIME VARIABLE
    ! POINTERS ARE NOT SET HERE!
    IF(Associated(ncfin%FTIME)) THEN
       ncfout%FTIME => new_ftime()
       ncfout%FTIME = ncfin%FTIME
    END IF


  END FUNCTION copy_file
!====================================================================
!====================================================================
  FUNCTION new_ftime() RESULT(FTM)
    IMPLICIT NONE
    TYPE(ncftime), POINTER :: ftm
    integer status
    
    ALLOCATE(ftm,stat=status)
    if(status/=0) CALL fatal_error("NEW_FTM: COULD NOT ALLOCATE FTM!")

    nullify(ftm%tm1)
    nullify(ftm%tm2)

    ftm%TIMEZONE="none"

  END FUNCTION new_ftime
!====================================================================
!====================================================================
  SUBROUTINE copy_ftime(FTIME_OUT,FTIME_IN)
    IMPLICIT NONE
    TYPE(ncftime),INTENT(OUT):: FTIME_OUT
    TYPE(ncftime),INTENT(IN) :: FTIME_IN
    
    ftime_out%TMTYPE = ftime_in%TMTYPE
    ftime_out%STK_LEN = ftime_in%STK_LEN
    ftime_out%PREV_STKCNT = ftime_in%PREV_STKCNT
    ftime_out%NEXT_STKCNT = ftime_in%NEXT_STKCNT
    ftime_out%MAX_STKCNT = ftime_in%MAX_STKCNT
    ftime_out%PREV_IO = ftime_in%PREV_IO
    ftime_out%NEXT_IO = ftime_in%NEXT_IO
    ftime_out%PREV_WGHT = ftime_in%PREV_WGHT
    ftime_out%NEXT_WGHT = ftime_in%NEXT_WGHT
    ftime_out%INTERVAL = ftime_in%INTERVAL
    ftime_out%TIMEZONE = ftime_in%TIMEZONE

  END SUBROUTINE copy_ftime
!====================================================================
!====================================================================
  FUNCTION new_filep() RESULT(NCFP)
    IMPLICIT NONE
    TYPE(ncfilep), POINTER :: ncfp
    integer status
    
    ALLOCATE(ncfp,stat=status)
    if(status/=0) CALL fatal_error("ALLOC_FILEP: COULD NOT ALLOCATE!")
    NULLIFY(ncfp%NEXT)
    NULLIFY(ncfp%NCF)
    

  END FUNCTION new_filep
!====================================================================
!====================================================================
  FUNCTION new_filehead() RESULT(FILEHEAD)
    IMPLICIT NONE
    TYPE(ncfilelist), POINTER :: filehead
    integer status
    
    ALLOCATE(filehead,stat=status)
    if(status/=0) CALL fatal_error("ALLOC_FILEHEAD: COULD NOT ALLOCATE!")
    filehead%FIRST => new_filep()

  END FUNCTION new_filehead
!====================================================================
!====================================================================
  SUBROUTINE kill_filehead(FILEHEAD)
    IMPLICIT NONE
    TYPE(ncfilelist), POINTER :: FILEHEAD

    call delete_file_list(filehead)
    DEALLOCATE(filehead)
    NULLIFY(filehead)
    
  END SUBROUTINE kill_filehead
!====================================================================
!====================================================================
  SUBROUTINE delete_filep_byname(LIST,NAME,FOUND)
    IMPLICIT NONE
    TYPE(ncfilelist),   INTENT(INOUT) :: LIST
    CHARACTER(LEN=*), INTENT(IN)    :: NAME
    LOGICAL,            INTENT(OUT)   :: FOUND
    TYPE(ncfilep), pointer            :: CURRENT, PREVIOUS
    
    previous => list%FIRST
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( name == current%NCF%FNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_file(current%NCF)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_filep_byname
!====================================================================
!====================================================================
  SUBROUTINE delete_filep_byncid(LIST,NCID,FOUND)
    IMPLICIT NONE
    TYPE(ncfilelist),   INTENT(INOUT) :: LIST
    INTEGER, INTENT(IN)               :: NCID
    LOGICAL,            INTENT(OUT)   :: FOUND
    TYPE(ncfilep),pointer             :: CURRENT, PREVIOUS
    
    previous => list%FIRST
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( ncid == current%NCF%NCID ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_file(current%NCF)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_filep_byncid
!====================================================================
!====================================================================
  SUBROUTINE delete_file_list(LIST)
    IMPLICIT NONE
    TYPE(ncfilelist),   INTENT(INOUT) :: LIST
    TYPE(ncfilep),pointer             :: CURRENT, PREVIOUS
    
    previous => list%FIRST
    current  => previous%NEXT
 
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       previous%NEXT => current%NEXT
       CALL kill_file(current%NCF)
       DEALLOCATE(current)
       
       current => previous%NEXT

    END DO
   
  END SUBROUTINE delete_file_list
!====================================================================
!====================================================================
 SUBROUTINE kill_file(NCF)
   TYPE(ncfile),POINTER :: NCF
   INTEGER STATUS

   IF(.not. ASSOCIATED(ncf))THEN
      
      IF(dbg_set(dbg_log)) CALL warning &
           & ("CALLED KILL FILL BUT FILE OBJECT IS NOT ASSOCIATED?")
      RETURN
   END IF

   IF (ncf%OPEN) THEN
      status = nf90_close(ncf%ncid)
   END IF

   CALL delete_var_list(ncf)
   DEALLOCATE(ncf%VARS)

   CALL delete_dim_list(ncf)
   DEALLOCATE(ncf%DIMS)

   CALL delete_att_list(ncf)
   DEALLOCATE(ncf%ATTS)
   
   IF(ASSOCIATED(ncf%FTIME)) THEN
      NULLIFY(ncf%FTIME%TM1)
      NULLIFY(ncf%FTIME%TM2)
      DEALLOCATE(ncf%FTIME)
      NULLIFY (ncf%FTIME)
   END IF

   ! INTERP MEMORY IS NEVER BELLONGS TO THE FILE POINTER
   IF(ASSOCIATED(ncf%INTERP_N)) Nullify(ncf%INTERP_N)
   IF(ASSOCIATED(ncf%INTERP_C)) Nullify(ncf%INTERP_C)

   DEALLOCATE(ncf%NCID)
   NULLIFY(ncf%NCID)
   
   DEALLOCATE(ncf,stat=status)
   IF(status /= 0) CALL fatal_error("KILL_FILE: COULD NOT DEALLOCATE")
   NULLIFY(ncf)

 END SUBROUTINE kill_file
!====================================================================
!====================================================================
!!$  SUBROUTINE INSERT_FILEP_BYNAME(LIST,NAME,FOUND)
!!$    ! ONLY INSERT NEW FILE IF NOT FOUND
!!$    ! ALWAYS INSERT NCFILEP AT THE END OF THE LIST
!!$    IMPLICIT NONE
!!$    CHARACTER(LEN=160), INTENT(IN)    :: NAME
!!$    LOGICAL,            INTENT(OUT)   :: FOUND
!!$    TYPE(NCFILELIST),   INTENT(INOUT) :: LIST
!!$    TYPE(NCFILEP), pointer            :: CURRENT, PREVIOUS
!!$    
!!$    PREVIOUS => LIST%FIRST
!!$    CURRENT  => PREVIOUS%NEXT
!!$    FOUND = .FALSE.
!!$    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
!!$    DO
!!$       IF(.NOT. ASSOCIATED(CURRENT)) EXIT !END OF LIST
!!$       IF( NAME == CURRENT%NCF%FNAME ) THEN ! FOUND THE FILE LINK
!!$          FOUND = .TRUE.
!!$          RETURN
!!$       ELSE
!!$          PREVIOUS => PREVIOUS%NEXT
!!$          CURRENT  => CURRENT%NEXT
!!$       END IF
!!$    END DO
!!$    ! NOT FOUND - ADD NEW FILE TO END OF LIST
!!$    CURRENT => NEW_FILEP()
!!$    CURRENT%NCF => NEW_FILE(NAME)
!!$    
!!$  END SUBROUTINE INSERT_FILEP_BYNAME
!====================================================================
!====================================================================
  SUBROUTINE insert_filep_byncf(LIST,NCF,FOUND)
    ! ONLY INSERT NEW FILE IF NOT FOUND
    ! ALWAYS INSERT NCFILEP AT THE END OF THE LIST
    IMPLICIT NONE
    TYPE(ncfile),POINTER              :: NCF
    LOGICAL,            INTENT(OUT)   :: FOUND
    TYPE(ncfilelist),   INTENT(INOUT) :: LIST
    TYPE(ncfilep), pointer            :: CURRENT, PREVIOUS
    
    IF(.NOT.ASSOCIATED(ncf))&
         & CALL fatal_error("INSERT_FILEP_BYNCF: NCF NOT ASSOCIATED!")

    previous => list%FIRST
    current  => previous%NEXT
    found = .false.
    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       IF( ncf%FNAME == current%NCF%FNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          RETURN
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO
    ! NOT FOUND - ADD NEW FILE TO END OF LIST

    previous%NEXT => new_filep()
    previous%NEXT%NCF => ncf
    
  END SUBROUTINE insert_filep_byncf
!====================================================================
!====================================================================
  FUNCTION find_file_byname(LIST,NAME,FOUND) RESULT(NCF)
    IMPLICIT NONE
    TYPE(ncfile),POINTER               :: ncf
    TYPE(ncfilelist),    INTENT(IN)    :: list
    CHARACTER(LEN=*),  INTENT(IN)    :: name
    LOGICAL,             INTENT(OUT)   :: found
    TYPE(ncfilep), pointer             :: current, previous
    integer                            :: idx

    previous => list%FIRST
    current  => previous%NEXT
    NULLIFY(ncf)
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       if(.not. associated(current%ncf)) Call fatal_error&
            & ("FIND_FILE: Link in file list has file pointer that is &
            &not associated!")

       idx = index(current%NCF%FNAME,name)

       IF( idx /= 0 ) THEN ! FOUND THE FILE LINK
          ncf => current%NCF
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO
    
  END FUNCTION find_file_byname
!====================================================================
!====================================================================
  FUNCTION find_file_byncid(LIST,NCID,FOUND) RESULT(NCF)
    IMPLICIT NONE
    TYPE(ncfile),POINTER               :: ncf
    TYPE(ncfilelist),    INTENT(IN) :: list
    INTEGER,             INTENT(IN)    :: ncid
    LOGICAL,             INTENT(OUT)   :: found
    TYPE(ncfilep), pointer             :: current, previous
    
    NULLIFY(ncf)
    previous => list%FIRST
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( ncid == current%NCF%NCID ) THEN ! FOUND THE FILE LINK
          ncf => current%NCF
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO
    
  END FUNCTION find_file_byncid
!====================================================================
!====================================================================
  FUNCTION count_file_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncfilelist),    INTENT(IN)    :: list
    TYPE(ncfilep), pointer             :: current, previous
    
    previous => list%FIRST
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       previous => previous%NEXT
       current  => current%NEXT
       cnt = cnt + 1
    END DO
    
  END FUNCTION count_file_list
!====================================================================
!====================================================================
  SUBROUTINE print_file_list(LIST)
    IMPLICIT NONE
    type(ncfilelist), intent(IN)       :: LIST
    TYPE(ncfilep), pointer             :: CURRENT, PREVIOUS
    INTEGER                            :: CNT
    Character(len=4)                   :: chr

    previous => list%FIRST
    current  => previous%NEXT

    IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% FILE LIST IS EMPTY %%%%%%%%%%%%%"
       RETURN
    ELSE
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% PRINTING FILE LIST %%%%%%%%%%%%%"
    END IF
    
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1
       write(chr,'(I4.4)')cnt
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"! PRINTING FILE LIST ENTRY #"//chr
       CALL print_file(current%NCF)

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    if(dbg_set(dbg_log)) &
         & write(ipt,*)"%%%%%%%%%%% END OF FILE LIST %%%%%%%%%%%%%"
  END SUBROUTINE print_file_list
!====================================================================
!====================================================================
  SUBROUTINE print_file(NCF)
    implicit none
    type(ncfile), pointer :: NCF
    type(ncftime), pointer :: TM
    
    if(dbg_set(dbg_log)) then
       WRITE(ipt,*) "======== PRINT NCFILE TYPE ======="
       if(.not. associated(ncf)) then
          WRITE(ipt,*) "THIS NCFILE HAS NOT BEEN ASSOCIATED"
          WRITE(ipt,*) "======= PRINTED NCFILE TYPE ======"
          return
       end if
       WRITE(ipt,*) "=FILENAME    ::"//trim(ncf%FNAME)
       WRITE(ipt,*) "=NCID        ::",ncf%NCID
       WRITE(ipt,*) "=WRITABLE    ::",ncf%WRITABLE
       WRITE(ipt,*) "=OPEN        ::",ncf%OPEN
       WRITE(ipt,*) "=CONNECTED   ::",ncf%CONNECTED
       WRITE(ipt,*) "=INDEFMODE   ::",ncf%INDEFMODE
       WRITE(ipt,*) "=UNLIMDIMID  ::",ncf%UNLIMDIMID
       WRITE(ipt,*) "= "
       tm => ncf%FTIME
       CALL print_ftime(tm)
       WRITE(ipt,*) "= "
       WRITE(ipt,*) "=     FILE OBJECT COUNTS"
       WRITE(ipt,*) "=nDIMS       ::",count_dim_list(ncf)
       WRITE(ipt,*) "=nATTS       ::",count_att_list(ncf)
       WRITE(ipt,*) "=nVARS       ::",count_var_list(ncf)
       IF(ASSOCIATED(ncf%INTERP_N))WRITE(ipt,*) "= HAS INTERP COEF'S TO NODES"
       IF(ASSOCIATED(ncf%INTERP_C))WRITE(ipt,*) "= HAS INTERP COEF'S TO CELLS"
       WRITE(ipt,*) "====== PRINTED NCFILE TYPE ======"
       
    end if
END SUBROUTINE print_file
!===================================================================
!===================================================================
SUBROUTINE print_ftime(FTIME)
  USE control, only : use_real_world_time
  IMPLICIT NONE
  TYPE(ncftime), POINTER :: FTIME
  

  WRITE(ipt,*) "===== FILE IO TIME INFO ===="

  IF (ASSOCIATED(ftime)) THEN
     select case(ftime%TMtype)
     CASE(tmtype_unknown)
        WRITE(ipt,*) "=    TMTYPE  :: UNKNOWN"
     CASE(tmtype_char_date)
        WRITE(ipt,*) "=    TMTYPE  :: CHARACTER STRING DATE"
     CASE(tmtype_int2_mjd)
        WRITE(ipt,*) "=    TMTYPE  :: TWO INTEGER MJD"
     CASE(tmtype_float_seconds)
        WRITE(ipt,*) "=    TMTYPE  :: FLOATING POINT SECONDS"
     CASE(tmtype_float_days)
        WRITE(ipt,*) "=    TMTYPE  :: FLOATING POINT DAYS"
     END select
     CALL print_var(ftime%TM1)
     CALL print_var(ftime%TM2)
          
     IF(use_real_world_time) THEN
        CALL print_real_time(ftime%PREV_IO,ipt,"PREV IO")
        CALL print_real_time(ftime%NEXT_IO,ipt,"NEXT IO")
     ELSE
        CALL print_time(ftime%PREV_IO,ipt,"PREV IO")
        CALL print_time(ftime%NEXT_IO,ipt,"NEXT IO")
     END IF
     CALL print_time(ftime%INTERVAL,ipt,"IO INTERVAL")
     
     WRITE(ipt,*) "=STK_LEN     ::",ftime%STK_LEN

     WRITE(ipt,*) "=PREV_STKCNT ::",ftime%PREV_STKCNT
     WRITE(ipt,*) "=NEXT_STKCNT ::",ftime%NEXT_STKCNT
     WRITE(ipt,*) "=MAX_STKCNT  ::",ftime%MAX_STKCNT
     WRITE(ipt,*) "=PREV_WGHT   ::",ftime%PREV_WGHT
     WRITE(ipt,*) "=NEXT_WGHT   ::",ftime%NEXT_WGHT
     WRITE(ipt,*) "=TIMEZONE    ::"//trim(ftime%TIMEZONE)
     
  ELSE
     WRITE(ipt,*) "=  FTIME NOT ALLOCATED: THE FILE HAS NO RECOGNIZED TIME VARIABLE"
  END IF
  WRITE(ipt,*) "=END  FILE IO TIME TYPE ===="
  
END SUBROUTINE print_ftime
!====================================================================
!====================================================================
!=========================== VARIABLES ==============================
!====================================================================
!====================================================================
  FUNCTION new_var() RESULT(VAR)
    IMPLICIT NONE
!    CHARACTER(Len=*), INTENT(IN) :: NAME
    TYPE(ncvar), POINTER :: var
    integer status
    
    ALLOCATE(var,stat=status)
    if(status/=0) CALL fatal_error("NEW_VAR: COULD NOT ALLOCATE!")

    NULLIFY(var%NCID)
    var%CONNECTED = .false.
    var%VARID     = -1
!    VAR%VARNAME   = NAME
    var%VARNAME   = ' '
    var%XTYPE     = -1
    nullify(var%DIMS)
    nullify(var%ATTS)

    var%DIMS => new_dimp()
    var%ATTS => new_attp()

    nullify(var%scl_int)
    nullify(var%vec_int)
    nullify(var%arr_int)
    nullify(var%cub_int)
    nullify(var%fda_int)

    nullify(var%scl_flt)
    nullify(var%vec_flt)
    nullify(var%arr_flt)
    nullify(var%cub_flt)
    nullify(var%fda_flt)

    nullify(var%scl_dbl)
    nullify(var%vec_dbl)
    nullify(var%arr_dbl)
    nullify(var%cub_dbl)
    nullify(var%fda_dbl)

    nullify(var%scl_chr)
    nullify(var%vec_chr)

  END FUNCTION new_var
!====================================================================
!====================================================================
  FUNCTION new_varp() RESULT(VARP)
    IMPLICIT NONE
    TYPE(ncvarp), POINTER :: varp
    integer status
    
    ALLOCATE(varp,stat=status)
    if(status/=0) CALL fatal_error("NEW_VARP: COULD NOT ALLOCATE!")
    NULLIFY(varp%NEXT)
    NULLIFY(varp%VAR)

  END FUNCTION new_varp
!====================================================================
!====================================================================
  FUNCTION copy_var(VARIN) RESULT(VAROUT)
    IMPLICIT NONE
    TYPE(ncvar), POINTER :: varin, varout
    integer status

    varout => new_var()

    ! DO NOT TAKE VALUES THAT BELONG TO THIS FILE
!    VAROUT%NCID      => VARIN%NCID
!    VAROUT%CONNECTED = VARIN%CONNECTED
!    VAROUT%VARID     = VARIN%VARID
    varout%VARNAME   = varin%VARNAME
    varout%XTYPE     = varin%XTYPE
    
    IF(Associated(varin%SCL_INT)) varout%SCL_INT=>varin%SCL_INT
    IF(Associated(varin%VEC_INT)) varout%VEC_INT=>varin%VEC_INT
    IF(Associated(varin%ARR_INT)) varout%ARR_INT=>varin%ARR_INT
    IF(Associated(varin%CUB_INT)) varout%CUB_INT=>varin%CUB_INT
    IF(Associated(varin%FDA_INT)) varout%FDA_INT=>varin%FDA_INT

    IF(Associated(varin%SCL_FLT)) varout%SCL_FLT=>varin%SCL_FLT
    IF(Associated(varin%VEC_FLT)) varout%VEC_FLT=>varin%VEC_FLT
    IF(Associated(varin%ARR_FLT)) varout%ARR_FLT=>varin%ARR_FLT
    IF(Associated(varin%CUB_FLT)) varout%CUB_FLT=>varin%CUB_FLT
    IF(Associated(varin%FDA_FLT)) varout%FDA_FLT=>varin%FDA_FLT

    IF(Associated(varin%SCL_DBL)) varout%SCL_DBL=>varin%SCL_DBL
    IF(Associated(varin%VEC_DBL)) varout%VEC_DBL=>varin%VEC_DBL
    IF(Associated(varin%ARR_DBL)) varout%ARR_DBL=>varin%ARR_DBL
    IF(Associated(varin%CUB_DBL)) varout%CUB_DBL=>varin%CUB_DBL
    IF(Associated(varin%FDA_DBL)) varout%FDA_DBL=>varin%FDA_DBL

    IF(Associated(varin%SCL_CHR)) varout%SCL_CHR=>varin%SCL_CHR
    IF(Associated(varin%VEC_CHR)) varout%VEC_CHR=>varin%VEC_CHR



    IF(.not. Associated(varin%DIMS)) Call fatal_error &
         ("COPY_VAR: INPUT VARIABLE DIMS LIST IS NOT ASSOCIATED!")

    IF(.not. Associated(varin%ATTS)) Call fatal_error &
         ("COPY_VAR: INPUT VARIABLE ATTS LIST IS NOT ASSOCIATED!")

    ! USING OVERLOADED ASSIGNMENT OPERATOR
!    call copy_dim_list(VAROUT%DIMS, VARIN%DIMS)
!    call copy_att_list(VAROUT%ATTS, VARIN%ATTS)

    varout%DIMS = varin%DIMS
    varout%ATTS = varin%ATTS

  END FUNCTION copy_var
!====================================================================
!====================================================================
  FUNCTION reference_var(VARIN) RESULT(VAROUT)
    IMPLICIT NONE
    TYPE(ncvar), POINTER :: varin, varout
    integer status

    varout => new_var()

    varout%NCID      => varin%NCID
    varout%CONNECTED = varin%CONNECTED
    varout%VARID     = varin%VARID
    varout%VARNAME   = varin%VARNAME
    varout%XTYPE     = varin%XTYPE
    varout%DIMS%NEXT => varin%DIMS%NEXT
    varout%ATTS%NEXT => varin%ATTS%NEXT

  END FUNCTION reference_var
!====================================================================
!====================================================================
  SUBROUTINE delete_varp_byname(LIST,NAME,FOUND)
    IMPLICIT NONE
    ! NCFILE IS ALWAYS THE HEAD FOR A VAR LINK LIST
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    CHARACTER(LEN=*),INTENT(IN)                 :: NAME
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncvarp), pointer                       :: CURRENT, PREVIOUS
    
    previous => list%VARS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( name == current%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_var(current%VAR)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_varp_byname
!====================================================================
!====================================================================
  SUBROUTINE delete_varp_byvarid(LIST,VARID,FOUND)
    IMPLICIT NONE
    ! NCFILE IS ALWAYS THE HEAD FOR A VAR LINK LIST
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    INTEGER,                       INTENT(IN)   :: VARID
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncvarp), pointer                       :: CURRENT, PREVIOUS
    
    previous => list%VARS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( varid == current%VAR%VARID ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_var(current%VAR)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_varp_byvarid
!====================================================================
!====================================================================
  SUBROUTINE delete_var_list(LIST)
    IMPLICIT NONE
    ! NCFILE IS ALWAYS THE HEAD FOR A VAR LINK LIST
    TYPE(ncfile), POINTER                       :: LIST
    TYPE(ncvarp), pointer                       :: CURRENT, PREVIOUS

    IF(.not.ASSOCIATED(list)) RETURN
    
    previous => list%VARS
    current  => previous%NEXT

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       previous%NEXT => current%NEXT
       CALL kill_var(current%VAR)
       DEALLOCATE(current)
       current => previous%NEXT

    END DO

   
  END SUBROUTINE delete_var_list
!====================================================================
!====================================================================
 SUBROUTINE kill_var(VAR)
   TYPE(ncvar),POINTER :: VAR
   INTEGER STATUS

   IF(.not.ASSOCIATED(var)) RETURN
   
   CALL delete_dim_list(var)
   DEALLOCATE(var%DIMS)
   
   CALL delete_att_list(var)
   DEALLOCATE(var%ATTS)

   DEALLOCATE(var,stat=status)
   IF(status /= 0) CALL fatal_error("KILL_VAR: COULD NOT DEALLOCATE")
   NULLIFY(var)
   
 END SUBROUTINE kill_var
!====================================================================
!====================================================================
!!$ SUBROUTINE INSERT_VARP_BYNAME(LIST,NAME,FOUND)
!!$    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
!!$    ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
!!$    IMPLICIT NONE
!!$    CHARACTER(LEN=NF90_MAX_NAME+1),INTENT(IN)   :: NAME
!!$    LOGICAL,                       INTENT(OUT)  :: FOUND
!!$    TYPE(NCFILE),                  INTENT(INOUT):: LIST
!!$    TYPE(NCVARP), pointer                       :: CURRENT, PREVIOUS
!!$    
!!$    PREVIOUS => LIST%VARS
!!$    CURRENT  => PREVIOUS%NEXT
!!$    FOUND = .FALSE.
!!$    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
!!$    DO
!!$       IF(.NOT. ASSOCIATED(CURRENT)) EXIT !END OF LIST
!!$       IF( NAME == CURRENT%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
!!$          FOUND = .TRUE.
!!$          RETURN
!!$       ELSE
!!$          PREVIOUS => PREVIOUS%NEXT
!!$          CURRENT  => CURRENT%NEXT
!!$       END IF
!!$    END DO
!!$    ! NOT FOUND - ADD NEW FILE TO END OF LIST
!!$    CURRENT => NEW_VARP()
!!$    CURRENT%VAR => NEW_VAR(NAME)
!!$    
!!$  END SUBROUTINE INSERT_VARP_BYNAME
!====================================================================
!====================================================================
 SUBROUTINE insert_varp_byvar(LIST,VAR,FOUND)
    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
    ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
    IMPLICIT NONE
    TYPE(ncvar),POINTER                         :: VAR
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    TYPE(ncvarp),POINTER                        :: CURRENT, PREVIOUS
    INTEGER CNT

    IF(.NOT.ASSOCIATED(var))&
         & CALL fatal_error("INSERT_VARP_BYVAR: VAR NOT ASSOCIATED!")

    previous => list%VARS
    current  => previous%NEXT
    found = .false.
    cnt = 1
    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       IF( var%VARNAME == current%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          RETURN
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
          cnt = cnt + 1
       END IF
    END DO
    ! NOT FOUND - ADD NEW FILE TO END OF LIST
    previous%NEXT => new_varp()
    previous%NEXT%VAR => var
    var%VARID = cnt

  END SUBROUTINE insert_varp_byvar
!====================================================================
!====================================================================
  FUNCTION find_var_byname(LIST,NAME,FOUND) RESULT(VAR)
    IMPLICIT NONE
    TYPE(ncvar), POINTER                :: var
    TYPE(ncfile),         INTENT(IN) :: list
    CHARACTER(LEN=*),INTENT(IN)    :: name
    LOGICAL,              INTENT(OUT)   :: found
    TYPE(ncvarp)                ,POINTER :: current, previous
    
    NULLIFY(var)
    previous => list%VARS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( name == current%VAR%VARNAME ) THEN ! FOUND THE FILE LINK
          var => current%VAR
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_var_byname
!====================================================================
!====================================================================
  FUNCTION find_var_byvarid(LIST,VARID,FOUND) RESULT(VAR)
    IMPLICIT NONE
    TYPE(ncvar), POINTER                :: var
    TYPE(ncfile),         INTENT(IN) :: list
    INTEGER,              INTENT(IN)    :: varid
    LOGICAL,              INTENT(OUT)   :: found
    TYPE(ncvarp)                ,POINTER :: current, previous
    
    NULLIFY(var)
    previous => list%VARS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( varid == current%VAR%VARID ) THEN ! FOUND THE FILE LINK
          var => current%VAR
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO
    
  END FUNCTION find_var_byvarid    
!====================================================================
!====================================================================
  FUNCTION count_var_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncfile),        INTENT(IN)    :: list
    TYPE(ncvarp)              ,POINTER :: current, previous
    
    previous => list%VARS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       previous => previous%NEXT
       current  => current%NEXT
       cnt = cnt + 1
    END DO
    
  END FUNCTION count_var_list
!====================================================================
!====================================================================
  FUNCTION count_unlimited_vars(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncfile),        INTENT(IN)    :: list
    TYPE(ncvarp)              ,POINTER :: current, previous
    
    previous => list%VARS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF(has_unlimited(current%VAR)) cnt = cnt + 1

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    
  END FUNCTION count_unlimited_vars
!====================================================================
!====================================================================
  SUBROUTINE print_var_list(LIST)
    IMPLICIT NONE
    type(ncfile), intent(IN)       :: LIST
    TYPE(ncvarp)              ,POINTER :: CURRENT, PREVIOUS
    INTEGER                            :: CNT
    Character(len=4)                   :: chr

    previous => list%VARS
    current  => previous%NEXT

    IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% VARIABLE LIST IS EMPTY %%%%%%%%%%%%%"
       RETURN
    ELSE
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% PRINTING VARIABLE LIST %%%%%%%%%%%%%"
    END IF
    
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1
       write(chr,'(I4.4)')cnt
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"! PRINTING VARIABLE LIST ENTRY #"//chr
       CALL print_var(current%VAR)

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% END OF VARIABLE LIST %%%%%%%%%%%%%"
  END SUBROUTINE print_var_list
!====================================================================
!====================================================================
SUBROUTINE print_var(VAR)
  implicit none
  type(ncvar), POINTER, intent(IN) :: VAR
  
  if(dbg_set(dbg_log)) then
     WRITE(ipt,*) "======== PRINT NCVAR TYPE ======="

     if(.not. associated(var)) then
        WRITE(ipt,*) "THIS NCVAR HAS NOT BEEN ASSOCIATED"
        WRITE(ipt,*) "======= PRINTED NCVAR TYPE ======"
        return
     end if

     WRITE(ipt,*) "VARNAME     ::"//trim(var%VARNAME)
     WRITE(ipt,*) "VARID       ::",var%VARID
      if(.not. associated(var%NCID)) then
         WRITE(ipt,*) "NCID        :: NOT ASSOCIATED"
      else
         WRITE(ipt,*) "NCID        ::",var%NCID
     end if
     WRITE(ipt,*) "CONNECTED   ::",var%CONNECTED
     WRITE(ipt,*) "CURR_STKCNT ::",var%CURR_STKCNT
     
     select case(var%XTYPE)
     case(nf90_char)
        WRITE(ipt,*) "XYTPE       :: CHAR"
     case(nf90_byte)
        WRITE(ipt,*) "XYTPE       :: BYTE"
     case(nf90_short)
        WRITE(ipt,*) "XYTPE       :: SHORT"
     case(nf90_int)
        WRITE(ipt,*) "XYTPE       :: INT"
     case(nf90_float)
        WRITE(ipt,*) "XYTPE       :: FLOAT"
     case(nf90_double)
        WRITE(ipt,*) "XYTPE       :: DOUBLE"
     END select

     IF(ASSOCIATED(var%SCL_INT)) WRITE(ipt,*) "ASSOCIATED  :: SCL_INT"
     IF(ASSOCIATED(var%VEC_INT)) WRITE(ipt,*) "ASSOCIATED  :: VEC_INT"
     IF(ASSOCIATED(var%ARR_INT)) WRITE(ipt,*) "ASSOCIATED  :: ARR_INT"
     IF(ASSOCIATED(var%CUB_INT)) WRITE(ipt,*) "ASSOCIATED  :: CUB_INT"
     IF(ASSOCIATED(var%FDA_INT)) WRITE(ipt,*) "ASSOCIATED  :: FDA_INT"

     IF(ASSOCIATED(var%SCL_FLT)) WRITE(ipt,*) "ASSOCIATED  :: SCL_FLT"
     IF(ASSOCIATED(var%VEC_FLT)) WRITE(ipt,*) "ASSOCIATED  :: VEC_FLT"
     IF(ASSOCIATED(var%ARR_FLT)) WRITE(ipt,*) "ASSOCIATED  :: ARR_FLT"
     IF(ASSOCIATED(var%CUB_FLT)) WRITE(ipt,*) "ASSOCIATED  :: CUB_FLT"
     IF(ASSOCIATED(var%FDA_FLT)) WRITE(ipt,*) "ASSOCIATED  :: FDA_FLT"

     IF(ASSOCIATED(var%SCL_DBL)) WRITE(ipt,*) "ASSOCIATED  :: SCL_DBL"
     IF(ASSOCIATED(var%VEC_DBL)) WRITE(ipt,*) "ASSOCIATED  :: VEC_DBL"
     IF(ASSOCIATED(var%ARR_DBL)) WRITE(ipt,*) "ASSOCIATED  :: ARR_DBL"
     IF(ASSOCIATED(var%CUB_DBL)) WRITE(ipt,*) "ASSOCIATED  :: CUB_DBL"
     IF(ASSOCIATED(var%FDA_DBL)) WRITE(ipt,*) "ASSOCIATED  :: FDA_DBL"

     IF(ASSOCIATED(var%SCL_CHR)) WRITE(ipt,*) "ASSOCIATED  :: SCL_CHR"
     IF(ASSOCIATED(var%VEC_CHR)) WRITE(ipt,*) "ASSOCIATED  :: VEC_CHR"



     WRITE(ipt,*) "DIMS        ::",count_dim_list(var)
     WRITE(ipt,*) "ATTS        ::",count_att_list(var)
     WRITE(ipt,*) "======= PRINTED NCVAR TYPE ======"

  end if
END SUBROUTINE print_var
!====================================================================
!====================================================================
!====================== ATTRIBUTES ==================================
!====================================================================
!====================================================================
  FUNCTION new_att() RESULT(ATT)
    IMPLICIT NONE
!    CHARACTER(LEN=*),INTENT(IN)   :: NAME
    TYPE(ncatt), POINTER :: att
    integer status
    
    ALLOCATE(att,stat=status)
    if(status/=0) CALL fatal_error("NEW_ATT: COULD NOT ALLOCATE!")

!    ATT%ATTNAME   = NAME
    att%ATTNAME   = ' '
    att%LEN       = -1
    att%ATTID     = 0
    att%XTYPE     = -1
  END FUNCTION new_att
!====================================================================
!====================================================================
  FUNCTION new_attp() RESULT(ATTP)
    IMPLICIT NONE
    TYPE(ncattp), POINTER :: attp
    integer status
    
    ALLOCATE(attp,stat=status)
    if(status/=0) CALL fatal_error("NEW_ATTP COULD NOT ALLOCATE!")
    NULLIFY(attp%NEXT)
    NULLIFY(attp%ATT)

  END FUNCTION new_attp
!====================================================================
!====================================================================
  FUNCTION copy_att(ATTIN) RESULT(ATTOUT)
    IMPLICIT NONE
    TYPE(ncatt), POINTER, INTENT(IN) :: attin
    TYPE(ncatt), POINTER :: attout
    integer status
    
    IF(.not. Associated(attin)) CALL fatal_error("THE ARGUMENT MUST BE&
         & ASSOCIAED FOR COPY_ATT")


    attout=>new_att()

    attout%ATTNAME   = attin%ATTNAME
    attout%LEN       = attin%LEN 
    attout%ATTID     = attin%ATTID
    attout%XTYPE     = attin%XTYPE

    IF (Allocated(attin%int)) THEN
       ALLOCATE(attout%int(attin%LEN),stat=status)
       if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE INT!")
       attout%int = attin%int
    END IF

    IF (Allocated(attin%flt)) THEN
       ALLOCATE(attout%flt(attin%LEN),stat=status)
       if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE FLT!")
       attout%flt = attin%flt
    END IF

    IF (Allocated(attin%dbl)) THEN
       ALLOCATE(attout%dbl(attin%LEN),stat=status)
       if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE DBL!")
       attout%dbl = attin%dbl
    END IF

    IF (Allocated(attin%chr)) THEN
       ALLOCATE(attout%chr(size(attin%chr)),stat=status)
       if(status/=0) CALL fatal_error("COPY_ATT COULD NOT ALLOCATE CHR!")
       attout%chr = attin%chr
    END IF
    
  END FUNCTION copy_att
!====================================================================
!====================================================================
  SUBROUTINE copy_att_list(ATTPOUT,ATTPIN)
    IMPLICIT NONE
!    TYPE(NCATTP), POINTER, INTENT(IN) :: ATTPIN
!    TYPE(NCATTP), POINTER, INTENT(INOUT) :: ATTPOUT
    TYPE(ncattp), TARGET, INTENT(IN) :: ATTPIN
    TYPE(ncattp), TARGET, INTENT(OUT) :: ATTPOUT
    TYPE(ncatt), POINTER              :: ATT
    TYPE(ncattp),POINTER              :: CURRENT_IN, PREVIOUS_IN
    TYPE(ncattp),POINTER              :: CURRENT_OUT, PREVIOUS_OUT

    integer status
    
!!$    IF(.not. Associated(ATTPIN)) CALL FATAL_ERROR("THE INPUT ARGUMENT MUST BE&
!!$         & ASSOCIAED FOR COPY_ATT_LIST?")
!!$
!!$    IF(.not. Associated(ATTPOUT)) CALL FATAL_ERROR("THE OUTPUT ARGUMENT MUST BE&
!!$         & ASSOCIAED FOR COPY_ATT_LIST?")

    previous_in => attpin
    current_in => previous_in%NEXT

    previous_out => attpout
    current_out => previous_out%NEXT

    ! I DON'T THINK THAT CURRENT_OUT SERVES ANY PURPOSE HERE?
    ! I DON'T THINK THAT PREVIOUS_IN SERVES ANY PURPOSE HERE?
    
    
    DO
       IF(.NOT. ASSOCIATED(current_in)) THEN
          RETURN ! END OF ATT IN LIST
       END IF

       IF(.NOT. ASSOCIATED(current_in%ATT)) THEN
          CALL fatal_error("COPY_ATT_LIST: FOUND NULL DIM POINTER IN THE LIST")
       END IF
       
       previous_out%NEXT => new_attp()
       previous_out%NEXT%ATT => copy_att(current_in%ATT)
       previous_out%NEXT%NEXT => current_out
       
       ! INCRIMENT THROUGH THE LIST
       previous_out => previous_out%NEXT
       ! DO NOT INCRIMENT  CURRENT_OUT
       
       previous_in => previous_in%NEXT
       current_in  => current_in%NEXT
          
    END DO
    


  END SUBROUTINE copy_att_list
!====================================================================
!====================================================================
  SUBROUTINE delete_ncf_attp_byname(LIST,NAME,FOUND)
    IMPLICIT NONE
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    CHARACTER(LEN=*),INTENT(IN)   :: NAME
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncattp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( name == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_att(current%ATT)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_ncf_attp_byname
!====================================================================
!====================================================================
  SUBROUTINE delete_ncf_attp_byattid(LIST,ATTID,FOUND)
    IMPLICIT NONE
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    INTEGER,                       INTENT(IN)   :: ATTID
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncattp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_att(current%ATT)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_ncf_attp_byattid
!====================================================================
!====================================================================
  SUBROUTINE delete_ncf_attp_list(LIST)
    IMPLICIT NONE
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    TYPE(ncattp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%ATTS
    current  => previous%NEXT
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       ! IF FOUND DELETE IT
       previous%NEXT => current%NEXT
       CALL kill_att(current%ATT)
       DEALLOCATE(current)
       current => previous%NEXT

    END DO
   
  END SUBROUTINE delete_ncf_attp_list
!====================================================================
!====================================================================
  SUBROUTINE delete_var_attp_byname(LIST,NAME,FOUND)
    IMPLICIT NONE
    TYPE(ncvar),                   INTENT(INOUT):: LIST
!    CHARACTER(LEN=NF90_MAX_NAME+1),INTENT(IN)   :: NAME
    CHARACTER(LEN=*),INTENT(IN)   :: NAME
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncattp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( name == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_att(current%ATT)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_var_attp_byname
!====================================================================
!====================================================================
  SUBROUTINE delete_var_attp_byattid(LIST,ATTID,FOUND)
    IMPLICIT NONE
    TYPE(ncvar),                   INTENT(INOUT):: LIST
    INTEGER,                       INTENT(IN)   :: ATTID
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncattp), POINTER                       :: CURRENT, PREVIOUS
    
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_att(current%ATT)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_var_attp_byattid
!====================================================================
!====================================================================
  SUBROUTINE delete_var_attp_list(LIST)
    IMPLICIT NONE
    TYPE(ncvar), INTENT(INOUT):: LIST
    TYPE(ncattp),POINTER      :: CURRENT, PREVIOUS
    
    previous => list%ATTS
    current  => previous%NEXT

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       previous%NEXT => current%NEXT
       CALL kill_att(current%ATT)
       DEALLOCATE(current)
       current => previous%NEXT

    END DO

  END SUBROUTINE delete_var_attp_list
!====================================================================
!====================================================================
 SUBROUTINE kill_att(ATT)
   TYPE(ncatt),POINTER :: ATT
   INTEGER STATUS
   IF(ASSOCIATED(att)) THEN
      IF(ALLOCATED(att%INT)) DEALLOCATE(att%INT)
      IF(ALLOCATED(att%FLT)) DEALLOCATE(att%FLT)
      IF(ALLOCATED(att%DBL)) DEALLOCATE(att%DBL)
      IF(ALLOCATED(att%CHR)) DEALLOCATE(att%CHR)

      DEALLOCATE(att,stat=status)
      IF(status /= 0) CALL fatal_error("KILL_ATT: COULD NOT DEALLOCATE")
      NULLIFY(att)
   END IF

 END SUBROUTINE kill_att
!====================================================================
!====================================================================
!!$  SUBROUTINE INSERT_NCF_ATTP_BYNAME(LIST,NAME,FOUND)
!!$    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
!!$    ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
!!$    IMPLICIT NONE
!!$    CHARACTER(LEN=NF90_MAX_NAME+1),INTENT(IN)   :: NAME
!!$    LOGICAL,                       INTENT(OUT)  :: FOUND
!!$    TYPE(NCFILE),                  INTENT(INOUT):: LIST
!!$    TYPE(NCATTP)          ,POINTER              :: CURRENT, PREVIOUS
!!$    INTEGER CNT
!!$    PREVIOUS => LIST%ATTS
!!$    CURRENT  => PREVIOUS%NEXT
!!$    FOUND = .FALSE.
!!$    CNT = 1
!!$
!!$    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
!!$    DO
!!$       IF(.NOT. ASSOCIATED(CURRENT)) EXIT !END OF LIST
!!$       IF( NAME == CURRENT%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
!!$          FOUND = .TRUE.
!!$          RETURN
!!$       ELSE
!!$          PREVIOUS => PREVIOUS%NEXT
!!$          CURRENT  => CURRENT%NEXT
!!$          CNT = CNT + 1
!!$       END IF
!!$    END DO
!!$    ! NOT FOUND - ADD NEW FILE TO END OF LIST
!!$    CURRENT => NEW_ATTP()
!!$    CURRENT%ATT => NEW_ATT(NAME)
!!$    CURRENT%ATT%ATTID = CNT ! SET THE ATTID 
!!$
!!$  END SUBROUTINE INSERT_NCF_ATTP_BYNAME
!====================================================================
!====================================================================
  SUBROUTINE insert_ncf_attp_byatt(LIST,ATT,FOUND)
    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
    ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
    IMPLICIT NONE
    TYPE(ncatt), POINTER                        :: ATT
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    TYPE(ncattp),POINTER                        :: CURRENT, PREVIOUS
    INTEGER CNT
    IF(.NOT.ASSOCIATED(att))&
         & CALL fatal_error("INSERT_NCF_ATTP_BYATT: ATT NOT ASSOCIATED!")

    previous => list%ATTS
    current  => previous%NEXT
    found = .false.
    cnt= 1

    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       IF( att%ATTNAME == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          RETURN
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
          cnt = cnt + 1
       END IF
    END DO
    ! NOT FOUND - ADD NEW FILE TO END OF LIST
     
    previous%NEXT => new_attp()
    previous%NEXT%ATT => att
    att%ATTID = cnt ! SET THE ATTID 

    previous%NEXT%NEXT => current
    

  END SUBROUTINE insert_ncf_attp_byatt
!====================================================================
!====================================================================
!!$  SUBROUTINE INSERT_VAR_ATTP_BYNAME(LIST,NAME,FOUND)
!!$    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
!!$    ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
!!$    IMPLICIT NONE
!!$    CHARACTER(LEN=NF90_MAX_NAME+1),INTENT(IN)   :: NAME
!!$    LOGICAL,                       INTENT(OUT)  :: FOUND
!!$    TYPE(NCVAR),                   INTENT(INOUT):: LIST
!!$    TYPE(NCATTP)                        ,POINTER :: CURRENT, PREVIOUS
!!$    INTEGER CNT
!!$    PREVIOUS => LIST%ATTS
!!$    CURRENT  => PREVIOUS%NEXT
!!$    FOUND = .FALSE.
!!$    CNT = 1
!!$    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
!!$    DO
!!$       IF(.NOT. ASSOCIATED(CURRENT)) EXIT !END OF LIST
!!$       IF( NAME == CURRENT%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
!!$          FOUND = .TRUE.
!!$          RETURN
!!$       ELSE
!!$          PREVIOUS => PREVIOUS%NEXT
!!$          CURRENT  => CURRENT%NEXT
!!$          CNT = CNT + 1
!!$       END IF
!!$    END DO
!!$    ! NOT FOUND - ADD NEW FILE TO END OF LIST
!!$    CURRENT => NEW_ATTP()
!!$    CURRENT%ATT => NEW_ATT(NAME)
!!$    CURRENT%ATT%ATTID = CNT ! SET THE ATTID 
!!$  END SUBROUTINE INSERT_VAR_ATTP_BYNAME
!====================================================================
!====================================================================
  SUBROUTINE insert_var_attp_byatt(LIST,ATT,FOUND)
    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
    ! ALWAYS INSERT NCVARP AT THE END OF THE LIST
    IMPLICIT NONE
    TYPE(ncatt),POINTER                         :: ATT
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncvar),                   INTENT(INOUT):: LIST
    TYPE(ncattp),POINTER                        :: CURRENT, PREVIOUS
    INTEGER CNT
    IF(.NOT.ASSOCIATED(att))&
         & CALL fatal_error("INSERT_VAR_ATTP_BYATT: ATT NOT ASSOCIATED!")

    previous => list%ATTS
    current  => previous%NEXT
    found = .false.
    cnt = 1
    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       IF( att%ATTNAME == current%ATT%ATTNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          RETURN
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
          cnt = cnt + 1
       END IF
    END DO
    ! NOT FOUND - ADD NEW FILE TO END OF LIST
    previous%NEXT => new_attp()
    previous%NEXT%ATT => att

    att%ATTID = cnt ! SET THE ATTID 

  END SUBROUTINE insert_var_attp_byatt
!====================================================================
!====================================================================
  FUNCTION find_ncf_att_byname(LIST,NAME,FOUND) RESULT(ATT)
    IMPLICIT NONE
    TYPE(ncatt), POINTER               :: att
    TYPE(ncfile),         INTENT(IN):: list
    CHARACTER(LEN=*),INTENT(IN)    :: name
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncattp)               ,POINTER :: current, previous
    
    NULLIFY(att)
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( trim(name) == trim(current%ATT%ATTNAME) ) THEN ! FOUND THE FILE LINK
          att => current%ATT
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_ncf_att_byname
!====================================================================
!====================================================================
  FUNCTION find_ncf_att_byattid(LIST,ATTID,FOUND) RESULT(ATT)
    IMPLICIT NONE
    TYPE(ncatt), POINTER               :: att
    INTEGER,              INTENT(IN)   :: attid
    TYPE(ncfile),         INTENT(IN):: list
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncattp)               ,POINTER :: current, previous
    
    NULLIFY(att)
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
          att => current%ATT
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_ncf_att_byattid
!====================================================================
!====================================================================
  FUNCTION find_var_att_byname(LIST,NAME,FOUND) RESULT(ATT)
    IMPLICIT NONE
    TYPE(ncatt), POINTER               :: att
    TYPE(ncvar),         INTENT(IN) :: list
    CHARACTER(LEN=*),INTENT(IN)    :: name
    LOGICAL,             INTENT(OUT)   :: found
    TYPE(ncattp)               ,POINTER :: current, previous
    
    NULLIFY(att)
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( trim(name) == trim(current%ATT%ATTNAME) ) THEN ! FOUND THE FILE LINK
          att => current%ATT
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_var_att_byname
!====================================================================
!====================================================================
  FUNCTION find_var_att_byattid(LIST,ATTID,FOUND) RESULT(ATT)
    IMPLICIT NONE
    TYPE(ncatt), POINTER               :: att
    INTEGER,              INTENT(IN)   :: attid
    TYPE(ncvar),          INTENT(IN):: list
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncattp)               ,POINTER :: current, previous
    
    NULLIFY(att)
    previous => list%ATTS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( attid == current%ATT%ATTID ) THEN ! FOUND THE FILE LINK
          att => current%ATT
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_var_att_byattid
!====================================================================
!====================================================================
  FUNCTION count_ncf_att_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncfile),    INTENT(IN)        :: list
    TYPE(ncattp)               ,POINTER :: current, previous
    
    previous => list%ATTS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       previous => previous%NEXT
       current  => current%NEXT
       cnt = cnt + 1
    END DO
    
  END FUNCTION count_ncf_att_list
!====================================================================
!====================================================================
  FUNCTION count_var_att_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncvar),    INTENT(IN)         :: list
    TYPE(ncattp)               ,POINTER :: current, previous
    
    previous => list%ATTS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       previous => previous%NEXT
       current  => current%NEXT
       cnt = cnt + 1
    END DO
    
  END FUNCTION count_var_att_list
!====================================================================
!====================================================================
  SUBROUTINE print_ncf_att_list(LIST)
    IMPLICIT NONE
    type(ncfile), intent(IN)           :: LIST
    TYPE(ncattp)               ,POINTER :: CURRENT, PREVIOUS
    INTEGER                            :: CNT
    Character(len=4)                   :: chr

    previous => list%ATTS
    current  => previous%NEXT

    IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% FILE ATTRIBUTE LIST IS EMPTY %%%%%%%%%%%%%"
       RETURN
    ELSE
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%% PRINTING GLOBAL ATTRIBUTE LIST %%%%%%%%%"
    END IF
    
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1
       write(chr,'(I4.4)')cnt
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"! PRINTING ATTRIBUTE LIST ENTRY #"//chr
       CALL print_att(current%ATT)

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    if(dbg_set(dbg_log)) &
         & write(ipt,*)"%%%%%%%%%%% END OF ATTRIBUTE LIST %%%%%%%%%%%%%"
  END SUBROUTINE print_ncf_att_list
!====================================================================
!====================================================================
  SUBROUTINE print_var_att_list(LIST)
    IMPLICIT NONE
    type(ncvar), intent(IN)            :: LIST
    TYPE(ncattp)               ,POINTER :: CURRENT, PREVIOUS
    INTEGER                            :: CNT
    Character(len=4)                   :: chr

    previous => list%ATTS
    current  => previous%NEXT

    IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%% VAIABLE ATTRIBUTE LIST IS EMPTY %%%%%%%%%%"
       RETURN
    ELSE
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%% PRINTING VARIALBE: "//trim(list%VARNAME)//"&
            &; ATTRIBUTE LIST %%%%%%%%"
    END IF
    
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1
       write(chr,'(I4.4)')cnt
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"! PRINTING ATTRIBUTE LIST ENTRY #"//chr
       CALL print_att(current%ATT)

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    if(dbg_set(dbg_log)) &
         & write(ipt,*)"%%%%%%%%%%% END OF ATTRIBUTE LIST %%%%%%%%%%%%%"
  END SUBROUTINE print_var_att_list
!====================================================================
!====================================================================
SUBROUTINE print_att(ATT)
  implicit none
  type(ncatt), pointer, intent(IN) :: ATT
  integer I

  if(dbg_set(dbg_log)) then
     WRITE(ipt,*) "======== PRINT NCATT TYPE ======="
     if(.not. associated(att)) then
        WRITE(ipt,*) "THIS NCATT HAS NOT BEEN ASSOCIATED"
        WRITE(ipt,*) "======= PRINTED NCATT TYPE ======"
        return
     end if
     WRITE(ipt,*) "ATTNAME::"//trim(att%ATTNAME)
     WRITE(ipt,*) "LEN    ::",att%LEN
     WRITE(ipt,*) "ATTID  ::",att%ATTID
     select case(att%XTYPE)
     case(nf90_char)
        WRITE(ipt,*) "XYTPE  ::CHAR"
        IF (.not. Allocated(att%chr)) then
           WRITE(ipt,*) "CHAR   :: Not allocated!"
        ELSE
           DO i = 1,size(att%chr)
              WRITE(ipt,*) "CHAR   ::"//trim(att%chr(i))
           END DO
        END IF
     case(nf90_byte)
        WRITE(ipt,*) "XYTPE  ::BYTE - TYPE NOT DEFINED"
     case(nf90_short)
        WRITE(ipt,*) "XYTPE  ::SHORT - TYPE NOT DEFINED"
     case(nf90_int)
        WRITE(ipt,*) "XYTPE  ::INT"
        IF (.not. Allocated(att%int)) then
           WRITE(ipt,*) "INT    :: Not allocated!"
        ELSE
           write(ipt,'(I8)') att%int
        END IF
     case(nf90_float)
        WRITE(ipt,*) "XYTPE  ::FLOAT"
        IF (.not. Allocated(att%flt)) then
           WRITE(ipt,*) "FLOAT  :: Not allocated!"
        ELSE
           write(ipt,'(ES14.3)') att%flt
        END IF
     case(nf90_double)
        WRITE(ipt,*) "XYTPE  ::DOUBLE"
        IF (.not. Allocated(att%DBL)) then
           WRITE(ipt,*) "DOUBLE :: Not allocated!"
        ELSE
           write(ipt,'(ES14.3)') att%dbl
        END IF
     END select
     WRITE(ipt,*) "======= PRINTED NCATT TYPE ======"
  end if
END SUBROUTINE print_att
!====================================================================
!====================================================================
!====================== DIMENSIONS ==================================
!====================================================================
!====================================================================
  FUNCTION new_dim() RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER :: dim
    integer status
    
    ALLOCATE(dim,stat=status)
    if(status/=0) CALL fatal_error("ALLOC_DIM: COULD NOT ALLOCATE!")

    dim%DIMID     = -1
    dim%DIMNAME   =" "
    dim%DIM       = -1
    dim%UNLIMITED = .false.
  END FUNCTION new_dim
!====================================================================
!====================================================================
  SUBROUTINE copy_dim_list(DIMPOUT,DIMPIN)
    IMPLICIT NONE
!    TYPE(NCDIMP),POINTER,INTENT(INOUT):: DIMPOUT
!    TYPE(NCDIMP), POINTER, INTENT(IN) :: DIMPIN
    TYPE(ncdimp),TARGET, INTENT(OUT):: DIMPOUT
    TYPE(ncdimp), TARGET, INTENT(IN) :: DIMPIN
    TYPE(ncdim), POINTER              :: DIM
    TYPE(ncdimp),POINTER              :: CURRENT_IN, PREVIOUS_IN
    TYPE(ncdimp),POINTER              :: CURRENT_OUT, PREVIOUS_OUT

    integer status
    
!!$    IF(.not. Associated(DIMPIN)) CALL FATAL_ERROR("THE INPUT ARGUMENT MUST BE&
!!$         & ASSOCIAED FOR COPY_DIM_LIST?")
!!$
!!$    IF(.not. Associated(DIMPOUT)) CALL FATAL_ERROR("THE OUTPUT ARGUMENT MUST BE&
!!$         & ASSOCIAED FOR COPY_DIM_LIST?")

    previous_in => dimpin
    current_in => previous_in%NEXT

!    DIMPOUT => NEW_DIMP()
    previous_out => dimpout
    current_out => previous_out%NEXT

    ! I DON'T THINK THAT CURRENT_OUT SERVES ANY PURPOSE HERE?
    ! I DON'T THINK THAT PREVIOUS_IN SERVES ANY PURPOSE HERE?
    
    
    DO
       IF(.NOT. ASSOCIATED(current_in)) THEN
          RETURN ! END OF DIM IN LIST
       END IF
       
       IF(.NOT. ASSOCIATED(current_in%DIM)) THEN
          CALL fatal_error("COPY_DIM_LIST: FOUND NULL DIM POINTER IN THE LIST")
       END IF
       
       previous_out%NEXT => new_dimp()
       previous_out%NEXT%DIM => copy_dim(current_in%DIM)
       previous_out%NEXT%NEXT => current_out
       
       ! INCRIMENT THROUGH THE LIST
       previous_out => previous_out%NEXT
       ! DO NOT INCRIMENT  CURRENT_OUT
       
       previous_in => previous_in%NEXT
       current_in  => current_in%NEXT
       
    END DO
    


  END SUBROUTINE copy_dim_list
!====================================================================
!====================================================================
  FUNCTION copy_dim(DIMIN) RESULT(DIMOUT)
    IMPLICIT NONE
    TYPE(ncdim), POINTER, INTENT(IN) :: dimin
    TYPE(ncdim), POINTER :: dimout
    integer status
    
    IF(.not. Associated(dimin)) CALL fatal_error("THE ARGUMENT MUST BE&
         & ASSOCIAED FOR COPY_DIM?")

    dimout => new_dim()

    dimout%DIMID     = dimin%DIMID
    dimout%DIMNAME   = dimin%DIMNAME
    dimout%DIM       = dimin%DIM
    dimout%UNLIMITED = dimin%UNLIMITED
  END FUNCTION copy_dim
!====================================================================
!====================================================================
  FUNCTION new_dimp() RESULT(DIMP)
    IMPLICIT NONE
    TYPE(ncdimp), POINTER :: dimp
    integer status
    
    NULLIFY(dimp)
    ALLOCATE(dimp,stat=status)
    if(status/=0) CALL fatal_error("ALLOC_NCDIMP COULD NOT ALLOCATE!")
    NULLIFY(dimp%NEXT)
    NULLIFY(dimp%DIM)

  END FUNCTION new_dimp
!====================================================================
!====================================================================
  SUBROUTINE delete_ncf_dimp_byname(LIST,NAME,FOUND)
    IMPLICIT NONE
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    CHARACTER(LEN=*),INTENT(IN)   :: NAME
    LOGICAL,                       INTENT(OUT)  :: FOUND
    LOGICAL                                     :: F1
    TYPE(ncdimp)                        ,POINTER :: CURRENT, PREVIOUS
    TYPE(ncvarp)                        ,POINTER :: CURRENT_VAR
    
    current_var => list%VARS%NEXT    
    DO 
       IF(.NOT. ASSOCIATED(current_var)) RETURN !END OF LIST

       IF(.NOT. ASSOCIATED(current_var%VAR)) THEN
          CALL fatal_error("DELETE_NCF_DIMP_BYNAME: NULL VAR POINTER IN FILE LIST?")
       END IF

      CALL delete_dim_link(current_var%VAR,name,f1)

      current_var => current_var%NEXT
   END DO


    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( name == current%DIM%DIMNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_dim(current%DIM)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_ncf_dimp_byname
!====================================================================
!====================================================================
  SUBROUTINE delete_ncf_dimp_bydimid(LIST,DIMID,FOUND)
    IMPLICIT NONE
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    INTEGER,                       INTENT(IN)   :: DIMID
    LOGICAL,                       INTENT(OUT)  :: FOUND
    LOGICAL                                     :: F1
    TYPE(ncdimp)                        ,POINTER :: CURRENT, PREVIOUS
    TYPE(ncvarp)                        ,POINTER :: CURRENT_VAR
    
    current_var => list%VARS%NEXT    
    DO 
       IF(.NOT. ASSOCIATED(current_var)) RETURN !END OF LIST

       IF(.NOT. ASSOCIATED(current_var%VAR)) THEN
          CALL fatal_error("DELETE_NCF_DIMP_BYDIMID: NULL VAR POINTER IN FILE LIST?")
       END IF

      CALL delete_dim_link(current_var%VAR,dimid,f1)

      current_var => current_var%NEXT
   END DO



    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT
    CALL kill_dim(current%DIM)
    DEALLOCATE(current)
   
  END SUBROUTINE delete_ncf_dimp_bydimid
!====================================================================
!====================================================================
  SUBROUTINE delete_ncf_dimp_list(LIST)
    IMPLICIT NONE
    TYPE(ncfile),                  INTENT(INOUT):: LIST
    TYPE(ncdimp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%DIMS
    current  => previous%NEXT
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       ! IF FOUND DELETE IT
       previous%NEXT => current%NEXT
       CALL kill_dim(current%DIM)
       DEALLOCATE(current)
       current => previous%NEXT

    END DO
    
  END SUBROUTINE delete_ncf_dimp_list
!====================================================================
!====================================================================
  SUBROUTINE delete_var_dimp_byname(LIST,NAME,FOUND)
    IMPLICIT NONE
    TYPE(ncvar),                   INTENT(INOUT):: LIST
    CHARACTER(LEN=*),INTENT(IN)   :: NAME
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncdimp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       IF(.NOT. ASSOCIATED(current%DIM))THEN 
          !       CALL PRINT_VAR(LIST)
          CALL fatal_error("DELETE_VAR_DIMP_BYNAME: VARIABLE HAS UNASSOCIATED DIMENSION IN LIST?")
       END IF
       
       IF( name == current%DIM%DIMNAME ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT

    IF(current%DIM%DIMID==-1) THEN
       call kill_dim(current%DIM) ! IT BELONGS TO THE VAR ONLY, NOT PART
       ! OF A FILE
    ELSE
       NULLIFY(current%DIM) ! DO NOT DEALLOCATE POINTER TO ACTUAL
       ! DIMENSION, IT BELONGS TO A FILE
    END IF

    DEALLOCATE(current)
   
  END SUBROUTINE delete_var_dimp_byname
!====================================================================
!====================================================================
! THIS METHOD WILL NOT WORK FOR VARIABLES WHICH HAVE NOT BEEN
  ! ASSIGNED TO A FILE BECAUSE THE ID WILL STILL BE -1. ONLY AFTER
  ! DIMS ARE ASSIGNED TO A VARIABLE ARE THEY GIVEN AND ID NUMBER
  SUBROUTINE delete_var_dimp_bydimid(LIST,DIMID,FOUND)
    IMPLICIT NONE
    TYPE(ncvar),                   INTENT(INOUT):: LIST
    INTEGER,                       INTENT(IN)   :: DIMID
    LOGICAL,                       INTENT(OUT)  :: FOUND
    TYPE(ncdimp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       IF(.NOT. ASSOCIATED(current%DIM))THEN 
          !       CALL PRINT_VAR(LIST)
          CALL fatal_error("DELETE_VAR_DIMP_BYDIMID: VARIABLE HAS UNASSOCIATED DIMENSION IN LIST?")
       END IF
    
       IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE FILE LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

    ! IF FOUND DELETE IT
    previous%NEXT => current%NEXT

    IF(current%DIM%DIMID==-1) THEN
       call kill_dim(current%DIM) ! IT BELONGS TO THE VAR ONLY, NOT PART
       ! OF A FILE
    ELSE
       NULLIFY(current%DIM) ! DO NOT DEALLOCATE POINTER TO ACTUAL
       ! DIMENSION, IT BELONGS TO A FILE
    END IF
    DEALLOCATE(current)
  END SUBROUTINE delete_var_dimp_bydimid
!====================================================================
!====================================================================
  SUBROUTINE delete_var_dimp_list(LIST)
    IMPLICIT NONE
    TYPE(ncvar),                   INTENT(INOUT):: LIST
    TYPE(ncdimp)                        ,POINTER :: CURRENT, PREVIOUS
    
    previous => list%DIMS
    current  => previous%NEXT

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       previous%NEXT => current%NEXT
       IF(.NOT. ASSOCIATED(current%DIM))THEN 
!          CALL PRINT_VAR(LIST)
          CALL fatal_error("VARIABLE HAS UNASSOCIATED DIMENSION IN LIST?")
       END IF

       IF(current%DIM%DIMID==-1) THEN
          call kill_dim(current%DIM) ! IT BELONGS TO THE VAR ONLY, NOT PART
          ! OF A FILE
       ELSE
          NULLIFY(current%DIM) ! DO NOT DEALLOCATE POINTER, IT
          ! BELONGS TO A FILE
       END IF
       
       DEALLOCATE(current)
       current => previous%NEXT

    END DO

  END SUBROUTINE delete_var_dimp_list
!====================================================================
!====================================================================
 SUBROUTINE kill_dim(DIM)
   TYPE(ncdim),POINTER :: DIM
   INTEGER STATUS
   DEALLOCATE(dim,stat=status)
   IF(status /= 0) CALL fatal_error("KILL_DIM: COULD NOT DEALLOCATE")
   NULLIFY(dim)

 END SUBROUTINE kill_dim
!====================================================================
!====================================================================

! INSERT_NCF_DIMP_BYNAME IS DANGEROUS AND DOES NOT EXIST

!====================================================================
!====================================================================
  SUBROUTINE insert_ncf_dimp_bydim(LIST,DIM,FOUND)
    ! IF FOUND DO NOT INSERT DUPLICATE, RETURN FOUND
    ! INSERT UNLIMDIM AT THE END OF THE LIST
    ! INSERT NONE UNLIMDIM IN THE ORDER ADDED  
    IMPLICIT NONE
    TYPE(ncdim), POINTER              :: DIM
    LOGICAL,             INTENT(OUT)  :: FOUND
    TYPE(ncfile),        INTENT(INOUT):: LIST
    TYPE(ncdimp),POINTER              :: CURRENT, PREVIOUS
    INTEGER CNT
    IF(.NOT.ASSOCIATED(dim))&
         & CALL fatal_error("INSERT_NCF_DIMP_BYDIM: DIM NOT ASSOCIATED!")

    previous => list%DIMS
    current  => previous%NEXT
    found = .false.
    cnt = 1

!!$    IF (DIM%UNLIMITED) THEN ! ADD AT END OF LIST!
    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST, ADD DIM
       
       IF( dim%DIMNAME == current%DIM%DIMNAME) THEN
          ! PROTECT AGAINST USER ERROR - MISMATCHED DIMENSIONS!
          IF(dim%DIM .NE. current%DIM%DIM) &
               & CALL fatal_error("ATEMPTED TO ADD DIMENSION NAMED:"//trim(dim%DIMNAME),&
               & "BUT THAT DIMENSION NAME ALREADY EXISTS WITH A DIFFERENT SIZE")
          
          ! PROTECT AGAINST USER ERROR - MISMATCHED UNLIMITED DIMENSIONS!
          IF(dim%UNLIMITED .AND. .NOT. current%DIM%UNLIMITED)&
               & CALL fatal_error("ATEMPTED TO ADD DIMENSION NAMED:&
               &"//trim(dim%DIMNAME)//"; AS UNLIMITED",&
               & "BUT THAT DIMENSION NAME ALREADY EXISTS AS NOT UNLIMITED")

          IF(.NOT. dim%UNLIMITED .AND. current%DIM%UNLIMITED)&
               & CALL fatal_error("ATEMPTED TO ADD DIMENSION NAMED:&
               &"//trim(dim%DIMNAME)//"; AS NOT UNLIMITED",&
               & "BUT THAT DIMENSION NAME ALREADY EXISTS AS UNLIMITED")
          
          found = .true.
          RETURN ! DIMENSION ALREADY EXISTS
       ELSE IF(dim%UNLIMITED .AND. current%DIM%UNLIMITED) THEN 
          CALL fatal_error("ATTEMPT TO PUT A SECOND UNLIMITED DIMENSIO&
               &N IN THE FILE OBJECT","DIMENSION NAME: "//trim(dim%DIMNAME))
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
          cnt = cnt +1
       END IF
    END DO
    ! NOT FOUND - ADD NEW DIM TO END OF LIST
    
    previous%NEXT => new_dimp()
    previous%NEXT%DIM => dim
    previous%NEXT%NEXT => current
    
    dim%DIMID = cnt ! SET THE DIMID OF THE NEW DIMENSION

    IF(dim%UNLIMITED) list%UNLIMDIMID = dim%DIMID
    
!!$ ELSE ! NOT AN UNLIMITED DIMENSION - ADD BEFORE ANY UNLIMITED DIMENSION
!!$    ! DO NOT MAKE DUPLICATE ENTRIES IN THE LIST
!!$    DO
!!$          IF(.NOT. ASSOCIATED(CURRENT)) EXIT !END OF LIST, ADD DIM TO END OF LIST
!!$          
!!$          IF( DIM%DIMNAME == CURRENT%DIM%DIMNAME) THEN
!!$             ! PROTECT AGAINST USER ERROR - MISMATCHED DIMENSIONS!
!!$             IF(DIM%DIM .NE. CURRENT%DIM%DIM) &
!!$                  & CALL FATAL_ERROR("ATEMPTED TO ADD DIMENSION NAMED:"//TRIM(DIM%DIMNAME),&
!!$                  & "BUT THAT DIMENSION NAME ALREADY EXISTS WITH A DIFFERENT SIZE")
!!$
!!$             ! PROTECT AGAINST USER ERROR - MISMATCHED UNLIMITED DIMENSIONS!
!!$             IF(CURRENT%DIM%UNLIMITED)&
!!$                  & CALL FATAL_ERROR("ATEMPTED TO ADD DIMENSION NAMED:&
!!$                  &"//TRIM(DIM%DIMNAME)//"; AS NOT UNLIMITED",&
!!$                  & "BUT THAT DIMENSION NAME ALREADY EXISTS AS UNLIMITED")
!!$
!!$             FOUND = .TRUE.
!!$             RETURN ! DIMENSION ALREADY EXISTS
!!$          ELSE IF(CURRENT%DIM%UNLIMITED) THEN ! FOUND THE UNLIMITED DIMENSION
!!$             IF(ASSOCIATED(CURRENT%NEXT)) &
!!$                  & CALL FATAL_ERROR("FOUND EXTRA DIMENSION LINK AFTER&
!!$                  & THE UNLIMITED DIMENSION", "WHILE ADDING NEW DIMENSION: "&
!!$                  &//TRIM(DIM%DIMNAME) )
!!$             
!!$             CURRENT%DIM%DIMID = CNT+1 ! INCRIMENT THE UNLIMITED DIMENSIONS DIMID
!!$             EXIT              ! Add the new dimension
!!$
!!$          ELSE
!!$             PREVIOUS => PREVIOUS%NEXT
!!$             CURRENT  => CURRENT%NEXT
!!$             CNT = CNT+1
!!$          END IF
!!$       END DO
!!$       ! NOT FOUND - INSERT DIM INTO LIST
!!$
!!$       PREVIOUS%NEXT => NEW_DIMP()
!!$       PREVIOUS%NEXT%DIM => DIM
!!$       DIM%DIMID = CNT  ! SET THE DIMID OF THE NEW DIMENSION
!!$
!!$       PREVIOUS%NEXT%NEXT => CURRENT
!!$    END IF

  END SUBROUTINE insert_ncf_dimp_bydim
!====================================================================
!====================================================================

! INSERT_VAR_DIMP_BYNAME IS DANGEROUS AND DOES NOT EXIST

!====================================================================
!====================================================================
  SUBROUTINE insert_var_dimp_bydim(LIST,DIM,FOUND)
    ! ALLOW NETCDF TO HAVE DUPLICATE DIMENSIONS IN A VARIABLE
    ! INSERT DIMS IN THE ORDER THEY ARE ADDED
    !
    ! DO NOT TOUCH DIMID - IT IS ONLY SET WHEN THE VARIABLE'S
    ! DIMENSIONS ARE POINTED TO THE FILES DIMENSIONS

    IMPLICIT NONE
    TYPE(ncdim), POINTER              :: DIM
    LOGICAL,             INTENT(OUT)  :: FOUND
    TYPE(ncvar),         INTENT(INOUT):: LIST
    TYPE(ncdimp),POINTER              :: CURRENT, PREVIOUS

    IF(.NOT.ASSOCIATED(dim))&
         & CALL fatal_error("INSERT_NCF_DIMP_BYDIM: DIM NOT ASSOCIATED!")

    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) THEN
          EXIT !END OF LIST, ADD DIM
       ELSE
          
          IF( dim%DIMNAME == current%DIM%DIMNAME) found = .true.
          
          IF(dim%UNLIMITED .AND. current%DIM%UNLIMITED) &
               & CALL fatal_error("ATTEMPT TO PUT A SECOND UNLIMITED DIMENSIO&
               &N IN THE VARIALBE NAME:"//trim(list%VARNAME),&
               & "DIMENSION NAME: "//trim(dim%DIMNAME))

          ! MAKE AN EXCEPTION FOR CHARACTER DATA?!?!
          IF(current%DIM%UNLIMITED .AND. list%XTYPE .NE. nf90_char) &
               & CALL fatal_error("ATTEMPT TO PUT A DIMENSION AFTER THE UNLIMITED DIMENSIO&
               &N IN THE VARIALBE NAME:"//trim(list%VARNAME),&
               & "DIMENSION NAME: "//trim(dim%DIMNAME),"THE USER MUST &
               &ADD DIMENSION IN THE CORRECT ORDER! (UNLIMITEDS GO LAS&
               &T IN FORTRAN ORDER)")


          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO
    ! NOT FOUND - ADD NEW DIM TO END OF LIST, EVEN IF IT ALREADY
    ! EXISTS!
    previous%NEXT => new_dimp()
    previous%NEXT%DIM => dim
    previous%NEXT%NEXT => current

  END SUBROUTINE insert_var_dimp_bydim
!====================================================================
!====================================================================
  FUNCTION find_ncf_dim_byname(LIST,NAME,FOUND) RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER               :: dim
    TYPE(ncfile),         INTENT(IN)   :: list
    CHARACTER(LEN=*),INTENT(IN)    :: name
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    NULLIFY(dim)
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( trim(name) == trim(current%DIM%DIMNAME) ) THEN ! FOUND THE FILE LINK
          dim => current%DIM
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_ncf_dim_byname
!====================================================================
!====================================================================
  FUNCTION find_ncf_dim_bydimid(LIST,DIMID,FOUND) RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER               :: dim
    INTEGER,              INTENT(IN)   :: dimid
    TYPE(ncfile),         INTENT(IN):: list
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    NULLIFY(dim)
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE DIM LINK
          dim => current%DIM
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_ncf_dim_bydimid
!====================================================================
!====================================================================
  FUNCTION find_ncf_dim_unlimited(LIST,FOUND) RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER               :: dim
    TYPE(ncfile),         INTENT(IN):: list
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    NULLIFY(dim)
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
          dim => current%DIM
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_ncf_dim_unlimited
!====================================================================
!====================================================================
  FUNCTION has_unlimited_ncf(LIST) RESULT(FOUND)
    IMPLICIT NONE
    TYPE(ncfile),         INTENT(IN):: list
    LOGICAL                        :: found
    TYPE(ncdimp)           ,POINTER :: current, previous
    
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION has_unlimited_ncf
!====================================================================
!====================================================================
  FUNCTION find_var_dim_byname(LIST,NAME,FOUND) RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER               :: dim
    TYPE(ncvar),          INTENT(IN)   :: list
    CHARACTER(LEN=*),INTENT(IN)    :: name
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    NULLIFY(dim)
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( trim(name) == trim(current%DIM%DIMNAME) ) THEN ! FOUND THE FILE LINK
          dim => current%DIM
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_var_dim_byname
!====================================================================
!====================================================================
  FUNCTION find_var_dim_bydimid(LIST,DIMID,FOUND) RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER               :: dim
    INTEGER,              INTENT(IN)   :: dimid
    TYPE(ncvar),          INTENT(IN)   :: list
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    NULLIFY(dim)
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF( dimid == current%DIM%DIMID ) THEN ! FOUND THE DIM LINK
          dim => current%DIM
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_var_dim_bydimid
!====================================================================
!====================================================================
  FUNCTION find_var_dim_unlimited(LIST,FOUND) RESULT(DIM)
    IMPLICIT NONE
    TYPE(ncdim), POINTER               :: dim
    TYPE(ncvar),          INTENT(IN)   :: list
    LOGICAL,              INTENT(OUT)  :: found
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    NULLIFY(dim)
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
          dim => current%DIM
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION find_var_dim_unlimited
!====================================================================
!====================================================================
  FUNCTION has_unlimited_var(LIST) RESULT(FOUND)
    IMPLICIT NONE
    TYPE(ncvar),          INTENT(IN)   :: list
    LOGICAL                            :: found
    TYPE(ncdimp)              ,POINTER :: current, previous
    
    previous => list%DIMS
    current  => previous%NEXT
    found = .false.

    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       
       IF(current%DIM%UNLIMITED ) THEN ! FOUND THE DIM LINK
          found = .true.
          EXIT
       ELSE
          previous => previous%NEXT
          current  => current%NEXT
       END IF
    END DO

  END FUNCTION has_unlimited_var
!====================================================================
!====================================================================
  FUNCTION var_dimids(LIST) RESULT(DIMIDS)
    TYPE(ncvar), INTENT(IN) :: list
    INTEGER, POINTER        :: dimids(:)
    TYPE(ncdimp),POINTER    :: current, previous
    INTEGER                 :: cnt, status, sz

    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
    ALLOCATE(dimids(count_dim_list(list)),stat=status)
    if(status /= 0) CALL fatal_error("VAR_DIMIDS: Can not allocate DIMIDS")

    IF(SIZE(dimids)==0) RETURN

    dimids=0

    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1       

       dimids(cnt) = current%DIM%DIMID
       
       previous => previous%NEXT
       current  => current%NEXT
       
    END DO

    if(cnt .NE. count_dim_list(list)) CALL fatal_error&
         &("VAR_DIMIDS: THE NUMBER OF DIMENSION OBJECTS IN THE VARIABL&
         &ES LIST EXCEEDS THE VARIABLES NDIMS PROPERTY")


  END FUNCTION var_dimids
!====================================================================
!====================================================================
  FUNCTION var_dims(LIST) RESULT(DIMS)
    TYPE(ncvar), INTENT(IN) :: list
    INTEGER, POINTER        :: dims(:)
    TYPE(ncdimp),POINTER    :: current, previous
    INTEGER                 :: cnt, status

    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
    ALLOCATE(dims(count_dim_list(list)),stat=status)
    if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate DIMS")

    IF(SIZE(dims)==0) RETURN

    dims=0

    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt= cnt+1

       dims(cnt) = current%DIM%DIM
       
       previous => previous%NEXT
       current  => current%NEXT
       
    END DO

    if(cnt .NE. count_dim_list(list)) CALL fatal_error&
         &("VAR_DIMS: THE NUMBER OF DIMENSION OBJECTS IN THE VARIABL&
         &ES LIST EXCEEDS THE VARIABLES NDIMS PROPERTY")


  END FUNCTION var_dims
!====================================================================
!====================================================================
  FUNCTION mem_dims(LIST) RESULT(DIMS)
    TYPE(ncvar), INTENT(IN) :: list
    INTEGER, POINTER        :: dims(:)
    TYPE(ncdimp),POINTER    :: current, previous
    INTEGER                 :: cnt, status

    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
!    ALLOCATE(DIMS(COUNT_DIM_LIST(LIST)),stat=status)

    ALLOCATE(dims(count_nonsingleton_dim_list(list)),stat=status)
    if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate DIMS")

    IF(SIZE(dims)==0) RETURN

    dims=0

    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt= cnt+1

       dims(cnt) = current%DIM%DIM
       
       previous => previous%NEXT
       current  => current%NEXT
       
    END DO

    if(cnt .NE. count_dim_list(list)) CALL fatal_error&
         &("VAR_DIMS: THE NUMBER OF DIMENSION OBJECTS IN THE VARIABL&
         &ES LIST EXCEEDS THE VARIABLES NDIMS PROPERTY")


  END FUNCTION mem_dims
!====================================================================
!====================================================================
  FUNCTION count_ncf_ns_dim_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncfile),    INTENT(IN)        :: list
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       ! DO NOT COUNT SINGLETON DIMENSIONS
       IF(current%DIM%DIM .GT. 1) cnt = cnt + 1

       previous => previous%NEXT
       current  => current%NEXT
       
    END DO
    
  END FUNCTION count_ncf_ns_dim_list
!====================================================================
!====================================================================
  FUNCTION count_var_ns_dim_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncvar),     INTENT(IN)        :: list
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST

       ! DO NOT COUNT SINGLETON DIMENSIONS
       IF(current%DIM%DIM .GT. 1) cnt = cnt + 1

       previous => previous%NEXT
       current  => current%NEXT

    END DO
    
  END FUNCTION count_var_ns_dim_list
!====================================================================
!====================================================================
  SUBROUTINE alloc_var(VAR,MYDIMS)
    IMPLICIT NONE
    TYPE(ncvar),INTENT(INOUT), POINTER :: VAR
    INTEGER,OPTIONAL,INTENT(OUT) :: MYDIMS
    TYPE(ncdim), POINTER :: DIM
    TYPE(ncvar), POINTER :: VAR_TMP

    INTEGER :: Ndims
    INTEGER, POINTER :: DIMS(:)
    LOGICAL :: FOUND
    INTEGER :: STATUS

    NULLIFY(dim,dims)

    IF(dbg_set(dbg_sbr)) WRITE(ipt,*) "START: ALLOC_VAR"

    IF(.not. ASSOCIATED(var))CALL fatal_error&
            & ("ALLOC_VAR: Unassociated Var!")
    
    ! GET RID OF TIME AND SINGLETON DIMENSIONS WHEN ALLOCATING SPACE
    var_tmp => copy_var(var)

    dim => find_unlimited(var_tmp,found)
    IF (found) THEN
       CALL delete_dim_link(var_tmp,dim%DIMID,found)
    END IF

    dims => mem_dims(var_tmp)

    IF(.not. Associated(dims)) CALL fatal_error("ALLOC_VAR: Could not allocate Dims?")
    ndims=size(dims)
    IF(PRESENT(mydims)) mydims = ndims

    CALL kill_var(var_tmp)
    

    IF(dbg_set(dbg_sbrio)) WRITE(ipt,*) "ALLOCATING SPACE FOR:"

    select case(var%XTYPE)
    case(nf90_char)
       IF(dbg_set(dbg_sbrio)) THEN
          WRITE(ipt,*) "XYTPE       :: CHAR"
          WRITE(ipt,*) "DIMS       ::",dims
       END IF

       SELECT CASE(ndims)
       CASE(2)
          ALLOCATE(var%VEC_CHR(dims(2)),stat=status)
          if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate VEC_CHR")
          var%VEC_CHR=""
       CASE(1)
          ALLOCATE(var%SCL_CHR,stat=status)
          if(status /= 0) CALL fatal_error("VAR_DIMS: Can not allocate SCL_CHR")
          var%SCL_CHR=""
       CASE(0)
          CALL fatal_error("Unsupported Character data dimension: 0")
       CASE DEFAULT
          CALL fatal_error("Unsupported Character data dimension")
       END SELECT

    case(nf90_byte)
       WRITE(ipt,*) "XYTPE       :: BYTE"
       CALL fatal_error("No Byte Type Available")

    case(nf90_short)
       WRITE(ipt,*) "XYTPE       :: SHORT"
       CALL fatal_error("No Short Type Available")

    case(nf90_int)
       IF(dbg_set(dbg_sbrio)) THEN
          WRITE(ipt,*) "XYTPE       :: INT"
          WRITE(ipt,*) "dims       ::",dims
       END IF


       SELECT CASE(ndims)
       CASE(4)
          ALLOCATE(var%FDA_INT(0:dims(1),dims(2),dims(3),dims(4)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_FDA")
          var%FDA_INT=0
       CASE(3)
          ALLOCATE(var%CUB_INT(0:dims(1),dims(2),dims(3)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_CUB")
          var%CUB_INT=0
       CASE(2)
          ALLOCATE(var%ARR_INT(0:dims(1),dims(2)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_ARR")
          var%ARR_INT=0
       CASE(1)
          ALLOCATE(var%VEC_INT(0:dims(1)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_VEC")
          var%VEC_INT=0
       CASE(0)
          ALLOCATE(var%SCL_INT,stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate INT_SCL")
          var%SCL_INT=0
       CASE DEFAULT
          CALL fatal_error("Unsupported Integer data dimension")
       END SELECT


    case(nf90_float)
       IF(dbg_set(dbg_sbrio)) THEN
          WRITE(ipt,*) "XYTPE       :: FLOAT"
          WRITE(ipt,*) "dims       ::",dims
       END IF

       SELECT CASE(ndims)
       CASE(4)
          ALLOCATE(var%FDA_FLT(0:dims(1),dims(2),dims(3),dims(4)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_FDA")
          var%FDA_FLT=0.0_spa
       CASE(3)
          ALLOCATE(var%CUB_FLT(0:dims(1),dims(2),dims(3)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_CUB")
          var%CUB_FLT=0.0_spa
       CASE(2)
          ALLOCATE(var%ARR_FLT(0:dims(1),dims(2)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_ARR")
          var%ARR_FLT=0.0_spa
       CASE(1)
          ALLOCATE(var%VEC_FLT(0:dims(1)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_VEC")
          var%VEC_FLT=0.0_spa
       CASE(0)
          ALLOCATE(var%SCL_FLT,stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate FLT_SCL")
          var%SCL_FLT=0.0_spa
       CASE DEFAULT
          CALL fatal_error("Unsupported Integer data dimension")
       END SELECT
       
    case(nf90_double)
       IF(dbg_set(dbg_sbrio)) THEN
          WRITE(ipt,*) "XYTPE       :: DOUBLE"
          WRITE(ipt,*) "dims       ::",dims
       END IF

       SELECT CASE(ndims)
       CASE(4)
          ALLOCATE(var%FDA_DBL(0:dims(1),dims(2),dims(3),dims(4)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_FDA")
          var%FDA_DBL=0.0_dp
       CASE(3)
          ALLOCATE(var%CUB_DBL(0:dims(1),dims(2),dims(3)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_CUB")
          var%CUB_DBL=0.0_dp
       CASE(2)
          ALLOCATE(var%ARR_DBL(0:dims(1),dims(2)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_ARR")
          var%ARR_DBL=0.0_dp
       CASE(1)
          ALLOCATE(var%VEC_DBL(0:dims(1)),stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_VEC")
          var%VEC_DBL=0.0_dp
       CASE(0)
          ALLOCATE(var%SCL_DBL,stat=status)
          if(status /= 0) CALL fatal_error("ALLOC_VAR: Can not allocate DBL_SCL")
          var%SCL_DBL=0.0_dp
       CASE DEFAULT
          CALL fatal_error("Unsupported Integer data dimension")
       END SELECT
       
    END select
    

    DEALLOCATE(dims)

    IF(dbg_set(dbg_sbr)) WRITE(ipt,*) "END: ALLOC_VAR"
  END SUBROUTINE alloc_var
!====================================================================
!====================================================================
  SUBROUTINE allocate_associated_vars(LIST)
    ! THIS IS A SHADY THING TO DO - I AM INTENTIONALLY ALLOCATING AN
    ! ASSOCIATED VARIABLE ASSUMING THAT IT WAS ASSOCIATED NOT
    ! ALLOCATED TO BEGIN WITH, THUS NOT CAUSING A MEMORY LEAK

    IMPLICIT NONE
    TYPE(ncfile),    INTENT(IN)        :: LIST
    TYPE(ncvarp),POINTER :: CURRENT
    TYPE(ncvar),POINTER :: VAR

    current => list%VARS%NEXT
    DO
       IF(.NOT. ASSOCIATED(current)) THEN
          EXIT ! END OF VAR LIST
       END IF

       IF(.NOT. ASSOCIATED(current%VAR)) THEN
          CALL fatal_error("ALLOCATE_ASSOCIATED_VARS: FOUND NULL VAR POINTER IN THE LIST")
       END IF

       var => current%VAR

       ! INTEGERS
       IF(Associated(var%SCL_INT)) THEN
          ALLOCATE(var%SCL_INT)
          var%SCL_INT=0
       END IF

       IF(Associated(var%VEC_INT))THEN
          ALLOCATE(var%VEC_INT(lbound(var%VEC_INT,1):ubound(var%VEC_INT,1)))
          var%VEC_INT=0
       END IF

       IF(Associated(var%ARR_INT))THEN
          ALLOCATE(var%ARR_INT(lbound(var%ARR_INT,1):ubound(var%ARR_INT,1),&
               & lbound(var%ARR_INT,2):ubound(var%ARR_INT,2)) )
          var%ARR_INT=0
       END IF

       IF(Associated(var%CUB_INT))THEN
          ALLOCATE(var%CUB_INT(lbound(var%CUB_INT,1):ubound(var%CUB_INT,1),&
               & lbound(var%CUB_INT,2):ubound(var%CUB_INT,2),&
               & lbound(var%CUB_INT,3):ubound(var%CUB_INT,3)))
          var%CUB_INT=0
       END IF

       IF(Associated(var%FDA_INT))THEN
          ALLOCATE(var%FDA_INT(lbound(var%FDA_INT,1):ubound(var%FDA_INT,1),&
               & lbound(var%FDA_INT,2):ubound(var%FDA_INT,2),&
               & lbound(var%FDA_INT,3):ubound(var%FDA_INT,3),&
           & lbound(var%FDA_INT,4):ubound(var%FDA_INT,4)))
          var%FDA_INT=0
       END IF

       
       !FLOATING POINT VALUES
       IF(Associated(var%SCL_FLT)) THEN
          ALLOCATE(var%SCL_FLT)
          var%SCL_FLT=0.0_spa
       END IF
       IF(Associated(var%VEC_FLT))THEN
          ALLOCATE(var%VEC_FLT(lbound(var%VEC_FLT,1):ubound(var%VEC_FLT,1)))
          var%VEC_FLT=0.0_spa
       END IF

       IF(Associated(var%ARR_FLT))THEN
          ALLOCATE(var%ARR_FLT(lbound(var%ARR_FLT,1):ubound(var%ARR_FLT,1),&
               & lbound(var%ARR_FLT,2):ubound(var%ARR_FLT,2)) )
          var%ARR_FLT=0.0_spa
       END IF

       IF(Associated(var%CUB_FLT))THEN
          ALLOCATE(var%CUB_FLT(lbound(var%CUB_FLT,1):ubound(var%CUB_FLT,1),&
               & lbound(var%CUB_FLT,2):ubound(var%CUB_FLT,2),&
               & lbound(var%CUB_FLT,3):ubound(var%CUB_FLT,3)))
          var%CUB_FLT=0.0_spa
       END IF
       
       IF(Associated(var%FDA_FLT))THEN
          ALLOCATE(var%FDA_FLT(lbound(var%FDA_FLT,1):ubound(var%FDA_FLT,1),&
               & lbound(var%FDA_FLT,2):ubound(var%FDA_FLT,2),&
               & lbound(var%FDA_FLT,3):ubound(var%FDA_FLT,3),&
               & lbound(var%FDA_FLT,4):ubound(var%FDA_FLT,4)))
          var%FDA_FLT=0.0_spa
       END IF
       
       !DOUBLE PRECISION
       IF(Associated(var%SCL_DBL)) THEN
          ALLOCATE(var%SCL_DBL)
          var%SCL_DBL=0.0_dp
       END IF
       IF(Associated(var%VEC_DBL))THEN
          ALLOCATE(var%VEC_DBL(lbound(var%VEC_DBL,1):ubound(var%VEC_DBL,1)))
          var%VEC_DBL=0.0_dp
       END IF
       IF(Associated(var%ARR_DBL))THEN
          ALLOCATE(var%ARR_DBL(lbound(var%ARR_DBL,1):ubound(var%ARR_DBL,1),&
               & lbound(var%ARR_DBL,2):ubound(var%ARR_DBL,2)) )
          var%ARR_DBL=0.0_dp
       END IF

       IF(Associated(var%CUB_DBL))THEN
          ALLOCATE(var%CUB_DBL(lbound(var%CUB_DBL,1):ubound(var%CUB_DBL,1),&
               & lbound(var%CUB_DBL,2):ubound(var%CUB_DBL,2),&
               & lbound(var%CUB_DBL,3):ubound(var%CUB_DBL,3)))
          var%CUB_DBL=0.0_dp
       END IF
       
       IF(Associated(var%FDA_DBL))THEN
          ALLOCATE(var%FDA_DBL(lbound(var%FDA_DBL,1):ubound(var%FDA_DBL,1),&
               & lbound(var%FDA_DBL,2):ubound(var%FDA_DBL,2),&
               & lbound(var%FDA_DBL,3):ubound(var%FDA_DBL,3),&
               & lbound(var%FDA_DBL,4):ubound(var%FDA_DBL,4)))
          var%FDA_DBL=0.0_dp
       END IF
       
       ! CHARACTER ARRAY DATA
       IF(Associated(var%SCL_CHR)) THEN
          ALLOCATE(var%SCL_CHR)
          var%SCL_CHR=""
       END IF
       IF(Associated(var%VEC_CHR))THEN
          ALLOCATE(var%VEC_CHR(lbound(var%VEC_CHR,1):ubound(var%VEC_CHR,1)))
          var%VEC_CHR=""
       END IF

       current => current%NEXT

    END DO



  END SUBROUTINE allocate_associated_vars
!====================================================================
!====================================================================
  FUNCTION count_ncf_dim_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncfile),    INTENT(IN)        :: list
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       previous => previous%NEXT
       current  => current%NEXT
       cnt = cnt + 1
    END DO
    
  END FUNCTION count_ncf_dim_list
!====================================================================
!====================================================================
  FUNCTION count_var_dim_list(LIST) RESULT(CNT)
    IMPLICIT NONE
    INTEGER                            :: cnt
    TYPE(ncvar),     INTENT(IN)        :: list
    TYPE(ncdimp)               ,POINTER :: current, previous
    
    previous => list%DIMS
    current  => previous%NEXT
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) RETURN !END OF LIST
       previous => previous%NEXT
       current  => current%NEXT
       cnt = cnt + 1
    END DO
    
  END FUNCTION count_var_dim_list
!====================================================================
!====================================================================
  SUBROUTINE print_ncf_dim_list(LIST)
    IMPLICIT NONE
    type(ncfile), intent(IN) :: LIST
    TYPE(ncdimp), POINTER    :: CURRENT, PREVIOUS
    INTEGER                  :: CNT
    Character(len=4)         :: chr

    previous => list%DIMS
    current  => previous%NEXT

    IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% FILE DIMENSION LIST IS EMPTY %%%%%%%%%%%%%"
       RETURN
    ELSE
       if(dbg_set(dbg_log)) then
          write(ipt,*)"%%%%%%% PRINTING FILE DIMENSION LIST %%%%%%%%%"
          write(ipt,*)"%%%%%%% FILE NAME: "//trim(list%FNAME)//" %%%%%%%%%"
       end if
    END IF
    
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1
       write(chr,'(I4.4)')cnt
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"! PRINTING DIMENSION LIST ENTRY #"//chr
       CALL print_dim(current%DIM)

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    if(dbg_set(dbg_log)) &
         & write(ipt,*)"%%%%%%%%%%% END OF DIMENSION LIST %%%%%%%%%%%%%"
  END SUBROUTINE print_ncf_dim_list
!====================================================================
!====================================================================
  SUBROUTINE print_var_dim_list(LIST)
    IMPLICIT NONE
    type(ncvar), intent(IN)           :: LIST
    TYPE(ncdimp)               ,POINTER :: CURRENT, PREVIOUS
    INTEGER                            :: CNT
    Character(len=4)                   :: chr

    previous => list%DIMS
    current  => previous%NEXT

    IF(.NOT. ASSOCIATED(current)) THEN ! EMPTY LIST
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%%%%%% VARIABLE DIMENSION LIST IS EMPTY %%%%%%%%%%%%%"
       RETURN
    ELSE
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"%%%%%%% PRINTING VARIABLE: "//trim(list&
            &%VARNAME)//"; DIMENSION LIST %%%%%%%%%"
    END IF
    
    cnt = 0
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT !END OF LIST
       cnt = cnt + 1
       write(chr,'(I4.4)')cnt
       if(dbg_set(dbg_log)) &
            & write(ipt,*)"! PRINTING DIMENSION LIST ENTRY #"//chr
       CALL print_dim(current%DIM)

       previous => previous%NEXT
       current  => current%NEXT
    END DO
    if(dbg_set(dbg_log)) &
         & write(ipt,*)"%%%%%%%%%%% END OF DIMENSION LIST %%%%%%%%%%%%%"
  END SUBROUTINE print_var_dim_list
!====================================================================
!====================================================================
  SUBROUTINE print_dim(DIM)
    implicit none
    type(ncdim),pointer, intent(IN) :: DIM
    
    if(dbg_set(dbg_log)) then
       WRITE(ipt,*) "======== PRINT NCDIM TYPE ======="
       if(.not. associated(dim)) then
          WRITE(ipt,*) "THIS NCDIM HAS NOT BEEN ASSOCIATED"
          WRITE(ipt,*) "======= PRINTED NCDIM TYPE ======"
          return
       end if
       WRITE(ipt,*) "DIMNAME  ::"//trim(dim%DIMNAME)
       WRITE(ipt,*) "DIMID    ::",dim%DIMID
       WRITE(ipt,*) "DIMLEN   ::",dim%DIM
       WRITE(ipt,*) "UNLIMITED::",dim%UNLIMITED
       WRITE(ipt,*) "======= PRINTED NCDIM TYPE ======"
    end if
  END SUBROUTINE print_dim
!====================================================================
!====================================================================
!====================== MIXED OPERATORS =============================
!====================================================================
!====================================================================
!
! THESE OPERATATIONS ADD TWO MIXED NC OBJECTS, NULLIFY THE ARGUMENTS
! AND RETURN THE LIST OF THE SUM. IN GENERAL THEY DO NOT DELETE OR 
! ALLOCATE ANY MEMORY - ONLY POINT THE LIST OF THE FIRST OBJECT TO
! THE NEW DATA IN THE MEMORY OF THE SECOND.
!     EXCEPTION: IF A DIMENSION OF A VARIABLE ALREADY EXISTS IN A
!     FILE WHEN YOU ADD IT, THAT DIMENSION IS DELETED FROM THE
!     VARIABLE AND THE VARIABLES DIMENSION IS POINTED TO THE FILE'S
!     DIMENSION  
! 
! THESE METHODS ARE 'SAFE' AND INTENDED FOR END USERS TO WORK WITH
! THE PRINT_* METHODS ARE ALSO INTENDED FOR END USERS
!
  FUNCTION var_plus_dim(VAR,DIM) RESULT(RET)
    ! ADD THE DIMENSION TO THE VARIABLE DIM LIST IF IT DOES NOT EXIST
    IMPLICIT NONE
    type(ncvar), POINTER        :: var
    type(ncvar), POINTER        :: ret
    type(ncdim), POINTER        :: dim
    LOGICAL found
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "START VAR_PLUS_DIM"

    IF(.NOT. ASSOCIATED(var)) CALL fatal_error &
         & ("VAR_PLUS_DIM: THE VAR OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(.NOT. ASSOCIATED(dim)) CALL fatal_error &
         & ("VAR_PLUS_DIM: THE DIM OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(var%CONNECTED) CALL fatal_error&
         ("CAN NOT ADD DIMENSIONS TO A VARIABLE OBJECT ALREADY IN A FILE")

    CALL insert_dim_link(var,dim,found)
    

!     IF(FOUND) CALL FATAL_ERROR("ERROR ADDIND DIMENSION TO VARIABLE",&
!         & "THE DIMENSION: "//TRIM(DIM%DIMNAME)//"; ALREADY EXISTS",&
!         & "IN THE VARIABLE: "//TRIM(VAR%VARNAME))


    !ALL MEMORY NOW BELONGS TO RET
    ret => var
    NULLIFY(var)
    NULLIFY(dim) 
    if(dbg_set(dbg_sbr)) &
         & write(ipt,*) "END VAR_PLUS_DIM"
  END FUNCTION var_plus_dim
!====================================================================
!====================================================================
  FUNCTION var_plus_att(VAR,ATT) RESULT(RET)
    ! ADD THE ATTRIBUTE TO THE VARIABLE ATT LIST IF IT DOES NOT EXIST
    IMPLICIT NONE
    type(ncvar), POINTER        :: var
    type(ncatt), POINTER        :: att
    type(ncvar), POINTER        :: ret
    LOGICAL found
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "START VAR_PLUS_ATT"

    IF(.NOT. ASSOCIATED(var)) CALL fatal_error &
         & ("VAR_PLUS_ATT: THE VAR OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(.NOT. ASSOCIATED(att)) CALL fatal_error &
         & ("VAR_PLUS_ATT: THE ATT OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(var%CONNECTED) CALL fatal_error&
         ("CAN NOT ADD ATTRIBUTES TO A VARIABLE OBJECT ALREADY IN A FILE")

    CALL insert_att_link(var,att,found)
    ! ADD ERROR HANDLING LATER FOR MERGING ATTS
    IF(found) CALL fatal_error("ERROR ADDIND ATTRIBUTE TO VARIABLE",&
         & "THE ATTRIBUTE: "//trim(att%ATTNAME)//"; ALREADY EXISTS",&
         & "IN THE VARIABLE: "//trim(var%VARNAME))


    !ALL MEMORY NOW BELONGS TO RET
    ret => var
    NULLIFY(var)
    NULLIFY(att)
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "END VAR_PLUS_ATT"
  END FUNCTION var_plus_att
!====================================================================
!====================================================================
  FUNCTION ncf_plus_var(NCF,VAR) RESULT(RET)
    ! ADD THE VARIABLE TO THE FILE LIST IF IT DOES NOT ALREADY EXIST
    !
    ! ADD THE VARIABLES DIMENSIONS IF THEY DO NOT EXIST IN THE FILE LIST
    ! OR POINT TO THE FILES DIMENSIONS AND USE THE FILES DIMIDS IF THE
    ! DIMENSION ALREADY EXISTS IN THE FILE'S LIST
    !
    ! ATTRIBUTES BELONG TO THE VARIABLE, JUST ADD THEM WITH THE VARIABLE
    IMPLICIT NONE
    type(ncvar),  POINTER       :: var
    type(ncfile), POINTER       :: ret
    type(ncfile), POINTER       :: ncf
    type(ncdim),  POINTER       :: vdim, gdim
    type(ncdimp), POINTER       :: current
    
    LOGICAL :: found, f
    CHARACTER(LEN=NF90_MAX_NAME+1):: name
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "START NCF_PLUS_VAR"

    IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
         & ("NCF_PLUS_VAR: THE FILE OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(.NOT. ASSOCIATED(var)) CALL fatal_error &
         & ("NCF_PLUS_VAR: THE VAR OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")


    IF(ncf%CONNECTED) CALL fatal_error&
         ("CAN NOT ADD VARIABLE TO FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")

    IF(var%CONNECTED) CALL fatal_error&
         ("CAN NOT ADD VARIABLE TO A FILE OBJECT WHEN IT IS ALREADY CONNECTED")


    ! LOOK TO SEE IF WE NEED TO ADD ANY NEW DIMENSIONS TO THE FILE
    current=>var%DIMS%NEXT
    DO
       IF(.NOT. ASSOCIATED(current)) EXIT

       IF (.NOT. ASSOCIATED(current%DIM)) &
            & CALL fatal_error("NCF_PLUS_VAR: ATTEMPT TO ADD VARIABLE &
            &THAT HAS UNASSOCIATED DIM POINTERS IN ITS LINK LIST!")

       vdim => current%DIM

       CALL insert_dim_link(ncf,vdim,found)
       ! THIS WILL ADD THE VARIABLES DIMENSION IF IT IS NOT THERE ALREADY
       ! IN THE FILE. THERE IS SOME BASIC CONSISTANCY CHECKING.

       ! IF WE JUST ADDED IT, GREAT! NOW THE FILE'S DIM LINK LIST AND
       ! THE VARIABLE'S DIM LINK LIST ALREADY POINT TO THE SAME MEMORY
       
       IF(found) THEN ! THE DIMENSION IS ALREADY THERE. 

          name = vdim%DIMNAME
          gdim => find_dim(ncf,name,f)
          IF(.NOT. f) CALL fatal_error("NCF_PLUS_VAR: CAN'T FIND D&
               &IMENSION BUT IT WAS THERE A MINUTE AGO?")

          IF (.not. associated(vdim,target = gdim)) THEN ! CHECKS TO SEE IF IT IS
             ! POINTING TO THE SAME MEMORY OR TRUELY A DUPLICATE
             
             ! DELETE THE DUPLICATE AND POINT TO THE FILES DIM LINK LIST
             
             ! THIS ALLOWS THE FILE TO SET THE DIMIDS. DIMIDS SET IN THE
             ! VARIABLES DIM LIST ARE IGNORED
             CALL kill_dim(vdim)

             ! MOVE NOW EMPTY VARIABLE'S DIM LINK LIST POINTER TO FILE'S DIM LINK LIST
             current%DIM => gdim
          END IF
       END IF
       current => current%NEXT
    END DO

    ! NOW ADD THE VARIABLE TO THE FILE

    CALL insert_var_link(ncf,var,found)
    IF(found) CALL fatal_error("NCF_PLUS_VAR: THIS VARIABLE ALREADY EX&
         &ISTS IN THE FILE. YOU CAN'T ADD IT AGAIN!", &
         & "VARIABLE NAME: "//trim(var%VARNAME))


!    IF(ASSOCIATED(VAR%NCID)) THEN
      ! IF(VAR%NCID /= NCF%NCID) &
!            CALL FATAL_ERROR&
!            &("CAN'T ADD VARIABLE TO A FILE WITH A DIFFERENT NCID")
!    ELSE
    
!    END IF

    var%NCID => ncf%NCID
    var%CONNECTED=.true.

    !ALL MEMORY NOW BELONGS TO RET
    ret => ncf
    NULLIFY(ncf)
    NULLIFY(var)
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "END NCF_PLUS_VAR"

  END FUNCTION ncf_plus_var
!====================================================================
!====================================================================
  FUNCTION ncf_plus_att(NCF,ATT) RESULT(RET)
    IMPLICIT NONE
    type(ncatt),  POINTER       :: att
    type(ncfile), POINTER       :: ret
    type(ncfile), POINTER       :: ncf
    LOGICAL found
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "START NCF_PLUS_ATT"

    IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
         & ("NCF_PLUS_ATT: THE FILE OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(.NOT. ASSOCIATED(att)) CALL fatal_error &
         & ("NCF_PLUS_ATT: THE ATT OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(ncf%CONNECTED) CALL fatal_error&
         ("CAN NOT ADD ATTRIBUTE TO FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")

    CALL insert_att_link(ncf,att,found)
    ! ADD ERROR HANDLING LATER FOR MERGING ATTS
    IF(found) CALL fatal_error("ERROR ADDIND ATTRIBUTE TO FILE",&
         & "THE ATTRIBUTE: "//trim(att%ATTNAME)//"; ALREADY EXISTS",&
         & "IN THE FILE: "//trim(ncf%FNAME))


    !ALL MEMORY NOW BELONGS TO RET
    ret => ncf
    NULLIFY(ncf)
    NULLIFY(att)
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "END NCF_PLUS_ATT"
  END FUNCTION ncf_plus_att
!====================================================================
!====================================================================
  FUNCTION ncf_plus_dim(NCF,DIM) RESULT(RET)
    IMPLICIT NONE
    type(ncdim),  POINTER       :: dim
    type(ncfile), POINTER       :: ret
    type(ncfile), POINTER       :: ncf
    LOGICAL found
    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "START NCF_PLUS_DIM"

    IF(.NOT. ASSOCIATED(ncf)) CALL fatal_error &
         & ("NCF_PLUS_DIM: THE FILE OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(.NOT. ASSOCIATED(dim)) CALL fatal_error &
         & ("NCF_PLUS_DIM: THE DIM OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")


    IF(ncf%CONNECTED) CALL fatal_error&
         ("CAN NOT ADD DIMENSION TO FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")

    CALL insert_dim_link(ncf,dim,found)

    ! ADDING DUPLICATE DIMENSIONS TO A FILE IS NOT IS OKAY
    IF(found) CALL fatal_error("ERROR ADDIND DIMENSION TO FILE",&
         & "THE DIMENSION: "//trim(dim%DIMNAME)//"; ALREADY EXISTS",&
         & "IN THE FILE: "//trim(ncf%FNAME))


    !ALL MEMORY NOW BELONGS TO RET
    ret => ncf
    NULLIFY(ncf)
    NULLIFY(dim)

    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "END NCF_PLUS_DIM"
  END FUNCTION ncf_plus_dim
!====================================================================
!====================================================================
  FUNCTION ncf_plus_ncf(NCF1,NCF2) RESULT(RET)
    ! ADD EACH VARIABLE FROM NCF2 TO NCF1
    ! THE VARIABLES WILL TAKE THEIR DIMENSIONS WITH THEM AS NEEDED
    !
    ! ADD ANY ATTRIBUTES THAT DO NOT ALREADY EXIST IN NCF1

    IMPLICIT NONE
    type(ncfile), POINTER       :: ncf1
    type(ncfile), POINTER       :: ncf2
    type(ncfile), POINTER       :: ret

    type(ncvarp), POINTER       :: current_var
    type(ncvar), POINTER        :: var

    type(ncdimp), POINTER       :: current_dim
    type(ncdim), POINTER        :: dim1
    type(ncdim), POINTER        :: dim2

    TYPE(ncattp), POINTER       :: current_att
!!$
    TYPE(ncatt),  POINTER       :: attt
!!$    

    CHARACTER(LEN=NF90_MAX_NAME+1):: name
    LOGICAL found1, found2

    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "START NCF_PLUS_NCF"


    IF(.NOT. ASSOCIATED(ncf1)) CALL fatal_error &
         & ("NCF_PLUS_NCF: THE FIRST FILE OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")

    IF(.NOT. ASSOCIATED(ncf2)) CALL fatal_error &
         & ("NCF_PLUS_NCF: THE SECOND FILE OBJECT ARGUMENT IS NOT ASSOC&
         &IATED. THIS IS ILLEGAL.","THE DEPARTMENT OF FVCOM SECURITY HAS BEEN CONTACTED")
    
    IF(ncf1%CONNECTED .OR. ncf2%CONNECTED) CALL fatal_error&
         ("CAN NOT COMBINE FILE OBJECTS ALREADY CONNECTED TO A NETCDF FILE")
    
    current_var => ncf2%VARS%NEXT

    DO
       IF(.NOT. ASSOCIATED(current_var)) EXIT
       
       IF (.NOT. ASSOCIATED(current_var%VAR)) &
            & CALL fatal_error("NCF_PLUS_NCF: ATTEMPT TO ADD A FILE &
            &THAT HAS UNASSOCIATED VAR POINTER IN ITS LINK LIST!")
       
       ! Variable from the second file
       var =>copy_var(current_var%VAR)
       !DISCONECT THE VARIABLE MOMENTARILY
       var%CONNECTED=.false.


       current_dim=>var%DIMS%NEXT
       DO
          IF(.NOT. ASSOCIATED(current_dim)) EXIT
          
          IF (.NOT. ASSOCIATED(current_dim%DIM)) &
               & CALL fatal_error("NCF_PLUS_NCF: ATTEMPT TO ADD VARIABLE &
               &THAT HAS UNASSOCIATED DIM POINTERS IN ITS LINK LIST!")
          
          !DIM from the variable of the second file
          dim2 => current_dim%DIM
          
          CALL insert_dim_link(ncf1,dim2,found1)
          ! THIS WILL ADD THE VARIABLES DIMENSION IF IT IS NOT THERE ALREADY
          ! IN THE FILE. THERE IS SOME BASIC CONSISTANCY CHECKING.
          
          ! IF WE JUST ADDED IT, GREAT! NOW THE FILE'S DIM LINK LIST AND
          ! THE VARIABLE'S DIM LINK LIST ALREADY POINT TO THE SAME MEMORY
          
          ! IF WE FOUND IT IN THE FILE TO WHICH THE VARIABLE IS BEING
          ! ADDED MOVE THE POINTER OVER
          IF (found1) THEN
             current_dim%DIM => find_dim(ncf1,dim2%DIMNAME,found2)
             IF (.NOT. found2) CALL fatal_error("NCF_PLUS_NCF: CAN'T FIN&
                  &D DIMENSION IN FILE BUT IT WAS HERE A SECOND AGO?")
             CALL kill_dim(dim2)

          END IF
          
          current_dim => current_dim%NEXT
       END DO

       ! NOW ADD THE VARIABLE TO THE FILE
       
       CALL insert_var_link(ncf1,var,found1)
       IF(found1) CALL fatal_error("NCF_PLUS_VAR: THIS VARIABLE ALREADY EX&
            &ISTS IN THE FILE. YOU CAN'T ADD IT AGAIN!", &
            & "VARIABLE NAME: "//trim(var%VARNAME))
       
       
       var%NCID => ncf1%NCID
       var%CONNECTED=.true.
       
       current_var => current_var%NEXT
    END DO
    

!!$    ! NOW GO THROUGH DIMENSION LIST IN BOTH FILES AND DELETE DUPLICATES!
!!$    CURRENT_DIM=>NCF2%DIMS%NEXT
!!$    DO
!!$       IF(.NOT. ASSOCIATED(CURRENT_DIM)) EXIT
!!$       
!!$       IF (.NOT. ASSOCIATED(CURRENT_DIM%DIM)) &
!!$            & CALL FATAL_ERROR("NCF_PLUS_NCF: ATTEMPT TO ADD VARIABLE &
!!$            &THAT HAS UNASSOCIATED DIM POINTERS IN ITS LINK LIST!")
!!$              
!!$       !DIM from the second file
!!$       DIM2 => CURRENT_DIM%DIM
!!$       
!!$       DIM1 => FIND_DIM(NCF1,DIM2%DIMNAME,FOUND1)
!!$       IF (.NOT. FOUND1) THEN
!!$          CALL FATAL_ERROR("NCF_PLUS_NCF: ALL DIMENSIO&
!!$               &NS FROM FILE TWO SHOULD ALREADY BE ADDED TO FILE ONE:",&
!!$               &"FOUND DIMNAME: "//DIM2%DIMNAME//" IN FILE 2 BUT NOT IN 1&
!!$               & ?")
!!$       ELSE
!!$          IF(.not. associated(DIM1,target = DIM2)) CALL KILL_DIM(DIM2)
!!$       END IF
!!$
!!$       CURRENT_DIM => CURRENT_DIM%NEXT
!!$
!!$    END DO


   current_att => ncf2%ATTS%NEXT
    DO
       IF(.NOT. ASSOCIATED(current_att)) EXIT
 
       IF (.NOT. ASSOCIATED(current_att%ATT)) &
            & CALL fatal_error("NCF_PLUS_NCF: ATTEMPT TO ADD A FILE &
            &THAT HAS UNASSOCIATED ATT POINTER IN ITS LINK LIST!")

       attt => copy_att(current_att%ATT)
       ncf1 => ncf_plus_att(ncf1,attt)
!!$       NCF1 => NCF_PLUS_ATT(NCF1,Copy_Att(CURRENT_ATT%ATT))
       !ALREADY INCRIMENTED NATTS

       current_att => current_att%NEXT
    END DO



    ret => ncf1
    NULLIFY(ncf1)
    CALL kill_file(ncf2)
    NULLIFY(ncf2)

    if(dbg_set(dbg_sbr)) &
       & write(ipt,*) "END NCF_PLUS_NCF"

  END FUNCTION ncf_plus_ncf
!====================================================================
!====================================================================
  FUNCTION ncflist_plus_ncf(NCFLIST,NCF) RESULT(RET)
    IMPLICIT NONE
    type(ncfilelist), POINTER   :: ncflist
    type(ncfilelist), POINTER   :: ret
    type(ncfile),     POINTER   :: ncf
    LOGICAL found

    IF (.NOT. ASSOCIATED(ncflist))THEN
       ALLOCATE(ncflist)
       ncflist%FIRST => new_filep()
    END IF

    CALL insert_file_link(ncflist,ncf,found)
    IF(found) CALL fatal_error("NCFLIST_PLUS_NCF: THIS FILE ALREADY EX&
         &ISTS IN THE FILELIST. YOU CAN'T ADD IT AGAIN!", &
         & "FILE NAME: "//trim(ncf%FNAME))

    !ALL MEMORY IN NCFLIST NOW BELONGS TO RET
    ret => ncflist
    NULLIFY(ncflist)
    NULLIFY(ncf)
  END FUNCTION ncflist_plus_ncf



  
END MODULE mod_ncll