New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
iom_nf90.F90 in NEMO/branches/2020/r4.0-HEAD_ticket2425/src/OCE/IOM – NEMO

source: NEMO/branches/2020/r4.0-HEAD_ticket2425/src/OCE/IOM/iom_nf90.F90 @ 13077

Last change on this file since 13077 was 13077, checked in by davestorkey, 4 years ago

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