source: NEMO/branches/2020/dev_r12953_ENHANCE-10_acc_fix_traqsr/src/OCE/IOM/iom_nf90.F90 @ 13121

Last change on this file since 13121 was 13121, checked in by acc, 3 months ago

2020/dev_r12953_ENHANCE-10_acc_fix_traqsr. Merge in trunk changes from 12953 to current HEAD (13115). Fully SETTE tested

  • Property svn:keywords set to Id
File size: 42.9 KB
Line 
1MODULE iom_nf90
2   !!======================================================================
3   !!                    ***  MODULE  iom_nf90 ***
4   !! Input/Output manager :  Library to read input files with NF90 (only fliocom module)
5   !!======================================================================
6   !! History :  9.0  ! 05 12  (J. Belier) Original code
7   !!            9.0  ! 06 02  (S. Masson) Adaptation to NEMO
8   !!             "   ! 07 07  (D. Storkey) Changes to iom_nf90_gettime
9   !!            3.6  ! 2015-15  (J. Harle) Added procedure to read REAL attributes
10   !!            4.0  ! 2017-11 (M. Andrejczuk) Extend IOM interface to write any 3D fields
11   !!----------------------------------------------------------------------
12
13   !!----------------------------------------------------------------------
14   !!   iom_open       : open a file read only
15   !!   iom_close      : close a file or all files opened by iom
16   !!   iom_get        : read a field (interfaced to several routines)
17   !!   iom_varid      : get the id of a variable in a file
18   !!   iom_rstput     : write a field in a restart file (interfaced to several routines)
19   !!----------------------------------------------------------------------
20   USE dom_oce         ! ocean space and time domain
21   USE sbc_oce, ONLY: ght_abl ! abl vertical level number and height
22   USE lbclnk          ! lateal boundary condition / mpp exchanges
23   USE iom_def         ! iom variables definitions
24   USE netcdf          ! NetCDF library
25   USE in_out_manager  ! I/O manager
26   USE lib_mpp         ! MPP library
27
28   IMPLICIT NONE
29   PRIVATE
30
31   PUBLIC iom_nf90_open  , iom_nf90_close, iom_nf90_varid, iom_nf90_get, iom_nf90_rstput
32   PUBLIC iom_nf90_chkatt, iom_nf90_getatt, iom_nf90_putatt
33
34   INTERFACE iom_nf90_get
35      MODULE PROCEDURE iom_nf90_g0d, iom_nf90_g123d
36   END INTERFACE
37   INTERFACE iom_nf90_rstput
38      MODULE PROCEDURE iom_nf90_rp0123d
39   END INTERFACE
40
41   !!----------------------------------------------------------------------
42   !! NEMO/OCE 4.0 , NEMO Consortium (2018)
43   !! $Id$
44   !! Software governed by the CeCILL license (see ./LICENSE)
45   !!----------------------------------------------------------------------
46CONTAINS
47
48   SUBROUTINE iom_nf90_open( cdname, kiomid, ldwrt, ldok, kdompar, kdlev, cdcomp )
49      !!---------------------------------------------------------------------
50      !!                   ***  SUBROUTINE  iom_open  ***
51      !!
52      !! ** Purpose : open an input file with NF90
53      !!---------------------------------------------------------------------
54      CHARACTER(len=*)       , INTENT(inout)           ::   cdname      ! File name
55      INTEGER                , INTENT(  out)           ::   kiomid      ! nf90 identifier of the opened file
56      LOGICAL                , INTENT(in   )           ::   ldwrt       ! read or write the file?
57      LOGICAL                , INTENT(in   )           ::   ldok        ! check the existence
58      INTEGER, DIMENSION(2,5), INTENT(in   ), OPTIONAL ::   kdompar     ! domain parameters:
59      INTEGER                , INTENT(in   ), OPTIONAL ::   kdlev       ! size of the ice/abl third dimension
60      CHARACTER(len=3)       , INTENT(in   ), OPTIONAL ::   cdcomp      ! name of component calling iom_nf90_open
61
62      CHARACTER(LEN=256) ::   clinfo           ! info character
63      CHARACTER(LEN=256) ::   cltmp            ! temporary character
64      CHARACTER(LEN=12 ) ::   clfmt            ! writing format
65      CHARACTER(LEN=3  ) ::   clcomp           ! name of component calling iom_nf90_open
66      INTEGER            ::   idg              ! number of digits
67      INTEGER            ::   iln              ! lengths of character
68      INTEGER            ::   istop            ! temporary storage of nstop
69      INTEGER            ::   if90id           ! nf90 identifier of the opened file
70      INTEGER            ::   idmy             ! dummy variable
71      INTEGER            ::   jl               ! loop variable
72      INTEGER            ::   ichunk           ! temporary storage of nn_chunksz
73      INTEGER            ::   imode            ! creation mode flag: NF90_CLOBBER or NF90_NOCLOBBER or NF90_HDF5
74      INTEGER            ::   ihdf5            ! local variable for retrieval of value for NF90_HDF5
75      LOGICAL            ::   llclobber        ! local definition of ln_clobber
76      !---------------------------------------------------------------------
77      !
78      clinfo = '                    iom_nf90_open ~~~  '
79      istop = nstop     ! store the actual value of nstop
80      !
81      !                 !number of vertical levels
82      IF( PRESENT(cdcomp) )   THEN
83         IF( .NOT. PRESENT(kdlev) ) CALL ctl_stop( 'iom_nf90_open: cdcomp and kdlev must both be present' )
84         clcomp = cdcomp    ! use input value
85      ELSE
86         clcomp = 'OCE'     ! by default
87      ENDIF
88      !
89      IF( nn_chunksz > 0 ) THEN   ;   ichunk = nn_chunksz
90      ELSE                        ;   ichunk = NF90_SIZEHINT_DEFAULT
91      ENDIF
92      !
93      llclobber = ldwrt .AND. ln_clobber
94      IF( ldok .AND. .NOT. llclobber ) THEN      !==  Open existing file ==!
95         !                                       !=========================!
96         IF( ldwrt ) THEN  ! ... in write mode
97            IF(lwp) WRITE(numout,*) TRIM(clinfo)//' open existing file: '//TRIM(cdname)//' in WRITE mode'
98            IF( snc4set%luse ) THEN
99               CALL iom_nf90_check(NF90_OPEN( TRIM(cdname), NF90_WRITE  , if90id ), clinfo)
100            ELSE
101               CALL iom_nf90_check(NF90_OPEN( TRIM(cdname), NF90_WRITE  , if90id, chunksize = ichunk ), clinfo)
102            ENDIF
103            CALL iom_nf90_check(NF90_SET_FILL( if90id, NF90_NOFILL, idmy                          ), clinfo)
104         ELSE              ! ... in read mode
105            IF(lwp) WRITE(numout,*) TRIM(clinfo)//' open existing file: '//TRIM(cdname)//' in READ mode'
106            CALL iom_nf90_check(NF90_OPEN( TRIM(cdname), NF90_NOWRITE, if90id, chunksize = ichunk ), clinfo)
107         ENDIF
108      ELSE                                       !== the file doesn't exist ==!   (or we overwrite it)
109         !                                       !============================!
110         iln = INDEX( cdname, '.nc' )
111         IF( ldwrt ) THEN              !* the file should be open in write mode so we create it...
112            IF( jpnij > 1 ) THEN
113               idg = MAX( INT(LOG10(REAL(MAX(1,jpnij-1),wp))) + 1, 4 )          ! how many digits to we need to write? min=4, max=9
114               WRITE(clfmt, "('(a,a,i', i1, '.', i1, ',a)')") idg, idg          ! '(a,a,ix.x,a)'
115               WRITE(cltmp,clfmt) cdname(1:iln-1), '_', narea-1, '.nc'
116               cdname = TRIM(cltmp)
117            ENDIF
118            IF(lwp) WRITE(numout,*) TRIM(clinfo)//' create new file: '//TRIM(cdname)//' in WRITE mode'
119
120            IF( llclobber ) THEN   ;   imode = IOR( NF90_64BIT_OFFSET, NF90_CLOBBER   )
121            ELSE                   ;   imode = IOR( NF90_64BIT_OFFSET, NF90_NOCLOBBER ) 
122            ENDIF
123            IF( snc4set%luse ) THEN
124               IF(lwp) WRITE(numout,*) TRIM(clinfo)//' creating file: '//TRIM(cdname)//' in hdf5 (netcdf4) mode'
125               CALL GET_NF90_SYMBOL("NF90_HDF5", ihdf5)
126               IF( llclobber ) THEN   ;   imode = IOR(ihdf5, NF90_CLOBBER)
127               ELSE                   ;   imode = IOR(ihdf5, NF90_NOCLOBBER)
128               ENDIF
129               CALL iom_nf90_check(NF90_CREATE( TRIM(cdname), imode, if90id ), clinfo)
130            ELSE
131               CALL iom_nf90_check(NF90_CREATE( TRIM(cdname), imode, if90id, chunksize = ichunk ), clinfo)
132            ENDIF
133            CALL iom_nf90_check(NF90_SET_FILL( if90id, NF90_NOFILL,                   idmy ), clinfo)
134            ! define dimensions
135                               CALL iom_nf90_check(NF90_DEF_DIM( if90id,            'x',   kdompar(1,1), idmy ), clinfo)
136                               CALL iom_nf90_check(NF90_DEF_DIM( if90id,            'y',   kdompar(2,1), idmy ), clinfo)
137            SELECT CASE (clcomp)
138            CASE ('OCE')   ;   CALL iom_nf90_check(NF90_DEF_DIM( if90id,      'nav_lev',            jpk, idmy ), clinfo)
139            CASE ('ICE')   ;   CALL iom_nf90_check(NF90_DEF_DIM( if90id,       'numcat',          kdlev, idmy ), clinfo)
140            CASE ('ABL')   ;   CALL iom_nf90_check(NF90_DEF_DIM( if90id,      'nav_lev',          kdlev, idmy ), clinfo)
141            CASE ('SED')   ;   CALL iom_nf90_check(NF90_DEF_DIM( if90id,       'numsed',          kdlev, idmy ), clinfo)
142            CASE DEFAULT   ;   CALL ctl_stop( 'iom_nf90_open unknown component type' )
143            END SELECT
144                               CALL iom_nf90_check(NF90_DEF_DIM( if90id, 'time_counter', NF90_UNLIMITED, idmy ), clinfo)
145            ! global attributes
146            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_number_total'   , jpnij              ), clinfo)
147            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_number'         , narea-1            ), clinfo)
148            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_dimensions_ids' , (/1     , 2     /) ), clinfo)
149            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_size_global'    , (/jpiglo, jpjglo/) ), clinfo)
150            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_size_local'     , kdompar(:,1)       ), clinfo)
151            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_position_first' , kdompar(:,2)       ), clinfo)
152            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_position_last'  , kdompar(:,3)       ), clinfo)
153            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_halo_size_start', kdompar(:,4)       ), clinfo)
154            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_halo_size_end'  , kdompar(:,5)       ), clinfo)
155            CALL iom_nf90_check(NF90_PUT_ATT( if90id, NF90_GLOBAL, 'DOMAIN_type'           , 'BOX'              ), clinfo)
156         ELSE                          !* the file should be open for read mode so it must exist...
157            CALL ctl_stop( TRIM(clinfo), ' should be impossible case...' )
158         ENDIF
159      ENDIF
160      !
161      ! start to fill file informations
162      ! =============
163      IF( istop == nstop ) THEN   ! no error within this routine
164!does not work with some compilers         kiomid = MINLOC(iom_file(:)%nfid, dim = 1)
165         kiomid = 0
166         DO jl = jpmax_files, 1, -1
167            IF( iom_file(jl)%nfid == 0 )   kiomid = jl
168         ENDDO
169         iom_file(kiomid)%name   = TRIM(cdname)
170         iom_file(kiomid)%comp   = clcomp
171         iom_file(kiomid)%nfid   = if90id
172         iom_file(kiomid)%nvars  = 0
173         iom_file(kiomid)%irec   = -1   ! useless for NetCDF files, used to know if the file is in define mode
174         CALL iom_nf90_check(NF90_Inquire(if90id, unlimitedDimId = iom_file(kiomid)%iduld), clinfo)
175         IF( iom_file(kiomid)%iduld .GE. 0 ) THEN
176            CALL iom_nf90_check(NF90_Inquire_Dimension(if90id, iom_file(kiomid)%iduld,    & 
177               &                                       name = iom_file(kiomid)%uldname,   &
178               &                                       len  = iom_file(kiomid)%lenuld ), clinfo )
179         ENDIF
180         IF(lwp) WRITE(numout,*) '                   ---> '//TRIM(cdname)//' OK'
181      ELSE
182         kiomid = 0               ! return error flag
183      ENDIF
184      !
185   END SUBROUTINE iom_nf90_open
186
187
188   SUBROUTINE iom_nf90_close( kiomid )
189      !!--------------------------------------------------------------------
190      !!                   ***  SUBROUTINE  iom_nf90_close  ***
191      !!
192      !! ** Purpose : close an input file with NF90
193      !!--------------------------------------------------------------------
194      INTEGER, INTENT(in) ::   kiomid   ! iom identifier of the file to be closed
195      CHARACTER(LEN=100)  ::   clinfo   ! info character
196      !---------------------------------------------------------------------
197      clinfo = '      iom_nf90_close    , file: '//TRIM(iom_file(kiomid)%name)
198      CALL iom_nf90_check(NF90_CLOSE(iom_file(kiomid)%nfid), clinfo)
199   END SUBROUTINE iom_nf90_close
200
201
202   FUNCTION iom_nf90_varid ( kiomid, cdvar, kiv, kdimsz, kndims, lduld ) 
203      !!-----------------------------------------------------------------------
204      !!                  ***  FUNCTION  iom_varid  ***
205      !!
206      !! ** Purpose : get the id of a variable in a file with NF90
207      !!-----------------------------------------------------------------------
208      INTEGER              , INTENT(in   )           ::   kiomid   ! file Identifier
209      CHARACTER(len=*)     , INTENT(in   )           ::   cdvar    ! name of the variable
210      INTEGER              , INTENT(in   )           ::   kiv   !
211      INTEGER, DIMENSION(:), INTENT(  out), OPTIONAL ::   kdimsz   ! size of each dimension
212      INTEGER              , INTENT(  out), OPTIONAL ::   kndims   ! number of dimensions
213      LOGICAL              , INTENT(  out), OPTIONAL ::   lduld    ! true if the last dimension is unlimited (time)
214      !
215      INTEGER                        ::   iom_nf90_varid   ! iom variable Id
216      INTEGER                        ::   if90id           ! nf90 file identifier
217      INTEGER                        ::   ji               ! dummy loop index
218      INTEGER                        ::   ivarid           ! NetCDF  variable Id
219      INTEGER                        ::   i_nvd            ! number of dimension of the variable
220      INTEGER, DIMENSION(jpmax_dims) ::   idimid           ! dimension ids of the variable
221      LOGICAL                        ::   llok             ! ok  test
222      CHARACTER(LEN=100)             ::   clinfo           ! info character
223      !!-----------------------------------------------------------------------
224      clinfo = '          iom_nf90_varid, file: '//TRIM(iom_file(kiomid)%name)//', var: '//TRIM(cdvar)
225      iom_nf90_varid = 0                    ! default definition
226      IF( PRESENT(kdimsz) ) kdimsz(:) = 0   ! default definition
227      if90id = iom_file(kiomid)%nfid        ! get back NetCDF file id
228      !
229      llok = NF90_INQ_VARID( if90id, TRIM(cdvar), ivarid ) == nf90_noerr   ! does the variable exist in the file
230      IF( llok ) THEN
231         iom_nf90_varid = kiv
232         iom_file(kiomid)%nvars       = kiv
233         iom_file(kiomid)%nvid(kiv)   = ivarid
234         iom_file(kiomid)%cn_var(kiv) = TRIM(cdvar)
235         CALL iom_nf90_check(NF90_Inquire_Variable(if90id, ivarid, ndims = i_nvd), clinfo)   ! number of dimensions
236         iom_file(kiomid)%ndims(kiv)  = i_nvd
237         CALL iom_nf90_check(NF90_Inquire_Variable(if90id, ivarid, dimids = idimid(1:i_nvd)), clinfo)   ! dimensions ids
238         iom_file(kiomid)%luld(kiv) = .FALSE.   ! default value
239         iom_file(kiomid)%dimsz(:,kiv) = 0      ! reset dimsz in case previously used
240         DO ji = 1, i_nvd                       ! dimensions size
241            CALL iom_nf90_check(NF90_Inquire_Dimension(if90id, idimid(ji), len = iom_file(kiomid)%dimsz(ji,kiv)), clinfo)   
242            IF( idimid(ji) == iom_file(kiomid)%iduld ) iom_file(kiomid)%luld(kiv) = .TRUE.   ! unlimited dimension?
243         END DO
244         !---------- Deal with scale_factor and add_offset
245         llok = NF90_Inquire_attribute(if90id, ivarid, 'scale_factor') == nf90_noerr
246         IF( llok) THEN
247            CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, 'scale_factor', iom_file(kiomid)%scf(kiv)), clinfo)
248         ELSE
249            iom_file(kiomid)%scf(kiv) = 1.
250         END IF
251         llok = NF90_Inquire_attribute(if90id, ivarid, 'add_offset') == nf90_noerr
252         IF( llok ) THEN
253            CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, 'add_offset', iom_file(kiomid)%ofs(kiv)), clinfo)
254         ELSE
255            iom_file(kiomid)%ofs(kiv) = 0.
256         END IF
257         ! return the simension size
258         IF( PRESENT(kdimsz) ) THEN
259            IF( i_nvd <= SIZE(kdimsz) ) THEN
260               kdimsz(1:i_nvd) = iom_file(kiomid)%dimsz(1:i_nvd,kiv)
261            ELSE
262               WRITE(ctmp1,*) i_nvd, SIZE(kdimsz)
263               CALL ctl_stop( TRIM(clinfo), 'error in kdimsz size'//TRIM(ctmp1) )
264            ENDIF
265         ENDIF
266         IF( PRESENT(kndims) )  kndims = iom_file(kiomid)%ndims(kiv)
267         IF( PRESENT( lduld) )  lduld  = iom_file(kiomid)%luld(kiv)
268      ELSE 
269         iom_nf90_varid = -1   !   variable not found, return error code: -1
270      ENDIF
271      !
272   END FUNCTION iom_nf90_varid
273
274   !!----------------------------------------------------------------------
275   !!                   INTERFACE iom_nf90_get
276   !!----------------------------------------------------------------------
277
278   SUBROUTINE iom_nf90_g0d( kiomid, kvid, pvar, kstart )
279      !!-----------------------------------------------------------------------
280      !!                  ***  ROUTINE  iom_nf90_g0d  ***
281      !!
282      !! ** Purpose : read a scalar with NF90
283      !!-----------------------------------------------------------------------
284      INTEGER ,               INTENT(in   )            ::   kiomid   ! Identifier of the file
285      INTEGER ,               INTENT(in   )            ::   kvid     ! variable id
286      REAL(wp),               INTENT(  out)            ::   pvar     ! read field
287      INTEGER , DIMENSION(1), INTENT(in   ), OPTIONAL  ::   kstart   ! start position of the reading in each axis
288      !
289      CHARACTER(LEN=100)      ::   clinfo   ! info character
290      !---------------------------------------------------------------------
291      clinfo = 'iom_nf90_g0d , file: '//TRIM(iom_file(kiomid)%name)//', var: '//TRIM(iom_file(kiomid)%cn_var(kvid))
292      CALL iom_nf90_check(NF90_GET_VAR(iom_file(kiomid)%nfid, iom_file(kiomid)%nvid(kvid), pvar, start = kstart), clinfo )
293   END SUBROUTINE iom_nf90_g0d
294
295
296   SUBROUTINE iom_nf90_g123d( kiomid, kvid, knbdim, kstart, kcount, kx1, kx2, ky1, ky2,   &
297         &                    pv_r1d, pv_r2d, pv_r3d )
298      !!-----------------------------------------------------------------------
299      !!                  ***  ROUTINE  iom_nf90_g123d  ***
300      !!
301      !! ** Purpose : read a 1D/2D/3D variable with NF90
302      !!
303      !! ** Method : read ONE record at each CALL
304      !!-----------------------------------------------------------------------
305      INTEGER                    , INTENT(in   )           ::   kiomid    ! iom identifier of the file
306      INTEGER                    , INTENT(in   )           ::   kvid      ! Name of the variable
307      INTEGER                    , INTENT(in   )           ::   knbdim    ! number of dimensions of the variable
308      INTEGER , DIMENSION(:)     , INTENT(in   )           ::   kstart    ! start position of the reading in each axis
309      INTEGER , DIMENSION(:)     , INTENT(in   )           ::   kcount    ! number of points to be read in each axis
310      INTEGER ,                    INTENT(in   )           ::   kx1, kx2, ky1, ky2   ! subdomain indexes
311      REAL(wp), DIMENSION(:)     , INTENT(  out), OPTIONAL ::   pv_r1d    ! read field (1D case)
312      REAL(wp), DIMENSION(:,:)   , INTENT(  out), OPTIONAL ::   pv_r2d    ! read field (2D case)
313      REAL(wp), DIMENSION(:,:,:) , INTENT(  out), OPTIONAL ::   pv_r3d    ! read field (3D case)
314      !
315      CHARACTER(LEN=100) ::   clinfo               ! info character
316      INTEGER            ::   if90id               ! nf90 identifier of the opened file
317      INTEGER            ::   ivid                 ! nf90 variable id
318      !---------------------------------------------------------------------
319      clinfo = 'iom_nf90_g123d , file: '//TRIM(iom_file(kiomid)%name)//', var: '//TRIM(iom_file(kiomid)%cn_var(kvid))
320      if90id = iom_file(kiomid)%nfid         ! get back NetCDF file id
321      ivid   = iom_file(kiomid)%nvid(kvid)   ! get back NetCDF var id
322      !
323      IF(     PRESENT(pv_r1d) ) THEN
324         CALL iom_nf90_check( NF90_GET_VAR(if90id, ivid, pv_r1d(:                ), start = kstart(1:knbdim),   &
325            &                                                                       count = kcount(1:knbdim)), clinfo )
326      ELSEIF( PRESENT(pv_r2d) ) THEN
327         CALL iom_nf90_check( NF90_GET_VAR(if90id, ivid, pv_r2d(kx1:kx2,ky1:ky2  ), start = kstart(1:knbdim),   &
328            &                                                                       count = kcount(1:knbdim)), clinfo )
329      ELSEIF( PRESENT(pv_r3d) ) THEN
330         CALL iom_nf90_check( NF90_GET_VAR(if90id, ivid, pv_r3d(kx1:kx2,ky1:ky2,:), start = kstart(1:knbdim),   &
331            &                                                                       count = kcount(1:knbdim)), clinfo )
332      ENDIF
333      !
334   END SUBROUTINE iom_nf90_g123d
335
336
337   SUBROUTINE iom_nf90_chkatt( kiomid, cdatt, llok, ksize, cdvar )
338      !!-----------------------------------------------------------------------
339      !!                  ***  ROUTINE  iom_nf90_chkatt  ***
340      !!
341      !! ** Purpose : check existence of attribute with NF90
342      !!              (either a global attribute (default) or a variable
343      !!               attribute if optional variable name is supplied (cdvar))
344      !!-----------------------------------------------------------------------
345      INTEGER         , INTENT(in   ) ::   kiomid   ! Identifier of the file
346      CHARACTER(len=*), INTENT(in   ) ::   cdatt    ! attribute name
347      LOGICAL         , INTENT(  out) ::   llok     ! error code
348      INTEGER         , INTENT(  out), OPTIONAL     &
349                      &               ::   ksize    ! attribute size
350      CHARACTER(len=*), INTENT(in   ), OPTIONAL     &
351                      &               ::   cdvar    ! name of the variable
352      !
353      INTEGER                         ::   if90id   ! temporary integer
354      INTEGER                         ::   isize    ! temporary integer
355      INTEGER                         ::   ivarid   ! NetCDF variable Id
356      !---------------------------------------------------------------------
357      !
358      if90id = iom_file(kiomid)%nfid
359      IF( PRESENT(cdvar) ) THEN
360         ! check the variable exists in the file
361         llok = NF90_INQ_VARID( if90id, TRIM(cdvar), ivarid ) == nf90_noerr
362         IF( llok ) &
363            ! check the variable has the attribute required
364            llok = NF90_Inquire_attribute(if90id, ivarid, cdatt, len=isize ) == nf90_noerr
365      ELSE
366         llok = NF90_Inquire_attribute(if90id, NF90_GLOBAL, cdatt, len=isize ) == nf90_noerr
367      ENDIF
368      !
369      IF( PRESENT(ksize) ) ksize = isize
370      !
371      IF( .not. llok) &
372         CALL ctl_warn('iom_nf90_chkatt: no attribute '//cdatt//' found')
373      !
374   END SUBROUTINE iom_nf90_chkatt
375
376
377   !!----------------------------------------------------------------------
378   !!                   INTERFACE iom_nf90_getatt
379   !!----------------------------------------------------------------------
380
381   SUBROUTINE iom_nf90_getatt( kiomid, cdatt, katt0d, katt1d, patt0d, patt1d, cdatt0d, cdvar)
382      !!-----------------------------------------------------------------------
383      !!                  ***  ROUTINE  iom_nf90_getatt  ***
384      !!
385      !! ** Purpose : read an attribute with NF90
386      !!              (either a global attribute (default) or a variable
387      !!               attribute if optional variable name is supplied (cdvar))
388      !!-----------------------------------------------------------------------
389      INTEGER               , INTENT(in   )           ::   kiomid   ! Identifier of the file
390      CHARACTER(len=*)      , INTENT(in   )           ::   cdatt    ! attribute name
391      INTEGER               , INTENT(  out), OPTIONAL ::   katt0d   ! read scalar integer
392      INTEGER, DIMENSION(:) , INTENT(  out), OPTIONAL ::   katt1d   ! read 1d array integer
393      REAL(wp)              , INTENT(  out), OPTIONAL ::   patt0d   ! read scalar  real
394      REAL(wp), DIMENSION(:), INTENT(  out), OPTIONAL ::   patt1d   ! read 1d array real
395      CHARACTER(len=*)      , INTENT(  out), OPTIONAL ::   cdatt0d  ! read character
396      CHARACTER(len=*)      , INTENT(in   ), OPTIONAL ::   cdvar    ! name of the variable
397      !
398      INTEGER                         ::   if90id   ! temporary integer
399      INTEGER                         ::   ivarid   ! NetCDF variable Id
400      LOGICAL                         ::   llok     ! temporary logical
401      CHARACTER(LEN=100)              ::   clinfo   ! info character
402      !---------------------------------------------------------------------
403      !
404      if90id = iom_file(kiomid)%nfid
405      IF( PRESENT(cdvar) ) THEN
406         ! check the variable exists in the file
407         llok = NF90_INQ_VARID( if90id, TRIM(cdvar), ivarid ) == nf90_noerr
408         IF( llok ) THEN
409            ! check the variable has the attribute required
410            llok = NF90_Inquire_attribute(if90id, ivarid, cdatt) == nf90_noerr
411         ELSE
412            CALL ctl_warn('iom_nf90_getatt: no variable '//TRIM(cdvar)//' found')
413         ENDIF
414      ELSE
415         llok = NF90_Inquire_attribute(if90id, NF90_GLOBAL, cdatt) == nf90_noerr
416         ivarid = NF90_GLOBAL
417      ENDIF
418      !
419      IF( llok) THEN
420         clinfo = 'iom_nf90_getatt, file: '//TRIM(iom_file(kiomid)%name)//', att: '//TRIM(cdatt)
421         IF(PRESENT( katt0d))   CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, cdatt, values =  katt0d), clinfo)
422         IF(PRESENT( katt1d))   CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, cdatt, values =  katt1d), clinfo)
423         IF(PRESENT( patt0d))   CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, cdatt, values =  patt0d), clinfo)
424         IF(PRESENT( patt1d))   CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, cdatt, values =  patt1d), clinfo)
425         IF(PRESENT(cdatt0d))   CALL iom_nf90_check(NF90_GET_ATT(if90id, ivarid, cdatt, values = cdatt0d), clinfo)
426      ELSE
427         CALL ctl_warn('iom_nf90_getatt: no attribute '//TRIM(cdatt)//' found')
428         IF(PRESENT( katt0d))    katt0d    = -999
429         IF(PRESENT( katt1d))    katt1d(:) = -999
430         IF(PRESENT( patt0d))    patt0d    = -999._wp
431         IF(PRESENT( patt1d))    patt1d(:) = -999._wp
432         IF(PRESENT(cdatt0d))   cdatt0d    = '!'
433      ENDIF
434      !
435   END SUBROUTINE iom_nf90_getatt
436
437
438   SUBROUTINE iom_nf90_putatt( kiomid, cdatt, katt0d, katt1d, patt0d, patt1d, cdatt0d, cdvar)
439      !!-----------------------------------------------------------------------
440      !!                  ***  ROUTINE  iom_nf90_putatt  ***
441      !!
442      !! ** Purpose : write an attribute with NF90
443      !!              (either a global attribute (default) or a variable
444      !!               attribute if optional variable name is supplied (cdvar))
445      !!-----------------------------------------------------------------------
446      INTEGER               , INTENT(in   )           ::   kiomid   ! Identifier of the file
447      CHARACTER(len=*)      , INTENT(in   )           ::   cdatt    ! attribute name
448      INTEGER               , INTENT(in   ), OPTIONAL ::   katt0d   ! read scalar integer
449      INTEGER, DIMENSION(:) , INTENT(in   ), OPTIONAL ::   katt1d   ! read 1d array integer
450      REAL(wp)              , INTENT(in   ), OPTIONAL ::   patt0d   ! read scalar  real
451      REAL(wp), DIMENSION(:), INTENT(in   ), OPTIONAL ::   patt1d   ! read 1d array real
452      CHARACTER(len=*)      , INTENT(in   ), OPTIONAL ::   cdatt0d  ! read character
453      CHARACTER(len=*)      , INTENT(in   ), OPTIONAL ::   cdvar    ! name of the variable
454      !
455      INTEGER                         ::   if90id   ! temporary integer
456      INTEGER                         ::   ivarid   ! NetCDF variable Id
457      INTEGER                         ::   isize    ! Attribute size
458      INTEGER                         ::   itype    ! Attribute type
459      LOGICAL                         ::   llok     ! temporary logical
460      LOGICAL                         ::   llatt     ! temporary logical
461      LOGICAL                         ::   lldata   ! temporary logical
462      CHARACTER(LEN=100)              ::   clinfo   ! info character
463      !---------------------------------------------------------------------
464      !
465      if90id = iom_file(kiomid)%nfid
466      IF( PRESENT(cdvar) ) THEN
467         llok = NF90_INQ_VARID( if90id, TRIM(cdvar), ivarid ) == nf90_noerr   ! is the variable in the file?
468         IF( .NOT. llok ) THEN
469            CALL ctl_warn('iom_nf90_putatt: no variable '//TRIM(cdvar)//' found'   &
470               &        , '                 no attribute '//cdatt//' written' )
471            RETURN
472         ENDIF
473      ELSE
474         ivarid = NF90_GLOBAL
475      ENDIF
476      llatt = NF90_Inquire_attribute(if90id, ivarid, cdatt, len = isize, xtype = itype ) == nf90_noerr
477      !
478      ! trick: irec used to know if the file is in define mode or not
479      lldata = iom_file(kiomid)%irec /= -1   ! default: go back in define mode if in data mode
480      IF( lldata .AND. llatt ) THEN          ! attribute already there. Do we really need to go back in define mode?
481         ! do we have the appropriate type?
482         IF(PRESENT( katt0d) .OR. PRESENT( katt1d))   llok = itype == NF90_INT
483         IF(PRESENT( patt0d) .OR. PRESENT( patt1d))   llok = itype == NF90_DOUBLE
484         IF(PRESENT(cdatt0d)                      )   llok = itype == NF90_CHAR
485         ! and do we have the appropriate size?
486         IF(PRESENT( katt0d))   llok = llok .AND. isize == 1
487         IF(PRESENT( katt1d))   llok = llok .AND. isize == SIZE(katt1d)
488         IF(PRESENT( patt0d))   llok = llok .AND. isize == 1
489         IF(PRESENT( patt1d))   llok = llok .AND. isize == SIZE(patt1d)
490         IF(PRESENT(cdatt0d))   llok = llok .AND. isize == LEN_TRIM(cdatt0d)
491         !
492         lldata = .NOT. llok
493      ENDIF
494      !
495      clinfo = 'iom_nf90_putatt, file: '//TRIM(iom_file(kiomid)%name)//', att: '//TRIM(cdatt)
496      IF(lldata)   CALL iom_nf90_check(NF90_REDEF( if90id ), clinfo)   ! leave data mode to define mode
497      !
498      IF(PRESENT( katt0d))   CALL iom_nf90_check(NF90_PUT_ATT(if90id, ivarid, cdatt, values =       katt0d) , clinfo)
499      IF(PRESENT( katt1d))   CALL iom_nf90_check(NF90_PUT_ATT(if90id, ivarid, cdatt, values =       katt1d) , clinfo)
500      IF(PRESENT( patt0d))   CALL iom_nf90_check(NF90_PUT_ATT(if90id, ivarid, cdatt, values =       patt0d) , clinfo)
501      IF(PRESENT( patt1d))   CALL iom_nf90_check(NF90_PUT_ATT(if90id, ivarid, cdatt, values =       patt1d) , clinfo)
502      IF(PRESENT(cdatt0d))   CALL iom_nf90_check(NF90_PUT_ATT(if90id, ivarid, cdatt, values = trim(cdatt0d)), clinfo)
503      !
504      IF(lldata)   CALL iom_nf90_check(NF90_ENDDEF( if90id ), clinfo)   ! leave define mode to data mode
505      !
506   END SUBROUTINE iom_nf90_putatt
507
508
509   SUBROUTINE iom_nf90_rp0123d( kt, kwrite, kiomid, cdvar , kvid  , ktype,   &
510         &                                  pv_r0d, pv_r1d, pv_r2d, pv_r3d )
511      !!--------------------------------------------------------------------
512      !!                   ***  SUBROUTINE  iom_nf90_rstput  ***
513      !!
514      !! ** Purpose : read the time axis cdvar in the file
515      !!--------------------------------------------------------------------
516      INTEGER                     , INTENT(in)           ::   kt       ! ocean time-step
517      INTEGER                     , INTENT(in)           ::   kwrite   ! writing time-step
518      INTEGER                     , INTENT(in)           ::   kiomid   ! Identifier of the file
519      CHARACTER(len=*)            , INTENT(in)           ::   cdvar    ! variable name
520      INTEGER                     , INTENT(in)           ::   kvid     ! variable id
521      INTEGER                     , INTENT(in), OPTIONAL ::   ktype    ! variable type (default R8)
522      REAL(wp)                    , INTENT(in), OPTIONAL ::   pv_r0d   ! written Od field
523      REAL(wp), DIMENSION(      :), INTENT(in), OPTIONAL ::   pv_r1d   ! written 1d field
524      REAL(wp), DIMENSION(:, :   ), INTENT(in), OPTIONAL ::   pv_r2d   ! written 2d field
525      REAL(wp), DIMENSION(:, :, :), INTENT(in), OPTIONAL ::   pv_r3d   ! written 3d field
526      !
527      INTEGER               :: idims                ! number of dimension
528      INTEGER               :: idvar                ! variable id
529      INTEGER               :: jd                   ! dimension loop counter   
530      INTEGER               :: ix1, ix2, iy1, iy2   ! subdomain indexes   
531      INTEGER, DIMENSION(4) :: idimsz               ! dimensions size 
532      INTEGER, DIMENSION(4) :: idimid               ! dimensions id
533      CHARACTER(LEN=256)    :: clinfo               ! info character
534      INTEGER               :: if90id               ! nf90 file identifier
535      INTEGER               :: itype                ! variable type
536      INTEGER, DIMENSION(4) :: ichunksz             ! NetCDF4 chunk sizes. Will be computed using
537      !                                             ! nn_nchunks_[i,j,k,t] namelist parameters
538      INTEGER               :: ichunkalg, ishuffle, ideflate, ideflate_level
539      !                                             ! NetCDF4 internally fixed parameters
540      LOGICAL               :: lchunk               ! logical switch to activate chunking and compression
541      !                                             ! when appropriate (currently chunking is applied to 4d fields only)
542      INTEGER               :: idlv                 ! local variable
543      !---------------------------------------------------------------------
544      !
545      clinfo = '          iom_nf90_rp0123d, file: '//TRIM(iom_file(kiomid)%name)//', var: '//TRIM(cdvar)
546      if90id = iom_file(kiomid)%nfid
547      !
548      ! define dimension variables if it is not already done
549      ! ==========================
550      IF( iom_file(kiomid)%nvars == 0 ) THEN
551         ! are we in define mode?
552         IF( iom_file(kiomid)%irec /= -1 ) THEN   ! trick: irec used to know if the file is in define mode or not
553            CALL iom_nf90_check(NF90_REDEF( if90id ), clinfo)   ;   iom_file(kiomid)%irec = -1
554         ENDIF
555         ! define the dimension variables if it is not already done
556         DO jd = 1, 2
557            CALL iom_nf90_check(NF90_INQUIRE_DIMENSION(if90id,jd,iom_file(kiomid)%cn_var(jd),iom_file(kiomid)%dimsz(jd,jd)),clinfo)
558            CALL iom_nf90_check(NF90_DEF_VAR( if90id, TRIM(iom_file(kiomid)%cn_var(jd)), NF90_FLOAT , (/ 1, 2 /),   &
559               &                              iom_file(kiomid)%nvid(jd) ), clinfo)
560         END DO
561         iom_file(kiomid)%dimsz(2,1) = iom_file(kiomid)%dimsz(2,2)   ! second dim of first  variable
562         iom_file(kiomid)%dimsz(1,2) = iom_file(kiomid)%dimsz(1,1)   ! first  dim of second variable
563         DO jd = 3, 4
564            CALL iom_nf90_check(NF90_INQUIRE_DIMENSION(if90id,jd,iom_file(kiomid)%cn_var(jd),iom_file(kiomid)%dimsz(1,jd)), clinfo)
565            CALL iom_nf90_check(NF90_DEF_VAR( if90id, TRIM(iom_file(kiomid)%cn_var(jd)), NF90_FLOAT , (/ jd   /),   &
566               &                              iom_file(kiomid)%nvid(jd) ), clinfo)
567         END DO
568         ! update informations structure related the dimension variable we just added...
569         iom_file(kiomid)%nvars       = 4
570         iom_file(kiomid)%luld(1:4)   = (/ .FALSE., .FALSE., .FALSE., .TRUE. /)
571         iom_file(kiomid)%ndims(1:4)  = (/ 2, 2, 1, 1 /)
572         IF(lwp) WRITE(numout,*) TRIM(clinfo)//' define dimension variables done'
573      ENDIF
574      ! define the data if it is not already done
575      ! ===============
576      IF( kvid <= 0 ) THEN
577         !
578         ! NetCDF4 chunking and compression fixed settings
579         ichunkalg = 0
580         ishuffle = 1
581         ideflate = 1
582         ideflate_level = 1
583         !
584         idvar = iom_file(kiomid)%nvars + 1
585         ! are we in define mode?
586         IF( iom_file(kiomid)%irec /= -1 ) THEN   ! trick: irec used to know if the file is in define mode or not
587            CALL iom_nf90_check(NF90_REDEF( if90id ), clinfo)   ;   iom_file(kiomid)%irec = -1
588         ENDIF
589         ! variable definition
590         IF(     PRESENT(pv_r0d) ) THEN   ;   idims = 0
591         ELSEIF( PRESENT(pv_r1d) ) THEN
592                                              idims = 2   ;   idimid(1:idims) = (/3,4/)
593         ELSEIF( PRESENT(pv_r2d) ) THEN   ;   idims = 3   ;   idimid(1:idims) = (/1,2,4/)
594         ELSEIF( PRESENT(pv_r3d) ) THEN
595                                              idims = 4   ;   idimid(1:idims) = (/1,2,3,4/)
596         ENDIF
597         IF( PRESENT(ktype) ) THEN   ! variable external type
598            SELECT CASE (ktype)
599            CASE (jp_r8)   ;   itype = NF90_DOUBLE
600            CASE (jp_r4)   ;   itype = NF90_FLOAT
601            CASE (jp_i4)   ;   itype = NF90_INT
602            CASE (jp_i2)   ;   itype = NF90_SHORT
603            CASE (jp_i1)   ;   itype = NF90_BYTE
604            CASE DEFAULT   ;   CALL ctl_stop( TRIM(clinfo)//' unknown variable type' )
605            END SELECT
606         ELSE
607            itype = NF90_DOUBLE
608         ENDIF
609         IF( PRESENT(pv_r0d) ) THEN
610            CALL iom_nf90_check(NF90_DEF_VAR( if90id, TRIM(cdvar), itype,                    &
611               &                              iom_file(kiomid)%nvid(idvar) ), clinfo )
612         ELSE
613            CALL iom_nf90_check(NF90_DEF_VAR( if90id, TRIM(cdvar), itype, idimid(1:idims),   &
614               &                              iom_file(kiomid)%nvid(idvar) ), clinfo )
615         ENDIF
616         lchunk = .false.
617         IF( snc4set%luse .AND. idims == 4 )   lchunk = .true.
618         ! update informations structure related the new variable we want to add...
619         iom_file(kiomid)%nvars         = idvar
620         iom_file(kiomid)%cn_var(idvar) = TRIM(cdvar)
621         iom_file(kiomid)%scf(idvar)    = 1.
622         iom_file(kiomid)%ofs(idvar)    = 0.
623         iom_file(kiomid)%ndims(idvar)  = idims
624         IF( .NOT. PRESENT(pv_r0d) ) THEN   ;   iom_file(kiomid)%luld(idvar) = .TRUE.
625         ELSE                               ;   iom_file(kiomid)%luld(idvar) = .FALSE.
626         ENDIF
627         DO jd = 1, idims
628            CALL iom_nf90_check(NF90_INQUIRE_DIMENSION( if90id, idimid(jd), len = iom_file(kiomid)%dimsz(jd,idvar) ), clinfo)
629            IF ( lchunk ) ichunksz(jd) = iom_file(kiomid)%dimsz(jd,idvar)
630         END DO
631         IF ( lchunk ) THEN
632            ! Calculate chunk sizes by partitioning each dimension as requested in namnc4 namelist
633            ! Disallow very small chunk sizes and prevent chunk sizes larger than each individual dimension
634            ichunksz(1) = MIN( ichunksz(1),MAX( (ichunksz(1)-1)/snc4set%ni + 1 ,16 ) ) ! Suggested default nc4set%ni=4
635            ichunksz(2) = MIN( ichunksz(2),MAX( (ichunksz(2)-1)/snc4set%nj + 1 ,16 ) ) ! Suggested default nc4set%nj=2
636            ichunksz(3) = MIN( ichunksz(3),MAX( (ichunksz(3)-1)/snc4set%nk + 1 , 1 ) ) ! Suggested default nc4set%nk=6
637            ichunksz(4) = 1                                                            ! Do not allow chunks to span the
638            !                                                                          ! unlimited dimension
639            CALL iom_nf90_check(SET_NF90_DEF_VAR_CHUNKING(if90id, idvar, ichunkalg, ichunksz), clinfo)
640            CALL iom_nf90_check(SET_NF90_DEF_VAR_DEFLATE(if90id, idvar, ishuffle, ideflate, ideflate_level), clinfo)
641            IF(lwp) WRITE(numout,*) TRIM(clinfo)//' chunked ok. Chunks sizes: ', ichunksz
642         ENDIF
643         IF(lwp) WRITE(numout,*) TRIM(clinfo)//' defined ok'
644      ELSE
645         idvar = kvid
646      ENDIF
647      !
648      ! time step kwrite : write the variable
649      IF( kt == kwrite ) THEN
650         ! are we in write mode?
651         IF( iom_file(kiomid)%irec == -1 ) THEN   ! trick: irec used to know if the file is in define mode or not
652            CALL iom_nf90_check(NF90_ENDDEF( if90id ), clinfo)   ;   iom_file(kiomid)%irec = 0
653         ENDIF
654         ! on what kind of domain must the data be written?
655         IF( PRESENT(pv_r2d) .OR. PRESENT(pv_r3d) ) THEN
656            idimsz(1:2) = iom_file(kiomid)%dimsz(1:2,idvar)
657            IF(     idimsz(1) == (nlei - nldi + 1) .AND. idimsz(2) == (nlej - nldj + 1) ) THEN
658               ix1 = nldi   ;   ix2 = nlei   ;   iy1 = nldj   ;   iy2 = nlej
659            ELSEIF( idimsz(1) == nlci              .AND. idimsz(2) == nlcj              ) THEN
660               ix1 = 1      ;   ix2 = nlci   ;   iy1 = 1      ;   iy2 = nlcj
661            ELSEIF( idimsz(1) == jpi               .AND. idimsz(2) == jpj               ) THEN
662               ix1 = 1      ;   ix2 = jpi    ;   iy1 = 1      ;   iy2 = jpj
663            ELSE
664               CALL ctl_stop( 'iom_nf90_rp0123d: should have been an impossible case...' )
665            ENDIF
666
667            ! write dimension variables if it is not already done
668            ! =============
669            ! trick: is defined to 0 => dimension variable are defined but not yet written
670            IF( iom_file(kiomid)%dimsz(1, 4) == 0 ) THEN   ! time_counter = 0
671               CALL iom_nf90_check(    NF90_PUT_VAR( if90id, 1,                            glamt(ix1:ix2, iy1:iy2) ), clinfo )
672               CALL iom_nf90_check(    NF90_PUT_VAR( if90id, 2,                            gphit(ix1:ix2, iy1:iy2) ), clinfo )
673               SELECT CASE (iom_file(kiomid)%comp)
674               CASE ('OCE') 
675                  CALL iom_nf90_check( NF90_PUT_VAR( if90id, 3,                                           gdept_1d ), clinfo )
676               CASE ('ABL')
677                  CALL iom_nf90_check( NF90_PUT_VAR( if90id, 3,                                            ght_abl ), clinfo )
678               CASE DEFAULT
679                  CALL iom_nf90_check( NF90_PUT_VAR( if90id, 3, (/ (idlv, idlv = 1,iom_file(kiomid)%dimsz(1,3)) /) ), clinfo )
680               END SELECT
681               ! "wrong" value: to be improved but not really useful...
682               CALL iom_nf90_check(   NF90_PUT_VAR( if90id, 4,                                                  kt ), clinfo )   
683               ! update the size of the variable corresponding to the unlimited dimension
684               iom_file(kiomid)%dimsz(1, 4) = 1   ! so we don't enter this IF case any more...
685               IF(lwp) WRITE(numout,*) TRIM(clinfo)//' write dimension variables done'
686            ENDIF
687         ENDIF
688
689         ! write the data
690         ! =============
691         IF(     PRESENT(pv_r0d) ) THEN
692            CALL iom_nf90_check( NF90_PUT_VAR( if90id, idvar, pv_r0d                    ), clinfo )
693         ELSEIF( PRESENT(pv_r1d) ) THEN
694            CALL iom_nf90_check( NF90_PUT_VAR( if90id, idvar, pv_r1d(:)                 ), clinfo )
695         ELSEIF( PRESENT(pv_r2d) ) THEN
696            CALL iom_nf90_check( NF90_PUT_VAR( if90id, idvar, pv_r2d(ix1:ix2,iy1:iy2)   ), clinfo )
697         ELSEIF( PRESENT(pv_r3d) ) THEN
698            CALL iom_nf90_check( NF90_PUT_VAR( if90id, idvar, pv_r3d(ix1:ix2,iy1:iy2,:) ), clinfo )
699         ENDIF
700         ! add 1 to the size of the temporal dimension (not really useful...)
701         IF( iom_file(kiomid)%luld(idvar) )   iom_file(kiomid)%dimsz(iom_file(kiomid)%ndims(idvar), idvar)    &
702               &                            = iom_file(kiomid)%dimsz(iom_file(kiomid)%ndims(idvar), idvar) + 1
703         IF(lwp) WRITE(numout,*) TRIM(clinfo)//' written ok'
704      ENDIF
705      !     
706   END SUBROUTINE iom_nf90_rp0123d
707
708
709   SUBROUTINE iom_nf90_check( kstatus, cdinfo )
710      !!--------------------------------------------------------------------
711      !!                   ***  SUBROUTINE iom_nf90_check  ***
712      !!
713      !! ** Purpose :   check nf90 errors
714      !!--------------------------------------------------------------------
715      INTEGER,          INTENT(in) :: kstatus
716      CHARACTER(LEN=*), INTENT(in) :: cdinfo
717      !---------------------------------------------------------------------
718      IF(kstatus /= nf90_noerr)   CALL ctl_stop( 'iom_nf90_check : '//TRIM(nf90_strerror(kstatus)), TRIM(cdinfo) )
719   END SUBROUTINE iom_nf90_check
720
721   !!======================================================================
722END MODULE iom_nf90
Note: See TracBrowser for help on using the repository browser.