grib_api_interface.F90

Go to the documentation of this file.

MODULE grib_api_interface

!define GRIB_API_TRACE

!**** Interface to GRIB_API

!     Purpose.
!     --------
!     Fortran 90 Interface to calling GRIB API

!     Author.
!     -------
!        M.Hamrud     ECMWF

!     Modifications.
!     --------------
!        Original: 2005-11-15
!      F. Vana  05-Mar-2015  Support for single precision

!     ------------------------------------------------------------------

USE parkind1 , ONLY : jprd, jpim, jpib, jprb, jprm
USE yomhook  , ONLY : lhook, dr_hook
USE grib_api
#ifdef SFX_MPI
USE mpl_module, ONLY : mpl_abort
#endif
IMPLICIT NONE

INTERFACE igrib_get_value
MODULE PROCEDURE &
 & igrib_get_int, igrib_get_real4, igrib_get_real8,igrib_get_char,&
 & igrib_get_int_array, igrib_get_real4_array, igrib_get_real8_array, &
 & igrib_get_int8
END INTERFACE
INTERFACE igrib_set_value
MODULE PROCEDURE &
 & igrib_set_int, igrib_set_real4, igrib_set_real8,igrib_set_char,&
 & igrib_set_int_array, igrib_set_real4_array, igrib_set_real8_array, &
 & igrib_set_int8, igrib_set_int8_array
END INTERFACE
INTERFACE igrib_read_bytes
MODULE PROCEDURE &
 & igrib_read_bytes_int, igrib_read_bytes_real4, igrib_read_bytes_real8, igrib_read_bytes_char
END INTERFACE
INTERFACE igrib_write_bytes
MODULE PROCEDURE &
 & igrib_write_bytes_int, igrib_write_bytes_real4, igrib_write_bytes_real8, igrib_write_bytes_char
END INTERFACE

PUBLIC igrib_get_value, igrib_set_value, igrib_open_file, igrib_close_file,&
 & igrib_release, jpgrib_success, jpgrib_end_of_file, jpgrib_buffer_too_small, &
 & igrib_get_message_size, igrib_new_from_message, igrib_new_from_file, &
 & igrib_new_from_samples, igrib_clone ,igrib_get_message, igrib_read_from_file, &
 & igrib_read_bytes, igrib_write_bytes, igrib_is_defined

INTEGER, PARAMETER :: jpgrib_success=grib_success
INTEGER, PARAMETER :: jpgrib_end_of_file=grib_end_of_file
INTEGER, PARAMETER :: jpgrib_buffer_too_small=grib_buffer_too_small

PRIVATE
#ifdef GRIB_API_1
INTEGER, PARAMETER, PUBLIC :: jpksize_t=jpim
#else
INTEGER, PARAMETER, PUBLIC :: jpksize_t=kindofsize_t
#endif

LOGICAL, PUBLIC :: lgrib_api_trace = .false.

CONTAINS

SUBROUTINE igrib_get_int8(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIB),INTENT(OUT) :: KVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_INT8',0,zhook_handle)
CALL grib_get_long(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_LONG',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_INT8',1,zhook_handle)

END SUBROUTINE igrib_get_int8

SUBROUTINE igrib_get_int(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIM),INTENT(OUT) :: KVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_INT',0,zhook_handle)
CALL grib_get_int(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_INT',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_INT',1,zhook_handle)

END SUBROUTINE igrib_get_int

SUBROUTINE igrib_get_real4(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRM)   ,INTENT(OUT) :: PVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL4',0,zhook_handle)
CALL grib_get_real4(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_REAL4',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL4',1,zhook_handle)

END SUBROUTINE igrib_get_real4

SUBROUTINE igrib_get_real8(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRD)   ,INTENT(OUT) :: PVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL8',0,zhook_handle)
CALL grib_get_real8(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_REAL8',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL8',1,zhook_handle)

END SUBROUTINE igrib_get_real8

SUBROUTINE igrib_get_char(KHANDLE,CDKEY,CDVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
CHARACTER(LEN=*)  ,INTENT(OUT) :: CDVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_CHAR',0,zhook_handle)
CALL grib_get_string(khandle,cdkey,cdval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_STRING',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_CHAR',1,zhook_handle)

END SUBROUTINE igrib_get_char

SUBROUTINE igrib_get_int_array(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIM),INTENT(OUT) :: KVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET,ISIZE
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_INT_ARRAY',0,zhook_handle)

CALL grib_get_int_array(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_INT',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_INT_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_get_int_array

SUBROUTINE igrib_get_real4_array(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRM)   ,INTENT(OUT) :: PVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL4_ARRAY',0,zhook_handle)

CALL grib_get_real4_array(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_REAL4_ARRAY',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL4_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_get_real4_array

SUBROUTINE igrib_get_real8_array(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRD)   ,INTENT(OUT) :: PVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL8_ARRAY',0,zhook_handle)

CALL grib_get_real8_array(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_REAL8_ARRAY',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_GET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_REAL8_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_get_real8_array
!====================================================================
SUBROUTINE igrib_set_int8(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIB),INTENT(IN) :: KVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT8',0,zhook_handle)

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) WRITE (0, *) 'CALL GRIB_SET_LONG (IGRIBH, ', '"'//trim(cdkey)//'"', ', ', kval, ')'
#endif

CALL grib_set_long(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_LONG',khandle,' ',cdkey,' ',kval,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT8',1,zhook_handle)

END SUBROUTINE igrib_set_int8

SUBROUTINE igrib_set_int(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIM),INTENT(IN) :: KVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT',0,zhook_handle)

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) WRITE (0, *) 'CALL GRIB_SET_INT (IGRIBH, ', '"'//trim(cdkey)//'"', ', ', kval, ')'
#endif

CALL grib_set_int(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_INT',khandle,' ',cdkey,' ',kval,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT',1,zhook_handle)

END SUBROUTINE igrib_set_int

SUBROUTINE igrib_set_real4(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRM)   ,INTENT(IN) :: PVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL4',0,zhook_handle)
CALL grib_set_real4(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_REAL4',khandle,' ',cdkey,' ',pval,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL4',1,zhook_handle)

END SUBROUTINE igrib_set_real4

SUBROUTINE igrib_set_real8(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRD)   ,INTENT(IN) :: PVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) WRITE (0, *) 'CALL GRIB_SET_REAL8 (IGRIBH, ', '"'//trim(cdkey)//'"', ', ', pval, ')'
#endif

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL8',0,zhook_handle)
CALL grib_set_real8(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_REAL8',khandle,' ',cdkey,' ',pval,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL8',1,zhook_handle)

END SUBROUTINE igrib_set_real8

SUBROUTINE igrib_set_char(KHANDLE,CDKEY,CDVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
CHARACTER(LEN=*)  ,INTENT(IN) :: CDVAL
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_CHAR',0,zhook_handle)

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) WRITE (0, *) 'CALL GRIB_SET_STRING (IGRIBH, ', '"'//trim(cdkey)//'"', ', ', '"'//trim(cdval)//'"', ')'
#endif

CALL grib_set_string(khandle,cdkey,cdval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_STRING',khandle,' ',cdkey,' ',cdval,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_CHAR',1,zhook_handle)

END SUBROUTINE igrib_set_char

SUBROUTINE igrib_set_int8_array(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIB),INTENT(IN) :: KVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: I
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT8_ARRAY',0,zhook_handle)

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) &
& WRITE (0, *) 'CALL GRIB_SET_LONG_ARRAY (IGRIBH, ', '"'//trim(cdkey)//'"', &
& ', (/ ', kval(1), ((', ', kval(i)), i = 2, SIZE (kval)), ' /))'
#endif

CALL grib_set_long_array(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_LONG_ARRAY',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT8_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_set_int8_array

SUBROUTINE igrib_set_int_array(KHANDLE,CDKEY,KVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
INTEGER(KIND=JPIM),INTENT(IN) :: KVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: I
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT_ARRAY',0,zhook_handle)

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) &
& WRITE (0, *) 'CALL GRIB_SET_INT_ARRAY (IGRIBH, ', '"'//trim(cdkey)//'"', &
& ', (/ ', kval(1), ((', ', kval(i)), i = 2, SIZE (kval)), ' /))'
#endif

CALL grib_set_int_array(khandle,cdkey,kval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_INT_ARRAY',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_INT_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_set_int_array

SUBROUTINE igrib_set_real4_array(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRM)   ,INTENT(IN) :: PVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL4_ARRAY',0,zhook_handle)
CALL grib_set_real4_array(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_REAL4_ARRAY',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL4_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_set_real4_array

SUBROUTINE igrib_set_real8_array(KHANDLE,CDKEY,PVAL,KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE
CHARACTER(LEN=*)  ,INTENT(IN) :: CDKEY
REAL(KIND=JPRD)   ,INTENT(IN) :: PVAL(:)
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=JPIM) :: I
REAL(KIND=JPRB) :: ZHOOK_HANDLE

#ifdef GRIB_API_TRACE
IF (lgrib_api_trace) &
& WRITE (0, *) 'CALL GRIB_SET_REAL8_ARRAY (IGRIBH, ', '"'//trim(cdkey)//'"', &
& ', (/ ', pval(1), ((', ', pval(i)), i = 2, SIZE (pval)), '/))'
#endif

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL8_ARRAY',0,zhook_handle)
CALL grib_set_real8_array(khandle,cdkey,pval,status=iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_SET_REAL8_ARRAY',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_SET_VALUE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_SET_REAL8_ARRAY',1,zhook_handle)

END SUBROUTINE igrib_set_real8_array

SUBROUTINE igrib_open_file(KFILE,CDPATH,CDMODE)
INTEGER(KIND=JPIM),INTENT(OUT)  :: KFILE
CHARACTER(LEN=*)  ,INTENT(IN)   :: CDPATH
CHARACTER(LEN=1)  ,INTENT(IN)   :: CDMODE

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_OPEN_FILE',0,zhook_handle)
CALL grib_open_file(kfile,cdpath,cdmode,status=iret)
IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_OPEN_FILE ',trim(cdpath),' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_OPEN_FILE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_OPEN_FILE',1,zhook_handle)

END SUBROUTINE igrib_open_file

SUBROUTINE igrib_close_file(KFILE)
INTEGER(KIND=JPIM),INTENT(IN)  :: KFILE

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_CLOSE_FILE',0,zhook_handle)
CALL grib_close_file(kfile,status=iret)
IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_CLOSE_FILE ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_CLOSE_FILE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_CLOSE_FILE',1,zhook_handle)

END SUBROUTINE igrib_close_file

SUBROUTINE igrib_read_from_file(KFILE,KBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT)   :: KBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_FROM_FILE',0,zhook_handle)

CALL grib_read_from_file(kfile,kbuf,kbytes,iret)
IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success .AND. iret /= jpgrib_end_of_file ) THEN
  WRITE(0,*) 'GRIB_READ_FROM_FILE ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_READ_FROM_FILE FAILED')
#endif
ENDIF

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_FROM_FILE',1,zhook_handle)

END SUBROUTINE igrib_read_from_file

SUBROUTINE igrib_read_bytes_int(KFILE,KBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT)   :: KBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT)   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_INT',0,zhook_handle)
CALL grib_read_bytes(kfile,kbuf,kbytes,iret)
IF(iret /= jpgrib_success .AND. iret /= jpgrib_end_of_file ) THEN
  WRITE(0,*) 'GRIB_READ_BYTES_INT ',kfile,' ',kbytes,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_READ_BYTES_INT FAILED')
#endif
ENDIF
kret = iret
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_INT',1,zhook_handle)

END SUBROUTINE igrib_read_bytes_int

SUBROUTINE igrib_read_bytes_real4(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM)   ,INTENT(OUT)   :: PBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT)   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_REAL4',0,zhook_handle)

CALL grib_read_bytes(kfile,pbuf,kbytes,iret)
IF(iret /= jpgrib_success .AND. iret /= jpgrib_end_of_file ) THEN
  WRITE(0,*) 'GRIB_READ_BYTES_INT ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_READ_BYTES_REAL4 FAILED')
#endif
ENDIF
kret = iret
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_REAL4',1,zhook_handle)
END SUBROUTINE igrib_read_bytes_real4

SUBROUTINE igrib_read_bytes_real8(KFILE,PBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD)   ,INTENT(OUT)   :: PBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT)   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_REAL8',0,zhook_handle)

CALL grib_read_bytes(kfile,pbuf,kbytes,iret)
IF(iret /= jpgrib_success .AND. iret /= jpgrib_end_of_file ) THEN
  WRITE(0,*) 'GRIB_READ_BYTES_REAL8 ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_READ_BYTES_REAL8 FAILED')
#endif
ENDIF
kret = iret
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_REAL8',1,zhook_handle)
END SUBROUTINE igrib_read_bytes_real8

SUBROUTINE igrib_read_bytes_char(KFILE,CDBUF,KBYTES,KRET)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
CHARACTER(LEN=1)  ,INTENT(OUT)   :: CDBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM),INTENT(OUT)   :: KRET
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_CHAR',0,zhook_handle)

CALL grib_read_bytes(kfile,cdbuf,kbytes,iret)
IF(iret /= jpgrib_success .AND. iret /= jpgrib_end_of_file ) THEN
  WRITE(0,*) 'GRIB_READ_BYTES_CHAR ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_READ_BYTES_CHAR FAILED')
#endif
ENDIF
kret = iret
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_READ_BYTES_CHAR',1,zhook_handle)

END SUBROUTINE igrib_read_bytes_char


SUBROUTINE igrib_write_bytes_int(KFILE,KBUF,KBYTES)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
INTEGER(KIND=JPIM),INTENT(IN)    :: KBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_INT',0,zhook_handle)

CALL grib_write_bytes(kfile,kbuf,kbytes,iret)
IF(iret /= jpgrib_success ) THEN
  WRITE(0,*) 'GRIB_WRITE_BYTES_INT ',kfile,' ',kbytes,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_WRITE_BYTES_INT FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_INT',1,zhook_handle)

END SUBROUTINE igrib_write_bytes_int

SUBROUTINE igrib_write_bytes_real4(KFILE,PBUF,KBYTES)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRM)   ,INTENT(IN)    :: PBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_REAL4',0,zhook_handle)

CALL grib_write_bytes(kfile,pbuf,kbytes,iret)
IF(iret /= jpgrib_success ) THEN
  WRITE(0,*) 'GRIB_WRITE_BYTES_INT ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_WRITE_BYTES_REAL4 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_REAL4',1,zhook_handle)

END SUBROUTINE igrib_write_bytes_real4

SUBROUTINE igrib_write_bytes_real8(KFILE,PBUF,KBYTES)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
REAL(KIND=JPRD)   ,INTENT(IN)    :: PBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM) :: IRET,ILEN
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_REAL8',0,zhook_handle)

CALL grib_write_bytes(kfile,pbuf,kbytes,iret)
IF(iret /= jpgrib_success ) THEN
  WRITE(0,*) 'GRIB_WRITE_BYTES_INT ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_WRITE_BYTES_REAL8 FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_REAL8',1,zhook_handle)

END SUBROUTINE igrib_write_bytes_real8

SUBROUTINE igrib_write_bytes_char(KFILE,CDBUF,KBYTES)
INTEGER(KIND=JPIM),INTENT(IN)    :: KFILE
CHARACTER(LEN=1)  ,INTENT(IN)    :: CDBUF(:)
INTEGER(KIND=JPKSIZE_T),INTENT(INOUT) :: KBYTES
INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_CHAR',0,zhook_handle)

CALL grib_write_bytes(kfile,cdbuf,kbytes,iret)
IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_WRITE_BYTES_CHAR ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_WRITE_BYTES_CHAR FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_WRITE_BYTES_CHAR',1,zhook_handle)

END SUBROUTINE igrib_write_bytes_char

SUBROUTINE igrib_new_from_file(KFILE,KHANDLE,KRET)
INTEGER(KIND=JPIM),INTENT(IN)  :: KFILE
INTEGER(KIND=JPIM),INTENT(OUT) :: KHANDLE
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_NEW_FROM_FILE',0,zhook_handle)

CALL grib_new_from_file(kfile,khandle,status=iret)

IF(PRESENT(kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success .AND. iret /= jpgrib_end_of_file ) THEN
  WRITE(0,*) 'GRIB_NEW_FROM_FILE ',kfile,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_NEW_FROM_FILE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_NEW_FROM_FILE',1,zhook_handle)

END SUBROUTINE igrib_new_from_file

SUBROUTINE igrib_new_from_message(KHANDLE,KBUF)
INTEGER(KIND=JPIM),INTENT(OUT) :: KHANDLE
INTEGER(KIND=JPIM),INTENT(IN)  :: KBUF(:)

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_NEW_FROM_MESSAGE',0,zhook_handle)

CALL grib_new_from_message(khandle,kbuf,status=iret)

IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'CALL TO GRIB_NEW_FROM_MESSAGE FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('IGRIB_NEW_FROM_MESSAGE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_NEW_FROM_MESSAGE',1,zhook_handle)

END SUBROUTINE igrib_new_from_message

SUBROUTINE igrib_release(KHANDLE)
INTEGER(KIND=JPIM),INTENT(IN) :: KHANDLE

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_RELEASE',0,zhook_handle)

CALL grib_release(khandle,status=iret)
IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_RELEASE ',khandle,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_RELEASE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_RELEASE',1,zhook_handle)

END SUBROUTINE igrib_release

SUBROUTINE igrib_get_message_size(KHANDLE,KBYTES)
INTEGER(KIND=JPIM),INTENT(IN)  :: KHANDLE
INTEGER(KIND=JPKSIZE_T),INTENT(OUT) :: KBYTES
INTEGER(KIND=JPIM) :: IRET
INTEGER(KIND=KINDOFSIZE_T) :: IBYTES
REAL(KIND=JPRB)    :: ZHOOK_HANDLE


IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_MESSAGE_SIZE',0,zhook_handle)
CALL grib_get_message_size(khandle,ibytes,status=iret)
kbytes = ibytes
IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_GET_MESSAGE_SIZE ',khandle,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort(' GRIB_GET_MESSAGE_SIZE FAIL')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_MESSAGE_SIZE',1,zhook_handle)

END SUBROUTINE igrib_get_message_size

SUBROUTINE igrib_get_message(KHANDLE,KGRIB)
INTEGER(KIND=JPIM),INTENT(IN)  :: KHANDLE
INTEGER(KIND=JPIM),INTENT(OUT) :: KGRIB(:)

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE
CHARACTER(LEN=1),ALLOCATABLE   :: CLS(:)
INTEGER(KIND=JPIM) :: ILENINT
INTEGER(KIND=JPKSIZE_T) :: ILEN

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_MESSAGE',0,zhook_handle)

!TEMP CODING
CALL igrib_get_message_size(khandle,ilen)
ilenint=(ilen+3)/4
ALLOCATE(cls(ilenint*4))
cls(ilenint*4-3:ilenint*4)='    '
CALL grib_copy_message(khandle,cls,status=iret)
kgrib(1:ilenint)=transfer(cls,kgrib)
DEALLOCATE(cls)
!CALL GRIB_COPY_MESSAGE(KHANDLE,KGRIB,STATUS=IRET)
IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_COPY_MESSAGE ',khandle,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort(' GRIB_COPY_MESSAGE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_GET_MESSAGE',1,zhook_handle)

END SUBROUTINE igrib_get_message

SUBROUTINE igrib_new_from_samples(KHANDLE,CDNAME,KRET)
INTEGER(KIND=JPIM),INTENT(OUT) :: KHANDLE
CHARACTER(LEN=*),INTENT(IN) :: CDNAME
INTEGER(KIND=JPIM),OPTIONAL,INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_NEW_FROM_SAMPLES',0,zhook_handle)
CALL grib_new_from_samples(khandle,trim(cdname),status=iret)
IF (PRESENT (kret)) THEN
  kret = iret
ELSEIF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_NEW_FROM_SAMPLES ',trim(cdname),' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort(' GRIB_NEW_FROM_SAMPLES FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_NEW_FROM_SAMPLES',1,zhook_handle)

END SUBROUTINE igrib_new_from_samples

SUBROUTINE igrib_clone(KHANDLE1,KHANDLE2)
INTEGER(KIND=JPIM),INTENT(IN)  :: KHANDLE1
INTEGER(KIND=JPIM),INTENT(OUT) :: KHANDLE2

INTEGER(KIND=JPIM) :: IRET
REAL(KIND=JPRB) :: ZHOOK_HANDLE

IF (lhook) CALL dr_hook('GRIB_API:IGRIB_CLONE',0,zhook_handle)
CALL grib_clone(khandle1,khandle2,status=iret)

IF(iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_CLONE FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort(' GRIB_CLONE FAILED')
#endif
ENDIF
IF (lhook) CALL dr_hook('GRIB_API:IGRIB_CLONE',1,zhook_handle)

END SUBROUTINE igrib_clone

SUBROUTINE err_msg(KRET)
INTEGER(KIND=JPIM),INTENT(IN) :: KRET
INTEGER(KIND=JPIM) :: IRET
CHARACTER(LEN=256) :: CLERRMSG

clerrmsg = ''
CALL grib_get_error_string(kret,clerrmsg,status=iret)
WRITE(0,*) 'GRIB_API ERROR MSG: ',trim(clerrmsg)
END SUBROUTINE err_msg


SUBROUTINE igrib_is_defined(KHANDLE, CDKEY, LDDEFINED, KRET)
INTEGER(KIND=JPIM),           INTENT(IN)  :: KHANDLE
CHARACTER(LEN=*),             INTENT(IN)  :: CDKEY
LOGICAL,                      INTENT(OUT) :: LDDEFINED
INTEGER(KIND=JPIM), OPTIONAL, INTENT(OUT) :: KRET

INTEGER(KIND=JPIM) :: IS_DEFINED, IRET

is_defined = 0
#define FAGRIB2
#ifdef FAGRIB2
CALL grib_is_defined (khandle, cdkey, is_defined, iret)
#else
#ifdef SFX_MPI
CALL mpl_abort('GRIB_IS_DEFINED FAILED')
#endif
#endif

IF (PRESENT (kret)) THEN
  kret = iret
ELSEIF (iret /= jpgrib_success) THEN
  WRITE(0,*) 'GRIB_IS_DEFINED',khandle,' ',cdkey,' FAILED',iret
  CALL err_msg(iret)
#ifdef SFX_MPI
  CALL mpl_abort('GRIB_IS_DEFINED FAILED')
#endif
ENDIF

lddefined = is_defined /= 0

END SUBROUTINE igrib_is_defined


END MODULE grib_api_interface