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.
sbcrnf_tam.F90 in branches/2012/dev_r3604_LEGI8_TAM/NEMOGCM/NEMO/OPATAM_SRC/SBC – NEMO

source: branches/2012/dev_r3604_LEGI8_TAM/NEMOGCM/NEMO/OPATAM_SRC/SBC/sbcrnf_tam.F90 @ 3627

Last change on this file since 3627 was 3627, checked in by rblod, 10 years ago

Correct long lines in TAM 4.3 see ticket #1010

  • Property svn:executable set to *
File size: 23.0 KB
Line 
1MODULE sbcrnf_tam
2#if defined key_tam
3   !!======================================================================
4   !!                       ***  MODULE  sbcrnf_tam  ***
5   !! Ocean forcing:  river runoff
6   !!=====================================================================
7   !! History :  OPA  ! 2000-11  (R. Hordoir, E. Durand)  NetCDF FORMAT
8   !!   NEMO     1.0  ! 2002-09  (G. Madec)  F90: Free form and module
9   !!            3.0  ! 2006-07  (G. Madec)  Surface module
10   !!            3.2  ! 2009-04  (B. Lemaire)  Introduce iom_put
11   !!            3.3  ! 2010-10  (R. Furner, G. Madec) runoff distributed over ocean levels
12   !!----------------------------------------------------------------------
13
14   !!----------------------------------------------------------------------
15   !!   sbc_rnf      : monthly runoffs read in a NetCDF file
16   !!   sbc_rnf_init : runoffs initialisation
17   !!   rnf_mouth    : set river mouth mask
18   !!----------------------------------------------------------------------
19   USE dom_oce         ! ocean space and time domain
20   USE phycst          ! physical constants
21   USE sbc_oce         ! surface boundary condition variables
22   USE sbc_oce_tam         ! surface boundary condition variables
23   USE closea          ! closed seas
24   USE fldread         ! read input field at current time step
25   USE restart         ! restart
26   USE in_out_manager  ! I/O manager
27   USE iom             ! I/O module
28   USE lib_mpp         ! MPP library
29   USE sbcrnf
30
31   IMPLICIT NONE
32   PRIVATE
33
34   PUBLIC   sbc_rnf_tan       ! routine call in sbcmod module
35   PUBLIC   sbc_rnf_div_tan   ! routine called in sshwzv module
36   PUBLIC   sbc_rnf_adj       ! routine call in sbcmod module
37   PUBLIC   sbc_rnf_div_adj   ! routine called in sshwzv module
38   PUBLIC   sbc_rnf_alloc_tam ! routine call in sbcmod module
39   PUBLIC   sbc_rnf_init_tam
40
41   !                                                     !!* namsbc_rnf namelist *
42
43   REAL(wp), PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:,:,:) ::   rnf_tsc_b_tl, rnf_tsc_tl  !: before and now T & S runoff contents   [K.m/s & PSU.m/s]
44   REAL(wp), PUBLIC, ALLOCATABLE, SAVE, DIMENSION(:,:,:) ::   rnf_tsc_b_ad, rnf_tsc_ad  !: before and now T & S runoff contents   [K.m/s & PSU.m/s
45
46   LOGICAL, PRIVATE, SAVE :: ll_alloctl = .FALSE.
47   LOGICAL, PRIVATE, SAVE :: ll_allocad = .FALSE.
48   REAL(wp) ::   r1_rau0   ! = 1 / rau0
49
50   !! * Substitutions
51#  include "domzgr_substitute.h90"
52   !!----------------------------------------------------------------------
53   !! NEMO/OPA 3.3 , NEMO Consortium (2010)
54   !! $Id$
55   !! Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
56   !!----------------------------------------------------------------------
57CONTAINS
58
59   INTEGER FUNCTION sbc_rnf_alloc_tam( kmode )
60      INTEGER, OPTIONAL :: kmode
61      !!----------------------------------------------------------------------
62      !!                ***  ROUTINE sbc_rnf_alloc  ***
63      !!----------------------------------------------------------------------
64      INTEGER :: jmode
65      INTEGER, DIMENSION(2) :: ierr
66
67      IF ( PRESENT( kmode ) ) THEN
68         jmode = kmode
69      ELSE
70         jmode = 0
71      END IF
72
73
74      IF ( ( jmode == 0 ) .OR. ( jmode == 1 ) .AND. ( .NOT. ll_alloctl ) ) THEN
75         ALLOCATE(  rnf_tsc_b_tl(jpi,jpj,jpts) , rnf_tsc_tl (jpi,jpj,jpts), STAT = ierr(1) )
76         ll_alloctl = .TRUE.
77      END IF
78      IF ( ( jmode == 0 ) .OR. ( jmode == 2 ) .AND. ( .NOT. ll_allocad ) ) THEN
79         ALLOCATE(  rnf_tsc_b_ad(jpi,jpj,jpts) , rnf_tsc_ad (jpi,jpj,jpts) , STAT=ierr(2) )
80         ll_allocad = .TRUE.
81      END IF
82      sbc_rnf_alloc_tam = SUM( ierr )
83         !
84      IF( lk_mpp            )   CALL mpp_sum ( sbc_rnf_alloc_tam )
85      IF( sbc_rnf_alloc_tam > 0 )   CALL ctl_warn('sbc_rnf_alloc: allocation of arrays failed')
86   END FUNCTION sbc_rnf_alloc_tam
87
88   INTEGER FUNCTION sbc_rnf_dealloc_tam( kmode )
89      INTEGER, OPTIONAL :: kmode
90      !!----------------------------------------------------------------------
91      !!                ***  ROUTINE sbc_rnf_alloc  ***
92      !!----------------------------------------------------------------------
93      INTEGER :: jmode
94      INTEGER, DIMENSION(2) :: ierr
95
96      IF ( PRESENT( kmode ) ) THEN
97         jmode = kmode
98      ELSE
99         jmode = 0
100      END IF
101
102
103      IF ( ( jmode == 0 ) .OR. ( jmode == 1 ) .AND. ( ll_alloctl ) ) THEN
104         DEALLOCATE(  rnf_tsc_b_tl, rnf_tsc_tl, STAT = ierr(1) )
105         ll_alloctl = .FALSE.
106      END IF
107      IF ( ( jmode == 0 ) .OR. ( jmode == 2 ) .AND. ( ll_allocad ) ) THEN
108         DEALLOCATE(  rnf_tsc_b_ad, rnf_tsc_ad, STAT=ierr(2) )
109         ll_allocad = .FALSE.
110      END IF
111      sbc_rnf_dealloc_tam = SUM( ierr )
112         !
113      IF( lk_mpp            )   CALL mpp_sum ( sbc_rnf_dealloc_tam )
114      IF( sbc_rnf_dealloc_tam > 0 )   CALL ctl_warn('sbc_rnf_dealloc: deallocation of arrays failed')
115   END FUNCTION sbc_rnf_dealloc_tam
116
117   SUBROUTINE sbc_rnf_tan( kt )
118      !!----------------------------------------------------------------------
119      !!                  ***  ROUTINE sbc_rnf_tan  ***
120      !!
121      !! ** Purpose :   Introduce a climatological run off forcing
122      !!
123      !! ** Method  :   Set each river mouth with a monthly climatology
124      !!                provided from different data.
125      !!                CAUTION : upward water flux, runoff forced to be < 0
126      !!
127      !! ** Action  :   runoff updated runoff field at time-step kt
128      !!----------------------------------------------------------------------
129      INTEGER, INTENT(in) ::   kt          ! ocean time step
130      !!
131      INTEGER  ::   ji, jj   ! dummy loop indices
132      !!----------------------------------------------------------------------
133      !
134      !                                            ! ---------------------------------------- !
135      IF( kt /= nit000 ) THEN                      !          Swap of forcing fields          !
136         !                                         ! ---------------------------------------- !
137         rnf_b_tl    (:,:  ) = rnf_tl    (:,:  )               ! Swap the ocean forcing fields except at nit000
138         rnf_tsc_b_tl(:,:,:) = rnf_tsc_tl(:,:,:)               ! where before fields are set at the end of the routine
139         !
140      ENDIF
141
142      !                                                   !-------------------!
143      IF( .NOT. ln_rnf_emp ) THEN                         !   Update runoff   !
144         !                                                !-------------------!
145         !
146                             CALL fld_read ( kt, nn_fsbc, sf_rnf   )    ! Read Runoffs data and provide it at kt
147         IF( ln_rnf_tem  )   CALL fld_read ( kt, nn_fsbc, sf_t_rnf )    ! idem for runoffs temperature if required
148         IF( ln_rnf_sal  )   CALL fld_read ( kt, nn_fsbc, sf_s_rnf )    ! idem for runoffs salinity    if required
149         !
150         ! Runoff reduction only associated to the ORCA2_LIM configuration
151         ! when reading the NetCDF file runoff_1m_nomask.nc
152         IF( cp_cfg == 'orca' .AND. jp_cfg == 2 )   THEN
153            WHERE( 40._wp < gphit(:,:) .AND. gphit(:,:) < 65._wp )
154               sf_rnf(1)%fnow(:,:,1) = 0.85 * sf_rnf(1)%fnow(:,:,1)
155            END WHERE
156         ENDIF
157         !
158         IF( MOD( kt - 1, nn_fsbc ) == 0 ) THEN
159            rnf_tl(:,:) = 0.0_wp
160            !
161            r1_rau0 = 1._wp / rau0
162            !                                                     ! set temperature & salinity content of runoffs
163            IF( ln_rnf_tem ) THEN                                       ! use runoffs temperature data
164               rnf_tsc_tl(:,:,jp_tem) = ( sf_t_rnf(1)%fnow(:,:,1) ) * rnf_tl(:,:) * r1_rau0
165               WHERE( sf_t_rnf(1)%fnow(:,:,1) == -999 )                 ! if missing data value use SST as runoffs temperature
166               rnf_tsc_tl(:,:,jp_tem) = (sst_m_tl(:,:) * rnf(:,:) &
167                  &                      + sst_m(:,:) * rnf_tl(:,:)) * r1_rau0
168               END WHERE
169            ELSE                                                        ! use SST as runoffs temperature
170               rnf_tsc_tl(:,:,jp_tem) = (sst_m_tl(:,:) * rnf(:,:) &
171                  &                      + sst_m(:,:) * rnf_tl(:,:)) * r1_rau0
172            ENDIF
173            !                                                           ! use runoffs salinity data
174            IF( ln_rnf_sal )   rnf_tsc_tl(:,:,jp_sal) = ( sf_s_rnf(1)%fnow(:,:,1) ) * rnf_tl(:,:) * r1_rau0
175            !                                                           ! else use S=0 for runoffs (done one for all in the init)
176            !
177            IF( ln_rnf_tem .OR. ln_rnf_sal ) THEN                 ! runoffs as outflow: use ocean SST and SSS
178               WHERE( rnf(:,:) < 0._wp )                                 ! example baltic model when flow is out of domain
179               rnf_tsc_tl(:,:,jp_tem) = (sst_m_tl(:,:) * rnf(:,:) &
180                  &                      + sst_m(:,:) * rnf_tl(:,:)) * r1_rau0
181               rnf_tsc_tl(:,:,jp_sal) = (sss_m_tl(:,:) * rnf(:,:) &
182                  &                      + sss_m(:,:) * rnf_tl(:,:)) * r1_rau0
183               END WHERE
184            ENDIF
185            !
186         ENDIF
187         !
188      ENDIF
189      !
190      IF( kt == nit000 ) THEN                          !   set the forcing field at nit000 - 1    !
191         !                                             ! ---------------------------------------- !
192         IF( ln_rstart ) THEN
193            rnf_b_tl(:,:) = 0.0_wp
194            rnf_tsc_b_tl(:,:,:) = 0.0_wp
195         ELSE                                                   !* no restart: set from nit000 values
196            IF(lwp) WRITE(numout,*) '          nit000-1 runoff forcing fields set to nit000'
197             rnf_b_tl    (:,:  ) = rnf_tl    (:,:  )
198             rnf_tsc_b_tl(:,:,:) = rnf_tsc_tl(:,:,:)
199         ENDIF
200      ENDIF
201      !
202   END SUBROUTINE sbc_rnf_tan
203
204
205   SUBROUTINE sbc_rnf_div_tan( phdivn_tl )
206      !!----------------------------------------------------------------------
207      !!                  ***  ROUTINE sbc_rnf  ***
208      !!
209      !! ** Purpose :   update the horizontal divergence with the runoff inflow
210      !!
211      !! ** Method  :
212      !!                CAUTION : rnf is positive (inflow) decreasing the
213      !!                          divergence and expressed in m/s
214      !!
215      !! ** Action  :   phdivn   decreased by the runoff inflow
216      !!----------------------------------------------------------------------
217      REAL(wp), DIMENSION(:,:,:), INTENT(inout) ::   phdivn_tl   ! horizontal divergence
218      !!
219      INTEGER  ::   ji, jj, jk   ! dummy loop indices
220      REAL(wp) ::   r1_rau0   ! local scalar
221      REAL(wp) ::   zfact     ! local scalar
222      !!----------------------------------------------------------------------
223      !
224      zfact = 0.5_wp
225      !
226      r1_rau0 = 1._wp / rau0
227      IF( ln_rnf_depth ) THEN      !==   runoff distributed over several levels   ==!
228         IF( lk_vvl ) THEN             ! variable volume case
229            !DO jj = 1, jpj                   ! update the depth over which runoffs are distributed
230               !DO ji = 1, jpi
231                  !h_rnf(ji,jj) = 0._wp
232                  !DO jk = 1, nk_rnf(ji,jj)                           ! recalculates h_rnf to be the depth in metres
233                     !h_rnf(ji,jj) = h_rnf(ji,jj) + fse3t(ji,jj,jk)   ! to the bottom of the relevant grid box
234                  !END DO
235                  !!                          ! apply the runoff input flow
236                  !DO jk = 1, nk_rnf(ji,jj)
237                     !phdivn(ji,jj,jk) = phdivn(ji,jj,jk) - ( rnf(ji,jj) + rnf_b(ji,jj) ) * zfact * r1_rau0 / h_rnf(ji,jj)
238                  !END DO
239               !END DO
240            !END DO
241            CALL ctl_stop('key_vvl not implemented in TAM yet')
242         ELSE                          ! constant volume case : just apply the runoff input flow
243            DO jj = 1, jpj
244               DO ji = 1, jpi
245                  DO jk = 1, nk_rnf(ji,jj)
246                     phdivn_tl(ji,jj,jk) = phdivn_tl(ji,jj,jk) - ( rnf_tl(ji,jj) + rnf_b_tl(ji,jj) )   &
247                                         &                       * zfact * r1_rau0 / h_rnf(ji,jj)
248                  END DO
249               END DO
250            END DO
251         ENDIF
252      ELSE                       !==   runoff put only at the surface   ==!
253         IF( lk_vvl ) THEN              ! variable volume case
254            CALL ctl_stop('key_vvl not implemented in TAM yet')
255            !h_rnf(:,:) = fse3t(:,:,1)   ! recalculate h_rnf to be depth of top box
256         ENDIF
257         phdivn_tl(:,:,1) = phdivn_tl(:,:,1) - ( rnf_tl(:,:) + rnf_b_tl(:,:) ) * zfact * r1_rau0 / fse3t(:,:,1)
258      ENDIF
259      !
260   END SUBROUTINE sbc_rnf_div_tan
261
262   SUBROUTINE sbc_rnf_adj( kt )
263      !!----------------------------------------------------------------------
264      !!                  ***  ROUTINE sbc_rnf_adj  ***
265      !!
266      !! ** Purpose :   Introduce a climatological run off forcing
267      !!
268      !! ** Method  :   Set each river mouth with a monthly climatology
269      !!                provided from different data.
270      !!                CAUTION : upward water flux, runoff forced to be < 0
271      !!
272      !! ** Action  :   runoff updated runoff field at time-step kt
273      !!----------------------------------------------------------------------
274      INTEGER, INTENT(in) ::   kt          ! ocean time step
275      !!
276      INTEGER  ::   ji, jj   ! dummy loop indices
277      !!----------------------------------------------------------------------
278      !
279      IF( kt == nitend ) THEN                          !   set the forcing field at nit000 - 1    !
280         !                                             ! ---------------------------------------- !
281         IF( ln_rstart ) THEN
282            rnf_b_ad(:,:) = 0.0_wp
283            rnf_tsc_b_ad(:,:,:) = 0.0_wp
284         ELSE                                                   !* no restart: set from nit000 values
285            IF(lwp) WRITE(numout,*) '          nit000-1 runoff forcing fields set to nit000'
286             rnf_ad    (:,:  ) = rnf_ad    (:,:  )  + rnf_b_ad(:,:)
287             rnf_tsc_ad(:,:,:) = rnf_tsc_ad(:,:,:)  + rnf_tsc_b_ad(:,:,:)
288         ENDIF
289      ENDIF
290      !                                            ! ---------------------------------------- !
291      !                                                   !-------------------!
292      IF( .NOT. ln_rnf_emp ) THEN                         !   Update runoff   !
293         !                                                !-------------------!
294         !
295                             CALL fld_read ( kt, nn_fsbc, sf_rnf   )    ! Read Runoffs data and provide it at kt
296         IF( ln_rnf_tem  )   CALL fld_read ( kt, nn_fsbc, sf_t_rnf )    ! idem for runoffs temperature if required
297         IF( ln_rnf_sal  )   CALL fld_read ( kt, nn_fsbc, sf_s_rnf )    ! idem for runoffs salinity    if required
298         !
299         ! Runoff reduction only associated to the ORCA2_LIM configuration
300         ! when reading the NetCDF file runoff_1m_nomask.nc
301         IF( cp_cfg == 'orca' .AND. jp_cfg == 2 )   THEN
302            WHERE( 40._wp < gphit(:,:) .AND. gphit(:,:) < 65._wp )
303               sf_rnf(1)%fnow(:,:,1) = 0.85 * sf_rnf(1)%fnow(:,:,1)
304            END WHERE
305         ENDIF
306         !
307         IF( MOD( kt - 1, nn_fsbc ) == 0 ) THEN
308            rnf_ad(:,:) = 0.0_wp
309            !
310            r1_rau0 = 1._wp / rau0
311            !                                                     ! set temperature & salinity content of runoffs
312            !
313            IF( ln_rnf_tem .OR. ln_rnf_sal ) THEN                 ! runoffs as outflow: use ocean SST and SSS
314               WHERE( rnf(:,:) < 0._wp )                                 ! example baltic model when flow is out of domain
315                  sss_m_ad(:,:) = sst_m_ad(:,:) + r1_rau0 * (rnf(:,:) * rnf_tsc_ad(:,:,jp_sal))
316                  rnf_ad(:,:)   = rnf_ad(:,:)   + r1_rau0 * (sss_m(:,:) * rnf_tsc_ad(:,:,jp_sal))
317                  sst_m_ad(:,:) = sst_m_ad(:,:) + r1_rau0 * (rnf(:,:) * rnf_tsc_ad(:,:,jp_tem))
318                  rnf_ad(:,:)   = rnf_ad(:,:)   + r1_rau0 * (sst_m(:,:) * rnf_tsc_ad(:,:,jp_tem))
319               END WHERE
320            ENDIF
321            IF( ln_rnf_sal ) THEN
322               rnf_ad(:,:) = rnf_ad(:,:) + ( sf_s_rnf(1)%fnow(:,:,1) ) * rnf_tsc_ad(:,:,jp_sal) * r1_rau0
323            END IF
324            !                                                           ! else use S=0 for runoffs (done one for all in the init)
325            IF( ln_rnf_tem ) THEN                                       ! use runoffs temperature data
326               rnf_ad(:,:) = rnf_ad(:,:) + ( sf_s_rnf(1)%fnow(:,:,1) ) * rnf_tsc_ad(:,:,jp_tem) * r1_rau0
327               WHERE( sf_t_rnf(1)%fnow(:,:,1) == -999 )                 ! if missing data value use SST as runoffs temperature
328                  sst_m_ad(:,:) = sst_m_ad(:,:) + r1_rau0 * (rnf(:,:) * rnf_tsc_ad(:,:,jp_tem))
329                  rnf_ad(:,:)   = rnf_ad(:,:)   + r1_rau0 * (sst_m(:,:) * rnf_tsc_ad(:,:,jp_tem))
330               END WHERE
331            ELSE                                                        ! use SST as runoffs temperature
332               sst_m_ad(:,:) = sst_m_ad(:,:) + r1_rau0 * (rnf(:,:) * rnf_tsc_ad(:,:,jp_tem))
333               rnf_ad(:,:)   = rnf_ad(:,:)   + r1_rau0 * (sst_m(:,:) * rnf_tsc_ad(:,:,jp_tem))
334            ENDIF
335            !                                                           ! use runoffs salinity data
336            !
337         ENDIF
338         !
339      ENDIF
340      IF( kt /= nit000 ) THEN                      !          Swap of forcing fields          !
341         !                                         ! ---------------------------------------- !
342         rnf_ad    (:,:  ) = rnf_ad    (:,:  ) + rnf_b_ad(:,:)               ! Swap the ocean forcing fields except at nit000
343         rnf_tsc_ad(:,:,:) = rnf_tsc_ad(:,:,:) +rnf_tsc_b_ad(:,:,:)              ! where before fields are set at the end of the routine
344         !
345      ENDIF
346
347      !
348   END SUBROUTINE sbc_rnf_adj
349
350
351   SUBROUTINE sbc_rnf_div_adj( phdivn_ad )
352      !!----------------------------------------------------------------------
353      !!                  ***  ROUTINE sbc_rnf  ***
354      !!
355      !! ** Purpose :   update the horizontal divergence with the runoff inflow
356      !!
357      !! ** Method  :
358      !!                CAUTION : rnf is positive (inflow) decreasing the
359      !!                          divergence and expressed in m/s
360      !!
361      !! ** Action  :   phdivn   decreased by the runoff inflow
362      !!----------------------------------------------------------------------
363      REAL(wp), DIMENSION(:,:,:), INTENT(inout) ::   phdivn_ad   ! horizontal divergence
364      !!
365      INTEGER  ::   ji, jj, jk   ! dummy loop indices
366      REAL(wp) ::   r1_rau0   ! local scalar
367      REAL(wp) ::   zfact     ! local scalar
368      !!----------------------------------------------------------------------
369      !
370      zfact = 0.5_wp
371      !
372      r1_rau0 = 1._wp / rau0
373      IF( ln_rnf_depth ) THEN      !==   runoff distributed over several levels   ==!
374         IF( lk_vvl ) THEN             ! variable volume case
375            !DO jj = 1, jpj                   ! update the depth over which runoffs are distributed
376               !DO ji = 1, jpi
377                  !h_rnf(ji,jj) = 0._wp
378                  !DO jk = 1, nk_rnf(ji,jj)                           ! recalculates h_rnf to be the depth in metres
379                     !h_rnf(ji,jj) = h_rnf(ji,jj) + fse3t(ji,jj,jk)   ! to the bottom of the relevant grid box
380                  !END DO
381                  !!                          ! apply the runoff input flow
382                  !DO jk = 1, nk_rnf(ji,jj)
383                     !phdivn(ji,jj,jk) = phdivn(ji,jj,jk) - ( rnf(ji,jj) + rnf_b(ji,jj) ) * zfact * r1_rau0 / h_rnf(ji,jj)
384                  !END DO
385               !END DO
386            !END DO
387            CALL ctl_stop('key_vvl not implemented in TAM yet')
388         ELSE                          ! consadjt volume case : just apply the runoff input flow
389            DO jj = 1, jpj
390               DO ji = 1, jpi
391                  DO jk = 1, nk_rnf(ji,jj)
392                     rnf_ad(:,:) = rnf_ad(:,:) - phdivn_ad(:,:,1) * zfact * r1_rau0 / h_rnf(ji,jj)
393                     rnf_b_ad(:,:) = rnf_b_ad(:,:) - phdivn_ad(:,:,1) * zfact * r1_rau0 / h_rnf(ji,jj)
394                  END DO
395               END DO
396            END DO
397         ENDIF
398      ELSE                       !==   runoff put only at the surface   ==!
399         IF( lk_vvl ) THEN              ! variable volume case
400            CALL ctl_stop('key_vvl not implemented in TAM yet')
401            !h_rnf(:,:) = fse3t(:,:,1)   ! recalculate h_rnf to be depth of top box
402         ENDIF
403         rnf_ad(:,:) = rnf_ad(:,:) - phdivn_ad(:,:,1) * zfact * r1_rau0 / fse3t(:,:,1)
404         rnf_b_ad(:,:) = rnf_b_ad(:,:) - phdivn_ad(:,:,1) * zfact * r1_rau0 / fse3t(:,:,1)
405      ENDIF
406      !
407   END SUBROUTINE sbc_rnf_div_adj
408
409   SUBROUTINE sbc_rnf_init_tam
410      !!----------------------------------------------------------------------
411      !!                  ***  ROUTINE sbc_rnf_init  ***
412      !!
413      !! ** Purpose :   Initialisation of the runoffs if (ln_rnf=T)
414      !!
415      !! ** Method  : - read the runoff namsbc_rnf namelist
416      !!
417      !! ** Action  : - read parameters
418      !!----------------------------------------------------------------------
419      CHARACTER(len=32) ::   rn_dep_file   ! runoff file name
420      INTEGER           ::   ji, jj, jk    ! dummy loop indices
421      INTEGER           ::   ierror, inum  ! temporary integer
422      !!
423      IF(lwp) THEN
424         WRITE(numout,*)
425         WRITE(numout,*) 'sbc_rnf_tam : runoff '
426         WRITE(numout,*) '~~~~~~~ '
427         WRITE(numout,*) '   Namelist namsbc_rnf'
428         WRITE(numout,*) '      runoff in a file to be read                ln_rnf_emp   = ', ln_rnf_emp
429         WRITE(numout,*) '      specific river mouths treatment            ln_rnf_mouth = ', ln_rnf_mouth
430         WRITE(numout,*) '      river mouth additional Kz                  rn_avt_rnf   = ', rn_avt_rnf
431         WRITE(numout,*) '      depth of river mouth additional mixing     rn_hrnf      = ', rn_hrnf
432         WRITE(numout,*) '      multiplicative factor for runoff           rn_rfact     = ', rn_rfact
433      ENDIF
434
435      !                                   ! ==================
436      !                                   !   Type of runoff
437      !                                   ! ==================
438      !                                         !==  allocate runoff arrays
439      IF( sbc_rnf_alloc_tam() /= 0 )   CALL ctl_stop( 'STOP', 'sbc_rnf_alloc_tam : unable to allocate arrays' )
440      !
441      !
442      rnf_tl(:,:) =  0._wp                         ! runoff initialisation
443      rnf_ad(:,:) =  0._wp                         ! runoff initialisation
444      rnf_tsc_tl(:,:,:) = 0._wp                    ! runoffs temperature & salinty contents initilisation
445      rnf_tsc_ad(:,:,:) = 0._wp                    ! runoffs temperature & salinty contents initilisation
446      rnf_tsc_b_tl(:,:,:) = 0._wp                    ! runoffs temperature & salinty contents initilisation
447      rnf_tsc_b_ad(:,:,:) = 0._wp                    ! runoffs temperature & salinty contents initilisation
448      !
449   END SUBROUTINE sbc_rnf_init_tam
450#endif
451   !!======================================================================
452END MODULE sbcrnf_tam
Note: See TracBrowser for help on using the repository browser.