source: trunk/NEMOGCM/NEMO/OPA_SRC/SBC/sbcrnf.F90 @ 3598

Last change on this file since 3598 was 3598, checked in by rblod, 8 years ago

Change of some variable range for TAM in 3.4 - Ticket #1004

  • Property svn:keywords set to Id
File size: 26.8 KB
Line 
1MODULE sbcrnf
2   !!======================================================================
3   !!                       ***  MODULE  sbcrnf  ***
4   !! Ocean forcing:  river runoff
5   !!=====================================================================
6   !! History :  OPA  ! 2000-11  (R. Hordoir, E. Durand)  NetCDF FORMAT
7   !!   NEMO     1.0  ! 2002-09  (G. Madec)  F90: Free form and module
8   !!            3.0  ! 2006-07  (G. Madec)  Surface module
9   !!            3.2  ! 2009-04  (B. Lemaire)  Introduce iom_put
10   !!            3.3  ! 2010-10  (R. Furner, G. Madec) runoff distributed over ocean levels
11   !!----------------------------------------------------------------------
12
13   !!----------------------------------------------------------------------
14   !!   sbc_rnf      : monthly runoffs read in a NetCDF file
15   !!   sbc_rnf_init : runoffs initialisation
16   !!   rnf_mouth    : set river mouth mask
17   !!----------------------------------------------------------------------
18   USE dom_oce         ! ocean space and time domain
19   USE phycst          ! physical constants
20   USE sbc_oce         ! surface boundary condition variables
21   USE closea          ! closed seas
22   USE fldread         ! read input field at current time step
23   USE restart         ! restart
24   USE in_out_manager  ! I/O manager
25   USE iom             ! I/O module
26   USE lib_mpp         ! MPP library
27
28   IMPLICIT NONE
29   PRIVATE
30
31   PUBLIC   sbc_rnf       ! routine call in sbcmod module
32   PUBLIC   sbc_rnf_div   ! routine called in sshwzv module
33   PUBLIC   sbc_rnf_alloc ! routine call in sbcmod module
34   PUBLIC   sbc_rnf_init  ! (PUBLIC for TAM)
35   !                                                     !!* namsbc_rnf namelist *
36   CHARACTER(len=100), PUBLIC ::   cn_dir       = './'    !: Root directory for location of ssr files
37   LOGICAL           , PUBLIC ::   ln_rnf_depth = .false. !: depth       river runoffs attribute specified in a file
38   LOGICAL           , PUBLIC ::   ln_rnf_tem   = .false. !: temperature river runoffs attribute specified in a file
39   LOGICAL           , PUBLIC ::   ln_rnf_sal   = .false. !: salinity    river runoffs attribute specified in a file
40   LOGICAL           , PUBLIC ::   ln_rnf_emp   = .false. !: runoffs into a file to be read or already into precipitation
41   TYPE(FLD_N)       , PUBLIC ::   sn_rnf                 !: information about the runoff file to be read
42   TYPE(FLD_N)       , PUBLIC ::   sn_cnf                 !: information about the runoff mouth file to be read
43   TYPE(FLD_N)                ::   sn_s_rnf               !: information about the salinities of runoff file to be read
44   TYPE(FLD_N)                ::   sn_t_rnf               !: information about the temperatures of runoff file to be read
45   TYPE(FLD_N)                ::   sn_dep_rnf             !: information about the depth which river inflow affects
46   LOGICAL           , PUBLIC ::   ln_rnf_mouth = .false. !: specific treatment in mouths vicinity
47   REAL(wp)          , PUBLIC ::   rn_hrnf      = 0._wp   !: runoffs, depth over which enhanced vertical mixing is used
48   REAL(wp)          , PUBLIC ::   rn_avt_rnf   = 0._wp   !: runoffs, value of the additional vertical mixing coef. [m2/s]
49   REAL(wp)          , PUBLIC ::   rn_rfact     = 1._wp   !: multiplicative factor for runoff
50
51   INTEGER , PUBLIC  ::   nkrnf = 0         !: nb of levels over which Kz is increased at river mouths
52   REAL(wp), PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:,:)   ::   rnfmsk              !: river mouth mask (hori.)
53   REAL(wp), PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:)     ::   rnfmsk_z            !: river mouth mask (vert.)
54   REAL(wp), PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:,:)   ::   h_rnf               !: depth of runoff in m
55   INTEGER,  PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:,:)   ::   nk_rnf              !: depth of runoff in model levels
56   REAL(wp), PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:,:,:) ::   rnf_tsc_b, rnf_tsc  !: before and now T & S runoff contents   [K.m/s & PSU.m/s]
57
58   REAL(wp) ::   r1_rau0   ! = 1 / rau0
59
60   TYPE(FLD), PUBLIC, ALLOCATABLE, DIMENSION(:) ::   sf_rnf       ! structure: river runoff (file information, fields read) (PUBLIC for TAM)
61   TYPE(FLD), PUBLIC, ALLOCATABLE, DIMENSION(:) ::   sf_s_rnf     ! structure: river runoff salinity (file information, fields read)  (PUBLIC for TAM)
62   TYPE(FLD), PUBLIC, ALLOCATABLE, DIMENSION(:) ::   sf_t_rnf     ! structure: river runoff temperature (file information, fields read) (PUBLIC for TAM)
63
64   !! * Substitutions
65#  include "domzgr_substitute.h90"
66   !!----------------------------------------------------------------------
67   !! NEMO/OPA 3.3 , NEMO Consortium (2010)
68   !! $Id$
69   !! Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
70   !!----------------------------------------------------------------------
71CONTAINS
72
73   INTEGER FUNCTION sbc_rnf_alloc()
74      !!----------------------------------------------------------------------
75      !!                ***  ROUTINE sbc_rnf_alloc  ***
76      !!----------------------------------------------------------------------
77      ALLOCATE( rnfmsk(jpi,jpj)         , rnfmsk_z(jpk)          ,     &
78         &      h_rnf (jpi,jpj)         , nk_rnf  (jpi,jpj)      ,     &
79         &      rnf_tsc_b(jpi,jpj,jpts) , rnf_tsc (jpi,jpj,jpts) , STAT=sbc_rnf_alloc )
80         !
81      IF( lk_mpp            )   CALL mpp_sum ( sbc_rnf_alloc )
82      IF( sbc_rnf_alloc > 0 )   CALL ctl_warn('sbc_rnf_alloc: allocation of arrays failed')
83   END FUNCTION sbc_rnf_alloc
84
85   SUBROUTINE sbc_rnf( kt )
86      !!----------------------------------------------------------------------
87      !!                  ***  ROUTINE sbc_rnf  ***
88      !!
89      !! ** Purpose :   Introduce a climatological run off forcing
90      !!
91      !! ** Method  :   Set each river mouth with a monthly climatology
92      !!                provided from different data.
93      !!                CAUTION : upward water flux, runoff forced to be < 0
94      !!
95      !! ** Action  :   runoff updated runoff field at time-step kt
96      !!----------------------------------------------------------------------
97      INTEGER, INTENT(in) ::   kt          ! ocean time step
98      !!
99      INTEGER  ::   ji, jj   ! dummy loop indices
100      !!----------------------------------------------------------------------
101      !
102      IF( kt == nit000 )   CALL sbc_rnf_init                           ! Read namelist and allocate structures
103
104      !                                            ! ---------------------------------------- !
105      IF( kt /= nit000 ) THEN                      !          Swap of forcing fields          !
106         !                                         ! ---------------------------------------- !
107         rnf_b    (:,:  ) = rnf    (:,:  )               ! Swap the ocean forcing fields except at nit000
108         rnf_tsc_b(:,:,:) = rnf_tsc(:,:,:)               ! where before fields are set at the end of the routine
109         !
110      ENDIF
111
112      !                                                   !-------------------!
113      IF( .NOT. ln_rnf_emp ) THEN                         !   Update runoff   !
114         !                                                !-------------------!
115         !
116                             CALL fld_read ( kt, nn_fsbc, sf_rnf   )    ! Read Runoffs data and provide it at kt
117         IF( ln_rnf_tem  )   CALL fld_read ( kt, nn_fsbc, sf_t_rnf )    ! idem for runoffs temperature if required
118         IF( ln_rnf_sal  )   CALL fld_read ( kt, nn_fsbc, sf_s_rnf )    ! idem for runoffs salinity    if required
119         !
120         ! Runoff reduction only associated to the ORCA2_LIM configuration
121         ! when reading the NetCDF file runoff_1m_nomask.nc
122         IF( cp_cfg == 'orca' .AND. jp_cfg == 2 )   THEN
123            WHERE( 40._wp < gphit(:,:) .AND. gphit(:,:) < 65._wp )
124               sf_rnf(1)%fnow(:,:,1) = 0.85 * sf_rnf(1)%fnow(:,:,1)
125            END WHERE
126         ENDIF
127         !
128         IF( MOD( kt - 1, nn_fsbc ) == 0 ) THEN
129            rnf(:,:) = rn_rfact * ( sf_rnf(1)%fnow(:,:,1) )
130            !
131            r1_rau0 = 1._wp / rau0
132            !                                                     ! set temperature & salinity content of runoffs
133            IF( ln_rnf_tem ) THEN                                       ! use runoffs temperature data
134               rnf_tsc(:,:,jp_tem) = ( sf_t_rnf(1)%fnow(:,:,1) ) * rnf(:,:) * r1_rau0
135               WHERE( sf_t_rnf(1)%fnow(:,:,1) == -999 )                 ! if missing data value use SST as runoffs temperature
136                   rnf_tsc(:,:,jp_tem) = sst_m(:,:) * rnf(:,:) * r1_rau0
137               END WHERE
138            ELSE                                                        ! use SST as runoffs temperature
139               rnf_tsc(:,:,jp_tem) = sst_m(:,:) * rnf(:,:) * r1_rau0
140            ENDIF
141            !                                                           ! use runoffs salinity data
142            IF( ln_rnf_sal )   rnf_tsc(:,:,jp_sal) = ( sf_s_rnf(1)%fnow(:,:,1) ) * rnf(:,:) * r1_rau0
143            !                                                           ! else use S=0 for runoffs (done one for all in the init)
144            !
145            IF( ln_rnf_tem .OR. ln_rnf_sal ) THEN                 ! runoffs as outflow: use ocean SST and SSS
146               WHERE( rnf(:,:) < 0._wp )                                 ! example baltic model when flow is out of domain
147                  rnf_tsc(:,:,jp_tem) = sst_m(:,:) * rnf(:,:) * r1_rau0
148                  rnf_tsc(:,:,jp_sal) = sss_m(:,:) * rnf(:,:) * r1_rau0
149               END WHERE
150            ENDIF
151            !
152            CALL iom_put( "runoffs", rnf )         ! output runoffs arrays
153         ENDIF
154         !
155      ENDIF
156      !
157      IF( kt == nit000 ) THEN                          !   set the forcing field at nit000 - 1    !
158         !                                             ! ---------------------------------------- !
159         IF( ln_rstart .AND.    &                               !* Restart: read in restart file
160            & iom_varid( numror, 'rnf_b', ldstop = .FALSE. ) > 0 ) THEN
161            IF(lwp) WRITE(numout,*) '          nit000-1 runoff forcing fields red in the restart file'
162            CALL iom_get( numror, jpdom_autoglo, 'rnf_b', rnf_b )     ! before runoff
163            CALL iom_get( numror, jpdom_autoglo, 'rnf_hc_b', rnf_tsc_b(:,:,jp_tem) )   ! before heat content of runoff
164            CALL iom_get( numror, jpdom_autoglo, 'rnf_sc_b', rnf_tsc_b(:,:,jp_sal) )   ! before salinity content of runoff
165         ELSE                                                   !* no restart: set from nit000 values
166            IF(lwp) WRITE(numout,*) '          nit000-1 runoff forcing fields set to nit000'
167             rnf_b    (:,:  ) = rnf    (:,:  )
168             rnf_tsc_b(:,:,:) = rnf_tsc(:,:,:)
169         ENDIF
170      ENDIF
171      !                                                ! ---------------------------------------- !
172      IF( lrst_oce ) THEN                              !      Write in the ocean restart file     !
173         !                                             ! ---------------------------------------- !
174         IF(lwp) WRITE(numout,*)
175         IF(lwp) WRITE(numout,*) 'sbcrnf : runoff forcing fields written in ocean restart file ',   &
176            &                    'at it= ', kt,' date= ', ndastp
177         IF(lwp) WRITE(numout,*) '~~~~'
178         CALL iom_rstput( kt, nitrst, numrow, 'rnf_b' , rnf )
179         CALL iom_rstput( kt, nitrst, numrow, 'rnf_hc_b', rnf_tsc(:,:,jp_tem) )
180         CALL iom_rstput( kt, nitrst, numrow, 'rnf_sc_b', rnf_tsc(:,:,jp_sal) )
181      ENDIF
182      !
183   END SUBROUTINE sbc_rnf
184
185
186   SUBROUTINE sbc_rnf_div( phdivn )
187      !!----------------------------------------------------------------------
188      !!                  ***  ROUTINE sbc_rnf  ***
189      !!
190      !! ** Purpose :   update the horizontal divergence with the runoff inflow
191      !!
192      !! ** Method  :
193      !!                CAUTION : rnf is positive (inflow) decreasing the
194      !!                          divergence and expressed in m/s
195      !!
196      !! ** Action  :   phdivn   decreased by the runoff inflow
197      !!----------------------------------------------------------------------
198      REAL(wp), DIMENSION(:,:,:), INTENT(inout) ::   phdivn   ! horizontal divergence
199      !!
200      INTEGER  ::   ji, jj, jk   ! dummy loop indices
201      REAL(wp) ::   r1_rau0   ! local scalar
202      REAL(wp) ::   zfact     ! local scalar
203      !!----------------------------------------------------------------------
204      !
205      zfact = 0.5_wp
206      !
207      r1_rau0 = 1._wp / rau0
208      IF( ln_rnf_depth ) THEN      !==   runoff distributed over several levels   ==!
209         IF( lk_vvl ) THEN             ! variable volume case
210            DO jj = 1, jpj                   ! update the depth over which runoffs are distributed
211               DO ji = 1, jpi
212                  h_rnf(ji,jj) = 0._wp
213                  DO jk = 1, nk_rnf(ji,jj)                           ! recalculates h_rnf to be the depth in metres
214                     h_rnf(ji,jj) = h_rnf(ji,jj) + fse3t(ji,jj,jk)   ! to the bottom of the relevant grid box
215                  END DO
216                  !                          ! apply the runoff input flow
217                  DO jk = 1, nk_rnf(ji,jj)
218                     phdivn(ji,jj,jk) = phdivn(ji,jj,jk) - ( rnf(ji,jj) + rnf_b(ji,jj) ) * zfact * r1_rau0 / h_rnf(ji,jj)
219                  END DO
220               END DO
221            END DO
222         ELSE                          ! constant volume case : just apply the runoff input flow
223            DO jj = 1, jpj
224               DO ji = 1, jpi
225                  DO jk = 1, nk_rnf(ji,jj)
226                     phdivn(ji,jj,jk) = phdivn(ji,jj,jk) - ( rnf(ji,jj) + rnf_b(ji,jj) ) * zfact * r1_rau0 / h_rnf(ji,jj)
227                  END DO
228               END DO
229            END DO
230         ENDIF
231      ELSE                       !==   runoff put only at the surface   ==!
232         IF( lk_vvl ) THEN              ! variable volume case
233            h_rnf(:,:) = fse3t(:,:,1)   ! recalculate h_rnf to be depth of top box
234         ENDIF
235         phdivn(:,:,1) = phdivn(:,:,1) - ( rnf(:,:) + rnf_b(:,:) ) * zfact * r1_rau0 / fse3t(:,:,1)
236      ENDIF
237      !
238   END SUBROUTINE sbc_rnf_div
239
240
241   SUBROUTINE sbc_rnf_init
242      !!----------------------------------------------------------------------
243      !!                  ***  ROUTINE sbc_rnf_init  ***
244      !!
245      !! ** Purpose :   Initialisation of the runoffs if (ln_rnf=T)
246      !!
247      !! ** Method  : - read the runoff namsbc_rnf namelist
248      !!
249      !! ** Action  : - read parameters
250      !!----------------------------------------------------------------------
251      CHARACTER(len=32) ::   rn_dep_file   ! runoff file name
252      INTEGER           ::   ji, jj, jk    ! dummy loop indices
253      INTEGER           ::   ierror, inum  ! temporary integer
254      !!
255      NAMELIST/namsbc_rnf/ cn_dir, ln_rnf_emp, ln_rnf_depth, ln_rnf_tem, ln_rnf_sal,   &
256         &                 sn_rnf, sn_cnf    , sn_s_rnf    , sn_t_rnf  , sn_dep_rnf,   &
257         &                 ln_rnf_mouth      , rn_hrnf     , rn_avt_rnf, rn_rfact
258      !!----------------------------------------------------------------------
259
260      !                                   ! ============
261      !                                   !   Namelist
262      !                                   ! ============
263      ! (NB: frequency positive => hours, negative => months)
264      !            !   file    ! frequency !  variable  ! time intep !  clim  ! 'yearly' or ! weights  ! rotation   !
265      !            !   name    !  (hours)  !   name     !   (T/F)    !  (T/F) !  'monthly'  ! filename ! pairs      !
266      sn_rnf = FLD_N( 'runoffs',    -1     , 'sorunoff' ,  .TRUE.    , .true. ,   'yearly'  , ''       , ''         )
267      sn_cnf = FLD_N( 'runoffs',     0     , 'sorunoff' ,  .FALSE.   , .true. ,   'yearly'  , ''       , ''         )
268
269      sn_s_rnf = FLD_N( 'runoffs',  24.  , 'rosaline' ,  .TRUE.    , .true. ,   'yearly'  , ''    , ''  )
270      sn_t_rnf = FLD_N( 'runoffs',  24.  , 'rotemper' ,  .TRUE.    , .true. ,   'yearly'  , ''    , ''  )
271      sn_dep_rnf = FLD_N( 'runoffs',   0.  , 'rodepth'  ,  .FALSE.   , .true. ,   'yearly'  , ''    , ''  )
272      !
273      REWIND ( numnam )                         ! Read Namelist namsbc_rnf
274      READ   ( numnam, namsbc_rnf )
275
276      !                                         ! Control print
277      IF(lwp) THEN
278         WRITE(numout,*)
279         WRITE(numout,*) 'sbc_rnf : runoff '
280         WRITE(numout,*) '~~~~~~~ '
281         WRITE(numout,*) '   Namelist namsbc_rnf'
282         WRITE(numout,*) '      runoff in a file to be read                ln_rnf_emp   = ', ln_rnf_emp
283         WRITE(numout,*) '      specific river mouths treatment            ln_rnf_mouth = ', ln_rnf_mouth
284         WRITE(numout,*) '      river mouth additional Kz                  rn_avt_rnf   = ', rn_avt_rnf
285         WRITE(numout,*) '      depth of river mouth additional mixing     rn_hrnf      = ', rn_hrnf
286         WRITE(numout,*) '      multiplicative factor for runoff           rn_rfact     = ', rn_rfact
287      ENDIF
288
289      !                                   ! ==================
290      !                                   !   Type of runoff
291      !                                   ! ==================
292      !                                         !==  allocate runoff arrays
293      IF( sbc_rnf_alloc() /= 0 )   CALL ctl_stop( 'STOP', 'sbc_rnf_alloc : unable to allocate arrays' )
294      !
295      IF( ln_rnf_emp ) THEN                     !==  runoffs directly provided in the precipitations  ==!
296         IF(lwp) WRITE(numout,*)
297         IF(lwp) WRITE(numout,*) '          runoffs directly provided in the precipitations'
298         IF( ln_rnf_depth .OR. ln_rnf_tem .OR. ln_rnf_sal ) THEN
299           CALL ctl_warn( 'runoffs already included in precipitations, so runoff (T,S, depth) attributes will not be used' )
300           ln_rnf_depth = .FALSE.   ;   ln_rnf_tem = .FALSE.   ;   ln_rnf_sal = .FALSE.
301         ENDIF
302         !
303      ELSE                                      !==  runoffs read in a file : set sf_rnf structure  ==!
304         !
305         ALLOCATE( sf_rnf(1), STAT=ierror )         ! Create sf_rnf structure (runoff inflow)
306         IF(lwp) WRITE(numout,*)
307         IF(lwp) WRITE(numout,*) '          runoffs inflow read in a file'
308         IF( ierror > 0 ) THEN
309            CALL ctl_stop( 'sbc_rnf: unable to allocate sf_rnf structure' )   ;   RETURN
310         ENDIF
311         ALLOCATE( sf_rnf(1)%fnow(jpi,jpj,1)   )
312         IF( sn_rnf%ln_tint ) ALLOCATE( sf_rnf(1)%fdta(jpi,jpj,1,2) )
313         !                                          ! fill sf_rnf with the namelist (sn_rnf) and control print
314         CALL fld_fill( sf_rnf, (/ sn_rnf /), cn_dir, 'sbc_rnf_init', 'read runoffs data', 'namsbc_rnf' )
315         !
316         IF( ln_rnf_tem ) THEN                      ! Create (if required) sf_t_rnf structure
317            IF(lwp) WRITE(numout,*)
318            IF(lwp) WRITE(numout,*) '          runoffs temperatures read in a file'
319            ALLOCATE( sf_t_rnf(1), STAT=ierror  )
320            IF( ierror > 0 ) THEN
321               CALL ctl_stop( 'sbc_rnf_init: unable to allocate sf_t_rnf structure' )   ;   RETURN
322            ENDIF
323            ALLOCATE( sf_t_rnf(1)%fnow(jpi,jpj,1)   )
324            IF( sn_t_rnf%ln_tint ) ALLOCATE( sf_t_rnf(1)%fdta(jpi,jpj,1,2) )
325            CALL fld_fill (sf_t_rnf, (/ sn_t_rnf /), cn_dir, 'sbc_rnf_init', 'read runoff temperature data', 'namsbc_rnf' )
326         ENDIF
327         !
328         IF( ln_rnf_sal  ) THEN                     ! Create (if required) sf_s_rnf and sf_t_rnf structures
329            IF(lwp) WRITE(numout,*)
330            IF(lwp) WRITE(numout,*) '          runoffs salinities read in a file'
331            ALLOCATE( sf_s_rnf(1), STAT=ierror  )
332            IF( ierror > 0 ) THEN
333               CALL ctl_stop( 'sbc_rnf_init: unable to allocate sf_s_rnf structure' )   ;   RETURN
334            ENDIF
335            ALLOCATE( sf_s_rnf(1)%fnow(jpi,jpj,1)   )
336            IF( sn_s_rnf%ln_tint ) ALLOCATE( sf_s_rnf(1)%fdta(jpi,jpj,1,2) )
337            CALL fld_fill (sf_s_rnf, (/ sn_s_rnf /), cn_dir, 'sbc_rnf_init', 'read runoff salinity data', 'namsbc_rnf' )
338         ENDIF
339         !
340         IF( ln_rnf_depth ) THEN                    ! depth of runoffs set from a file
341            IF(lwp) WRITE(numout,*)
342            IF(lwp) WRITE(numout,*) '          runoffs depth read in a file'
343            rn_dep_file = TRIM( cn_dir )//TRIM( sn_dep_rnf%clname )
344            CALL iom_open ( rn_dep_file, inum )                           ! open file
345            CALL iom_get  ( inum, jpdom_data, sn_dep_rnf%clvar, h_rnf )   ! read the river mouth array
346            CALL iom_close( inum )                                        ! close file
347            !
348            nk_rnf(:,:) = 0                               ! set the number of level over which river runoffs are applied
349            DO jj = 1, jpj
350               DO ji = 1, jpi
351                  IF( h_rnf(ji,jj) > 0._wp ) THEN
352                     jk = 2
353                     DO WHILE ( jk /= mbkt(ji,jj) .AND. fsdept(ji,jj,jk) < h_rnf(ji,jj) ) ;  jk = jk + 1 ;  END DO
354                     nk_rnf(ji,jj) = jk
355                  ELSEIF( h_rnf(ji,jj) == -1   ) THEN   ;  nk_rnf(ji,jj) = 1
356                  ELSEIF( h_rnf(ji,jj) == -999 ) THEN   ;  nk_rnf(ji,jj) = mbkt(ji,jj)
357                  ELSEIF( h_rnf(ji,jj) /=  0   ) THEN
358                     CALL ctl_stop( 'runoff depth not positive, and not -999 or -1, rnf value in file fort.999'  )
359                     WRITE(999,*) 'ji, jj, rnf(ji,jj) :', ji, jj, rnf(ji,jj)
360                  ENDIF
361               END DO
362            END DO
363            DO jj = 1, jpj                                ! set the associated depth
364               DO ji = 1, jpi
365                  h_rnf(ji,jj) = 0._wp
366                  DO jk = 1, nk_rnf(ji,jj)
367                     h_rnf(ji,jj) = h_rnf(ji,jj) + fse3t(ji,jj,jk)
368                  END DO
369               END DO
370            END DO
371         ELSE                                       ! runoffs applied at the surface
372            nk_rnf(:,:) = 1
373            h_rnf (:,:) = fse3t(:,:,1)
374         ENDIF
375         !
376      ENDIF
377      !
378      rnf(:,:) =  0._wp                         ! runoff initialisation
379      rnf_tsc(:,:,:) = 0._wp                    ! runoffs temperature & salinty contents initilisation
380      !
381      !                                   ! ========================
382      !                                   !   River mouth vicinity
383      !                                   ! ========================
384      !
385      IF( ln_rnf_mouth ) THEN                   ! Specific treatment in vicinity of river mouths :
386         !                                      !    - Increase Kz in surface layers ( rn_hrnf > 0 )
387         !                                      !    - set to zero SSS damping (ln_ssr=T)
388         !                                      !    - mixed upstream-centered (ln_traadv_cen2=T)
389         !
390         IF ( ln_rnf_depth )   CALL ctl_warn( 'sbc_rnf_init: increased mixing turned on but effects may already',   &
391            &                                              'be spread through depth by ln_rnf_depth'               )
392         !
393         nkrnf = 0                                  ! Number of level over which Kz increase
394         IF( rn_hrnf > 0._wp ) THEN
395            nkrnf = 2
396            DO WHILE( nkrnf /= jpkm1 .AND. gdepw_0(nkrnf+1) < rn_hrnf )   ;   nkrnf = nkrnf + 1   ;   END DO
397            IF( ln_sco )   &
398               CALL ctl_warn( 'sbc_rnf: number of levels over which Kz is increased is computed for zco...' )
399         ENDIF
400         IF(lwp) WRITE(numout,*)
401         IF(lwp) WRITE(numout,*) '          Specific treatment used in vicinity of river mouths :'
402         IF(lwp) WRITE(numout,*) '             - Increase Kz in surface layers (if rn_hrnf > 0 )'
403         IF(lwp) WRITE(numout,*) '               by ', rn_avt_rnf,' m2/s  over ', nkrnf, ' w-levels'
404         IF(lwp) WRITE(numout,*) '             - set to zero SSS damping       (if ln_ssr=T)'
405         IF(lwp) WRITE(numout,*) '             - mixed upstream-centered       (if ln_traadv_cen2=T)'
406         !
407         CALL rnf_mouth                             ! set river mouth mask
408         !
409      ELSE                                      ! No treatment at river mouths
410         IF(lwp) WRITE(numout,*)
411         IF(lwp) WRITE(numout,*) '          No specific treatment at river mouths'
412         rnfmsk  (:,:) = 0._wp
413         rnfmsk_z(:)   = 0._wp
414         nkrnf = 0
415      ENDIF
416
417   END SUBROUTINE sbc_rnf_init
418
419
420   SUBROUTINE rnf_mouth
421      !!----------------------------------------------------------------------
422      !!                  ***  ROUTINE rnf_mouth  ***
423      !!
424      !! ** Purpose :   define the river mouths mask
425      !!
426      !! ** Method  :   read the river mouth mask (=0/1) in the river runoff
427      !!                climatological file. Defined a given vertical structure.
428      !!                CAUTION, the vertical structure is hard coded on the
429      !!                first 5 levels.
430      !!                This fields can be used to:
431      !!                 - set an upstream advection scheme
432      !!                   (ln_rnf_mouth=T and ln_traadv_cen2=T)
433      !!                 - increase vertical on the top nn_krnf vertical levels
434      !!                   at river runoff input grid point (nn_krnf>=2, see step.F90)
435      !!                 - set to zero SSS restoring flux at river mouth grid points
436      !!
437      !! ** Action  :   rnfmsk   set to 1 at river runoff input, 0 elsewhere
438      !!                rnfmsk_z vertical structure
439      !!----------------------------------------------------------------------
440      !
441      INTEGER            ::   inum        ! temporary integers
442      CHARACTER(len=140) ::   cl_rnfile   ! runoff file name
443      !!----------------------------------------------------------------------
444      !
445      IF(lwp) WRITE(numout,*)
446      IF(lwp) WRITE(numout,*) 'rnf_mouth : river mouth mask'
447      IF(lwp) WRITE(numout,*) '~~~~~~~~~ '
448
449      cl_rnfile = TRIM( cn_dir )//TRIM( sn_cnf%clname )
450      IF( .NOT. sn_cnf%ln_clim ) THEN   ;   WRITE(cl_rnfile, '(a,"_y",i4)' ) TRIM( cl_rnfile ), nyear    ! add year
451         IF( sn_cnf%cltype == 'monthly' )   WRITE(cl_rnfile, '(a,"m",i2)'  ) TRIM( cl_rnfile ), nmonth   ! add month
452      ENDIF
453
454      ! horizontal mask (read in NetCDF file)
455      CALL iom_open ( cl_rnfile, inum )                           ! open file
456      CALL iom_get  ( inum, jpdom_data, sn_cnf%clvar, rnfmsk )    ! read the river mouth array
457      CALL iom_close( inum )                                      ! close file
458
459      IF( nn_closea == 1 )   CALL clo_rnf( rnfmsk )               ! closed sea inflow set as ruver mouth
460
461      rnfmsk_z(:)   = 0._wp                                       ! vertical structure
462      rnfmsk_z(1)   = 1.0
463      rnfmsk_z(2)   = 1.0                                         ! **********
464      rnfmsk_z(3)   = 0.5                                         ! HARD CODED on the 5 first levels
465      rnfmsk_z(4)   = 0.25                                        ! **********
466      rnfmsk_z(5)   = 0.125
467      !
468   END SUBROUTINE rnf_mouth
469
470   !!======================================================================
471END MODULE sbcrnf
Note: See TracBrowser for help on using the repository browser.