source: branches/2016/dev_r6859_LIM3_meltponds/NEMOGCM/NEMO/LIM_SRC_3/limmp.F90 @ 7293

Last change on this file since 7293 was 7293, checked in by vancop, 4 years ago

Commit infrastructure for melt pond impletation

File size: 51.5 KB
Line 
1MODULE limmp 
2   !!======================================================================
3   !!                     ***  MODULE  limmp   ***
4   !!   Melt ponds
5   !!======================================================================
6   !! history :       ! Original code by Daniela Flocco and Adrian Turner
7   !!            1.0  ! 2012    (O. Lecomte) Adaptation for scientific tests (NEMO3.1)
8   !!            2.0  ! 2016    (O. Lecomte, C. Rousset, M. Vancoppenolle) Implementation in NEMO3.6
9   !!----------------------------------------------------------------------
10#if defined key_lim3
11   !!----------------------------------------------------------------------
12   !!   'key_lim3' :                                 LIM3 sea-ice model
13   !!----------------------------------------------------------------------
14   !!   lim_mp_init      : some initialization and namelist read
15   !!   lim_mp           : main calling routine
16   !!   compute_mp_topo  : actual melt pond routine
17   !!   pond_area        : computes melt pond fraction per category
18   !!   calc_hpond       : computes melt pond depth
19   !!   permeability_phy : computes permeability
20
21   !!----------------------------------------------------------------------
22!  USE phycst           ! physical constants
23!  USE dom_oce          ! ocean space and time domain
24!  USE sbc_ice          ! Surface boundary condition: ice   fields
25   USE ice              ! LIM-3 variables
26   USE lbclnk           ! lateral boundary conditions - MPP exchanges
27   USE lib_mpp          ! MPP library
28   USE wrk_nemo         ! work arrays
29   USE in_out_manager   ! I/O manager
30   USE lib_fortran      ! glob_sum
31   USE timing           ! Timing
32!  USE limcons          ! conservation tests
33!  USE limctl           ! control prints
34!  USE limvar
35
36!OLI_CODE    USE ice_oce, ONLY: rdt_ice, tatm_ice
37!OLI_CODE    USE phycst
38!OLI_CODE    USE dom_ice
39!OLI_CODE    USE dom_oce
40!OLI_CODE    USE sbc_oce
41!OLI_CODE    USE sbc_ice
42!OLI_CODE    USE par_ice
43!OLI_CODE    USE par_oce
44!OLI_CODE    USE ice
45!OLI_CODE    USE thd_ice
46!OLI_CODE    USE in_out_manager
47!OLI_CODE    USE lbclnk
48!OLI_CODE    USE lib_mpp
49!OLI_CODE
50!OLI_CODE    IMPLICIT NONE
51!OLI_CODE    PRIVATE
52!OLI_CODE
53!OLI_CODE    PUBLIC   lim_mp_init
54!OLI_CODE    PUBLIC   lim_mp
55
56   IMPLICIT NONE
57   PRIVATE
58
59   PUBLIC   lim_mp_init    ! routine called by sbcice_lim.F90
60!  PUBLIC   lim_mp         ! routine called by sbcice_lim.F90
61
62   !! * Substitutions
63#  include "vectopt_loop_substitute.h90"
64   !!----------------------------------------------------------------------
65   !! NEMO/LIM3 4.0 , UCL - NEMO Consortium (2011)
66   !! $Id: limdyn.F90 6994 2016-10-05 13:07:10Z clem $
67   !! Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt)
68   !!----------------------------------------------------------------------
69CONTAINS
70
71   SUBROUTINE lim_mp_init 
72      !!-------------------------------------------------------------------
73      !!                  ***  ROUTINE lim_mp_init   ***
74      !!
75      !! ** Purpose : Physical constants and parameters linked to melt ponds
76      !!      over sea ice
77      !!
78      !! ** Method  :  Read the namicemp  namelist and check the melt pond 
79      !!       parameter values called at the first timestep (nit000)
80      !!
81      !! ** input   :   Namelist namicemp 
82      !!-------------------------------------------------------------------
83      INTEGER  ::   ios                 ! Local integer output status for namelist read
84      NAMELIST/namicemp/  ln_limMP, nn_limMP
85      !!-------------------------------------------------------------------
86
87      REWIND( numnam_ice_ref )              ! Namelist namicemp  in reference namelist : Melt Ponds 
88      READ  ( numnam_ice_ref, namicemp, IOSTAT = ios, ERR = 901)
89901   IF( ios /= 0 ) CALL ctl_nam ( ios , 'namicemp  in reference namelist', lwp )
90
91      REWIND( numnam_ice_cfg )              ! Namelist namicemp  in configuration namelist : Melt Ponds
92      READ  ( numnam_ice_cfg, namicemp, IOSTAT = ios, ERR = 902 )
93902   IF( ios /= 0 ) CALL ctl_nam ( ios , 'namicemp in configuration namelist', lwp )
94      IF(lwm) WRITE ( numoni, namicemp )
95     
96      IF(lwp) THEN                        ! control print
97         WRITE(numout,*)
98         WRITE(numout,*) 'lim_mp_init : ice parameters for melt ponds'
99         WRITE(numout,*) '~~~~~~~~~~~~'
100         WRITE(numout,*)'    Activate melt ponds                                         ln_limMP      = ', ln_limMP 
101         WRITE(numout,*)'    Type of melt pond implementation (1=all,2=rad, 3=fw, 4=no)  nn_limMP      = ', nn_limMP 
102      ENDIF
103      !
104   END SUBROUTINE lim_mp_init
105
106#else
107   !!----------------------------------------------------------------------
108   !!   Default option          Empty module           NO LIM sea-ice model
109   !!----------------------------------------------------------------------
110CONTAINS
111   SUBROUTINE lim_mp_init     ! Empty routine
112   END SUBROUTINE lim_mp_init
113#endif 
114
115   !!======================================================================
116END MODULE limmp 
117
118!======================================================================================================================================================
119!======================================================================================================================================================
120!======================================================================================================================================================
121! DIRTY LEFT OVERS FROM ASSHOLES
122!
123!  SUBROUTINE lim_dyn( kt )
124!     !!-------------------------------------------------------------------
125!     !!               ***  ROUTINE lim_dyn  ***
126!     !!               
127!     !! ** Purpose :   compute ice velocity
128!     !!               
129!     !! ** Method  :
130!     !!
131!     !! ** Action  : - Initialisation
132!     !!              - Call of the dynamic routine for each hemisphere
133!     !!------------------------------------------------------------------------------------
134!     INTEGER, INTENT(in) ::   kt     ! number of iteration
135!     !!
136!     INTEGER  :: jl, jk ! dummy loop indices
137!     REAL(wp) :: zvi_b, zsmv_b, zei_b, zfs_b, zfw_b, zft_b
138!    !!---------------------------------------------------------------------
139
140!     IF( nn_timing == 1 )  CALL timing_start('limdyn')
141
142!     CALL lim_var_agg(1)                      ! aggregate ice categories
143      !
144!     ! conservation test
145!     IF( ln_limdiachk ) CALL lim_cons_hsm(0, 'limdyn', zvi_b, zsmv_b, zei_b, zfw_b, zfs_b, zft_b)
146!  END SUBROUTINE lim_dyn
147
148!OLI_CODE MODULE limmp_topo
149!OLI_CODE    !!======================================================================
150!OLI_CODE    !!                       ***  MODULE limmp_topo ***
151!OLI_CODE    !! LIM-3 sea-ice :  computation of melt ponds' properties
152!OLI_CODE    !!======================================================================
153!OLI_CODE    !! History :  Original code by Daniela Flocco and Adrian Turner
154!OLI_CODE    !!            ! 2012-09 (O. Lecomte) Adaptation for routine inclusion in
155!OLI_CODE    !!                      NEMO-LIM3.1
156!OLI_CODE    !!            ! 2016-11 (O. Lecomte, C. Rousset, M. Vancoppenolle)
157!OLI_CODE    !!                      Adaptation for merge with NEMO-LIM3.6
158!OLI_CODE    !!----------------------------------------------------------------------
159!OLI_CODE #if defined key_lim3
160!OLI_CODE    !!----------------------------------------------------------------------
161!OLI_CODE    !!   'key_lim3'                                      LIM-3 sea-ice model
162!OLI_CODE    !!----------------------------------------------------------------------
163!OLI_CODE    !!   lim_mp_init     : melt pond properties initialization
164!OLI_CODE    !!   lim_mp          : melt pond routine caller
165!OLI_CODE    !!   compute_mp_topo : Actual melt pond routine
166!OLI_CODE    !!----------------------------------------------------------------------
167!OLI_CODE    USE ice_oce, ONLY: rdt_ice, tatm_ice
168!OLI_CODE    USE phycst
169!OLI_CODE    USE dom_ice
170!OLI_CODE    USE dom_oce
171!OLI_CODE    USE sbc_oce
172!OLI_CODE    USE sbc_ice
173!OLI_CODE    USE par_ice
174!OLI_CODE    USE par_oce
175!OLI_CODE    USE ice
176!OLI_CODE    USE thd_ice
177!OLI_CODE    USE in_out_manager
178!OLI_CODE    USE lbclnk
179!OLI_CODE    USE lib_mpp
180!OLI_CODE
181!OLI_CODE    IMPLICIT NONE
182!OLI_CODE    PRIVATE
183!OLI_CODE
184!OLI_CODE    PUBLIC   lim_mp_init
185!OLI_CODE    PUBLIC   lim_mp
186!OLI_CODE
187!OLI_CODE CONTAINS
188!OLI_CODE
189!OLI_CODE    SUBROUTINE lim_mp_init
190!OLI_CODE       !!-------------------------------------------------------------------
191!OLI_CODE       !!                ***  ROUTINE lim_mp_init  ***
192!OLI_CODE       !!
193!OLI_CODE       !! ** Purpose :   Initialize melt ponds
194!OLI_CODE       !!-------------------------------------------------------------------
195!OLI_CODE       a_ip_frac(:,:,:)    = 0._wp
196!OLI_CODE       a_ip(:,:,:)         = 0._wp
197!OLI_CODE       h_ip(:,:,:)         = 0._wp
198!OLI_CODE       v_ip(:,:,:)         = 0._wp
199!OLI_CODE       h_il(:,:,:)         = 0._wp
200!OLI_CODE       v_il(:,:,:)         = 0._wp
201!OLI_CODE         
202!OLI_CODE    END SUBROUTINE lim_mp_init
203!OLI_CODE
204!OLI_CODE
205!OLI_CODE    SUBROUTINE lim_mp
206!OLI_CODE       !!-------------------------------------------------------------------
207!OLI_CODE       !!                ***  ROUTINE lim_mp  ***
208!OLI_CODE       !!
209!OLI_CODE       !! ** Purpose :   Compute surface heat flux and call main melt pond
210!OLI_CODE       !!                routine
211!OLI_CODE       !!-------------------------------------------------------------------
212!OLI_CODE
213!OLI_CODE       INTEGER  ::   ji, jj, jl   ! dummy loop indices
214!OLI_CODE
215!OLI_CODE       fsurf(:,:) = 0.e0
216!OLI_CODE       DO jl = 1, jpl
217!OLI_CODE          DO jj = 1, jpj
218!OLI_CODE             DO ji = 1, jpi
219!OLI_CODE                fsurf(ji,jj) = fsurf(ji,jj) + a_i(ji,jj,jl) * &
220!OLI_CODE                      (qns_ice(ji,jj,jl) + (1.0 - izero(ji,jj,jl)) &
221!OLI_CODE                        * qsr_ice(ji,jj,jl))
222!OLI_CODE             END DO
223!OLI_CODE          END DO
224!OLI_CODE       END DO
225!OLI_CODE
226!OLI_CODE       CALL compute_mp_topo(at_i, a_i,                               &
227!OLI_CODE                          vt_i, v_i, v_s, rhosn_glo, t_i, s_i, a_ip_frac,  &
228!OLI_CODE                       h_ip, h_il, t_su, tatm_ice, diag_sur_me*rdt_ice, &
229!OLI_CODE                          fsurf, fwoc)
230!OLI_CODE
231!OLI_CODE       at_ip(:,:) = 0.0
232!OLI_CODE       vt_ip(:,:) = 0.0
233!OLI_CODE       vt_il(:,:) = 0.0
234!OLI_CODE       DO jl = 1, jpl
235!OLI_CODE         DO jj = 1, jpj
236!OLI_CODE            DO ji = 1, jpi
237!OLI_CODE               a_ip(ji,jj,jl) = MAX(0.0_wp, a_ip_frac(ji,jj,jl) * &
238!OLI_CODE                                                   a_i(ji,jj,jl))
239!OLI_CODE               v_ip(ji,jj,jl) = MAX(0.0_wp, a_ip_frac(ji,jj,jl) * &
240!OLI_CODE                                   a_i(ji,jj,jl) * h_ip(ji,jj,jl))
241!OLI_CODE               v_il(ji,jj,jl) = MAX(0.0_wp, a_ip_frac(ji,jj,jl) * &
242!OLI_CODE                                   a_i(ji,jj,jl) * h_il(ji,jj,jl))
243!OLI_CODE               at_ip(ji,jj)   = at_ip(ji,jj) + a_ip(ji,jj,jl)
244!OLI_CODE               vt_ip(ji,jj)   = vt_ip(ji,jj) + v_ip(ji,jj,jl)
245!OLI_CODE               vt_il(ji,jj)   = vt_il(ji,jj) + v_il(ji,jj,jl)
246!OLI_CODE            END DO
247!OLI_CODE         END DO
248!OLI_CODE       END DO
249!OLI_CODE
250!OLI_CODE    END SUBROUTINE lim_mp
251!OLI_CODE
252!OLI_CODE
253!OLI_CODE    SUBROUTINE compute_mp_topo(aice,      aicen,     &
254!OLI_CODE                               vice,      vicen,     &
255!OLI_CODE                               vsnon,     rhos,      &
256!OLI_CODE                               ticen,     salin,     &
257!OLI_CODE                               a_ip_frac, h_ip,      &
258!OLI_CODE                               h_il,      Tsfc,      &
259!OLI_CODE                               potT,      meltt,     &
260!OLI_CODE                               fsurf,     fwoc)
261!OLI_CODE       !!-------------------------------------------------------------------
262!OLI_CODE       !!                ***  ROUTINE compute_mp_topo  ***
263!OLI_CODE       !!
264!OLI_CODE       !! ** Purpose :   Compute melt pond evolution based on the ice
265!OLI_CODE       !!                topography as inferred from the ice thickness
266!OLI_CODE       !!                distribution. 
267!OLI_CODE       !!
268!OLI_CODE       !! ** Method  :   This code is initially based on Flocco and Feltham
269!OLI_CODE       !!                (2007) and Flocco et al. (2010). More to come...
270!OLI_CODE       !!
271!OLI_CODE       !! ** Tunable parameters :
272!OLI_CODE       !!
273!OLI_CODE       !! ** Note :
274!OLI_CODE       !!
275!OLI_CODE       !! ** References
276!OLI_CODE       !!    Flocco, D. and D. L. Feltham, 2007.  A continuum model of melt pond
277!OLI_CODE       !!    evolution on Arctic sea ice.  J. Geophys. Res. 112, C08016, doi:
278!OLI_CODE       !!    10.1029/2006JC003836.
279!OLI_CODE       !!    Flocco, D., D. L. Feltham and A. K. Turner, 2010.  Incorporation of
280!OLI_CODE       !!    a physically based melt pond scheme into the sea ice component of a
281!OLI_CODE       !!    climate model.  J. Geophys. Res. 115, C08012,
282!OLI_CODE       !!    doi: 10.1029/2009JC005568.
283!OLI_CODE       !!   
284!OLI_CODE       !!-------------------------------------------------------------------
285!OLI_CODE
286!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj), &
287!OLI_CODE          INTENT(IN) :: &
288!OLI_CODE          aice, &    ! total ice area fraction
289!OLI_CODE          vice       ! total ice volume (m)
290!OLI_CODE
291!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj,jpl), &
292!OLI_CODE          INTENT(IN) :: &
293!OLI_CODE          aicen, &   ! ice area fraction, per category
294!OLI_CODE          vsnon, &   ! snow volume, per category (m)
295!OLI_CODE          rhos,  &   ! equivalent snow density, per category (kg/m^3)
296!OLI_CODE          vicen      ! ice volume, per category (m)
297!OLI_CODE
298!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj,nlay_i,jpl), &
299!OLI_CODE          INTENT(IN) :: &
300!OLI_CODE          ticen, &   ! ice enthalpy, per category
301!OLI_CODE          salin
302!OLI_CODE
303!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj,jpl), &
304!OLI_CODE          INTENT(INOUT) :: &
305!OLI_CODE          a_ip_frac , &   ! pond area fraction of ice, per ice category
306!OLI_CODE          h_ip , &   ! pond depth, per ice category (m)
307!OLI_CODE          h_il       ! Refrozen ice lid thickness, per ice category (m)
308!OLI_CODE
309!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj), &
310!OLI_CODE          INTENT(IN) :: &
311!OLI_CODE          potT,  &   ! air potential temperature
312!OLI_CODE          meltt, &   ! total surface meltwater flux
313!OLI_CODE          fsurf      ! thermodynamic heat flux at ice/snow surface (W/m^2)
314!OLI_CODE
315!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj), &
316!OLI_CODE          INTENT(INOUT) :: &
317!OLI_CODE          fwoc      ! fresh water flux to the ocean (from draining and other pond volume adjustments)
318!OLI_CODE                    ! (m)
319!OLI_CODE
320!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj,jpl), &
321!OLI_CODE          INTENT(IN) :: &
322!OLI_CODE          Tsfc       ! snow/sea ice surface temperature
323!OLI_CODE
324!OLI_CODE       ! local variables
325!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj,jpl) :: &
326!OLI_CODE          zTsfcn, & ! ice/snow surface temperature (C)
327!OLI_CODE          zvolpn, & ! pond volume per unit area, per category (m)
328!OLI_CODE          zvuin     ! water-equivalent volume of ice lid on melt pond ('upper ice', m)
329!OLI_CODE
330!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj,jpl) :: &
331!OLI_CODE          zapondn,& ! pond area fraction, per category
332!OLI_CODE          zhpondn   ! pond depth, per category (m)
333!OLI_CODE
334!OLI_CODE       REAL (wp), DIMENSION (jpi,jpj) :: &
335!OLI_CODE          zvolp       ! total volume of pond, per unit area of pond (m)
336!OLI_CODE
337!OLI_CODE       REAL (wp) :: &
338!OLI_CODE          zhi,    & ! ice thickness (m)
339!OLI_CODE          zdHui,  & ! change in thickness of ice lid (m)
340!OLI_CODE          zomega, & ! conduction
341!OLI_CODE          zdTice, & ! temperature difference across ice lid (C)
342!OLI_CODE          zdvice, & ! change in ice volume (m)
343!OLI_CODE          zTavg,  & ! mean surface temperature across categories (C)
344!OLI_CODE          zTp,    & ! pond freezing temperature (C)
345!OLI_CODE          zdvn      ! change in melt pond volume for fresh water budget
346!OLI_CODE       INTEGER, DIMENSION (jpi*jpj) :: &
347!OLI_CODE          indxi, indxj    ! compressed indices for cells with ice melting
348!OLI_CODE
349!OLI_CODE       INTEGER :: n,k,i,j,ij,icells,indxij ! loop indices
350!OLI_CODE
351!OLI_CODE       INTEGER, DIMENSION (jpl) :: &
352!OLI_CODE          kcells          ! cells where ice lid combines with vice
353!OLI_CODE
354!OLI_CODE       INTEGER, DIMENSION (jpi*jpj,jpl) :: &
355!OLI_CODE          indxii, indxjj  ! i,j indices for kcells loop
356!OLI_CODE
357!OLI_CODE       REAL (wp), parameter :: &
358!OLI_CODE          zhicemin  = 0.1_wp , & ! minimum ice thickness with ponds (m)
359!OLI_CODE          zTd       = 0.15_wp, & ! temperature difference for freeze-up (C)
360!OLI_CODE          zr1_rlfus = 1._wp / 0.334e+6 / 917._wp , & ! (J/m^3)
361!OLI_CODE          zmin_volp = 1.e-4_wp, & ! minimum pond volume (m)
362!OLI_CODE          z0       = 0._wp,    &
363!OLI_CODE          zTimelt   = 0._wp,    &
364!OLI_CODE          z01      = 0.01_wp,  &
365!OLI_CODE          z25      = 0.25_wp,  &
366!OLI_CODE          z5       = 0.5_wp,   &
367!OLI_CODE          zuny     = 1.0e-11_wp
368!OLI_CODE       !---------------------------------------------------------------
369!OLI_CODE       ! initialize
370!OLI_CODE       !---------------------------------------------------------------
371!OLI_CODE
372!OLI_CODE       DO j = 1, jpj
373!OLI_CODE          DO i = 1, jpi
374!OLI_CODE             zvolp(i,j) = z0
375!OLI_CODE          END DO
376!OLI_CODE       END DO
377!OLI_CODE       DO n = 1, jpl
378!OLI_CODE          DO j = 1, jpj
379!OLI_CODE             DO i = 1, jpi
380!OLI_CODE                ! load tracers
381!OLI_CODE                zvolp(i,j) = zvolp(i,j) + h_ip(i,j,n) &
382!OLI_CODE                                      * a_ip_frac(i,j,n) * aicen(i,j,n)
383!OLI_CODE                zTsfcn(i,j,n) = Tsfc(i,j,n) - rtt ! convert in Celsius - Oli
384!OLI_CODE                zvuin (i,j,n) = h_il(i,j,n) &
385!OLI_CODE                             * a_ip_frac(i,j,n) * aicen(i,j,n)
386!OLI_CODE
387!OLI_CODE                zhpondn(i,j,n) = z0     ! pond depth, per category
388!OLI_CODE                zapondn(i,j,n) = z0     ! pond area,  per category
389!OLI_CODE             END DO
390!OLI_CODE          END DO
391!OLI_CODE          indxii(:,n) = 0
392!OLI_CODE          indxjj(:,n) = 0
393!OLI_CODE          kcells  (n) = 0
394!OLI_CODE       END DO
395!OLI_CODE
396!OLI_CODE       ! The freezing temperature for meltponds is assumed slightly below 0C,
397!OLI_CODE       ! as if meltponds had a little salt in them.  The salt budget is not
398!OLI_CODE       ! altered for meltponds, but if it were then an actual pond freezing
399!OLI_CODE       ! temperature could be computed.
400!OLI_CODE
401!OLI_CODE       zTp = zTimelt - zTd
402!OLI_CODE
403!OLI_CODE       !-----------------------------------------------------------------
404!OLI_CODE       ! Identify grid cells with ponds
405!OLI_CODE       !-----------------------------------------------------------------
406!OLI_CODE
407!OLI_CODE       icells = 0
408!OLI_CODE       DO j = 1, jpj
409!OLI_CODE       DO i = 1, jpi
410!OLI_CODE          zhi = z0
411!OLI_CODE          IF (aice(i,j) > zuny) zhi = vice(i,j)/aice(i,j)
412!OLI_CODE          IF ( aice(i,j) > z01 .and. zhi > zhicemin .and. &
413!OLI_CODE             zvolp(i,j) > zmin_volp*aice(i,j)) THEN
414!OLI_CODE             icells = icells + 1
415!OLI_CODE             indxi(icells) = i
416!OLI_CODE             indxj(icells) = j
417!OLI_CODE          ELSE  ! remove ponds on thin ice
418!OLI_CODE             !fpond(i,j) = fpond(i,j) - zvolp(i,j)
419!OLI_CODE             zvolpn(i,j,:) = z0
420!OLI_CODE             zvuin (i,j,:) = z0
421!OLI_CODE             zvolp (i,j) = z0
422!OLI_CODE          END IF
423!OLI_CODE       END DO                     ! i
424!OLI_CODE       END DO                     ! j
425!OLI_CODE
426!OLI_CODE       DO ij = 1, icells
427!OLI_CODE          i = indxi(ij)
428!OLI_CODE          j = indxj(ij)
429!OLI_CODE
430!OLI_CODE          !--------------------------------------------------------------
431!OLI_CODE          ! calculate pond area and depth
432!OLI_CODE          !--------------------------------------------------------------
433!OLI_CODE          CALL pond_area(aice(i,j),vice(i,j),rhos(i,j,:), &
434!OLI_CODE                    aicen(i,j,:), vicen(i,j,:), vsnon(i,j,:), &
435!OLI_CODE                    ticen(i,j,:,:), salin(i,j,:,:), &
436!OLI_CODE                    zvolpn(i,j,:), zvolp(i,j), &
437!OLI_CODE                    zapondn(i,j,:),zhpondn(i,j,:), zdvn)
438!OLI_CODE
439!OLI_CODE          fwoc(i,j) = fwoc(i,j) + zdvn ! -> Goes to fresh water budget
440!OLI_CODE
441!OLI_CODE          ! mean surface temperature
442!OLI_CODE          zTavg = z0
443!OLI_CODE          DO n = 1, jpl
444!OLI_CODE             zTavg = zTavg + zTsfcn(i,j,n)*aicen(i,j,n)
445!OLI_CODE          END DO
446!OLI_CODE          zTavg = zTavg / aice(i,j)
447!OLI_CODE
448!OLI_CODE          DO n = 1, jpl-1
449!OLI_CODE                       
450!OLI_CODE             IF (zvuin(i,j,n) > zuny) THEN
451!OLI_CODE
452!OLI_CODE          !----------------------------------------------------------------
453!OLI_CODE          ! melting: floating upper ice layer melts in whole or part
454!OLI_CODE          !----------------------------------------------------------------
455!OLI_CODE !               IF (zTsfcn(i,j,n) > zTp) THEN
456!OLI_CODE                IF (zTavg > zTp) THEN
457!OLI_CODE
458!OLI_CODE                   zdvice = min(meltt(i,j)*zapondn(i,j,n), zvuin(i,j,n))
459!OLI_CODE                   IF (zdvice > zuny) THEN
460!OLI_CODE                      zvuin (i,j,n) = zvuin (i,j,n) - zdvice
461!OLI_CODE                      zvolpn(i,j,n) = zvolpn(i,j,n) + zdvice
462!OLI_CODE                      zvolp (i,j)   = zvolp (i,j)   + zdvice
463!OLI_CODE                      !fwoc(i,j)   = fwoc(i,j)   + zdvice
464!OLI_CODE                       
465!OLI_CODE                      IF (zvuin(i,j,n) < zuny .and. zvolpn(i,j,n) > puny) THEN
466!OLI_CODE                         ! ice lid melted and category is pond covered
467!OLI_CODE                         zvolpn(i,j,n) = zvolpn(i,j,n) + zvuin(i,j,n)
468!OLI_CODE                         !fwoc(i,j)   = fwoc(i,j)   + zvuin(i,j,n)
469!OLI_CODE                         zvuin(i,j,n)  = z0
470!OLI_CODE                      END IF
471!OLI_CODE                      zhpondn(i,j,n) = zvolpn(i,j,n) / zapondn(i,j,n)
472!OLI_CODE                   END IF
473!OLI_CODE
474!OLI_CODE          !----------------------------------------------------------------
475!OLI_CODE          ! freezing: existing upper ice layer grows
476!OLI_CODE          !----------------------------------------------------------------
477!OLI_CODE                ELSE IF (zvolpn(i,j,n) > zuny) THEN ! zTavg <= zTp
478!OLI_CODE
479!OLI_CODE                 ! dIFferential growth of base of surface floating ice layer
480!OLI_CODE                   zdTice = max(-zTavg, z0) ! > 0
481!OLI_CODE                   zomega = rcdic*zdTice * zr1_rlfus
482!OLI_CODE                   zdHui = sqrt(zomega*rdt_ice + z25*(zvuin(i,j,n)/  &
483!OLI_CODE                         aicen(i,j,n))**2)- z5 * zvuin(i,j,n)/aicen(i,j,n)
484!OLI_CODE
485!OLI_CODE                   zdvice = min(zdHui*zapondn(i,j,n), zvolpn(i,j,n))   
486!OLI_CODE                   IF (zdvice > zuny) THEN
487!OLI_CODE                      zvuin (i,j,n) = zvuin (i,j,n) + zdvice
488!OLI_CODE                      zvolpn(i,j,n) = zvolpn(i,j,n) - zdvice
489!OLI_CODE                      zvolp (i,j)   = zvolp (i,j)   - zdvice
490!OLI_CODE                      !fwoc(i,j)   = fwoc(i,j)   - zdvice
491!OLI_CODE                      zhpondn(i,j,n) = zvolpn(i,j,n) / zapondn(i,j,n)
492!OLI_CODE                   END IF
493!OLI_CODE
494!OLI_CODE                END IF ! zTavg
495!OLI_CODE
496!OLI_CODE          !----------------------------------------------------------------
497!OLI_CODE          ! freezing: upper ice layer begins to form
498!OLI_CODE          ! note: albedo does not change
499!OLI_CODE          !----------------------------------------------------------------
500!OLI_CODE             ELSE ! zvuin < zuny
501!OLI_CODE                     
502!OLI_CODE                ! thickness of newly formed ice
503!OLI_CODE                ! the surface temperature of a meltpond is the same as that
504!OLI_CODE                ! of the ice underneath (0C), and the thermodynamic surface
505!OLI_CODE                ! flux is the same
506!OLI_CODE                zdHui = max(-fsurf(i,j)*rdt_ice*zr1_rlfus, z0)
507!OLI_CODE                zdvice = min(zdHui*zapondn(i,j,n), zvolpn(i,j,n)) 
508!OLI_CODE                IF (zdvice > zuny) THEN
509!OLI_CODE                   zvuin (i,j,n) = zdvice
510!OLI_CODE                   zvolpn(i,j,n) = zvolpn(i,j,n) - zdvice
511!OLI_CODE                   zvolp (i,j)   = zvolp (i,j)   - zdvice
512!OLI_CODE                   !fwoc(i,j)   = fwoc(i,j)   - zdvice
513!OLI_CODE                   zhpondn(i,j,n)= zvolpn(i,j,n) / zapondn(i,j,n)
514!OLI_CODE                END IF
515!OLI_CODE                     
516!OLI_CODE             END IF  ! zvuin
517!OLI_CODE
518!OLI_CODE          END DO ! jpl
519!OLI_CODE
520!OLI_CODE       END DO ! ij
521!OLI_CODE
522!OLI_CODE       !---------------------------------------------------------------
523!OLI_CODE       ! remove ice lid if there is no liquid pond
524!OLI_CODE       ! zvuin may be nonzero on category jpl due to dynamics
525!OLI_CODE       !---------------------------------------------------------------
526!OLI_CODE
527!OLI_CODE       DO j = 1, jpj
528!OLI_CODE       DO i = 1, jpi
529!OLI_CODE          DO n = 1, jpl
530!OLI_CODE             IF (aicen(i,j,n) > zuny .and. zvolpn(i,j,n) < puny &
531!OLI_CODE                                     .and. zvuin (i,j,n) > zuny) THEN
532!OLI_CODE                kcells(n) = kcells(n) + 1
533!OLI_CODE                indxij    = kcells(n)
534!OLI_CODE                indxii(indxij,n) = i
535!OLI_CODE                indxjj(indxij,n) = j
536!OLI_CODE             END IF
537!OLI_CODE          END DO
538!OLI_CODE       END DO                     ! i
539!OLI_CODE       END DO                     ! j
540!OLI_CODE
541!OLI_CODE       DO n = 1, jpl
542!OLI_CODE
543!OLI_CODE          IF (kcells(n) > 0) THEN
544!OLI_CODE          DO ij = 1, kcells(n)
545!OLI_CODE             i = indxii(ij,n)
546!OLI_CODE             j = indxjj(ij,n)
547!OLI_CODE             fwoc(i,j) = fwoc(i,j) + rhoic/rauw * zvuin(i,j,n) ! Completely refrozen lid goes into ocean (to be changed)
548!OLI_CODE             zvuin(i,j,n) = z0
549!OLI_CODE          END DO    ! ij
550!OLI_CODE          END IF
551!OLI_CODE
552!OLI_CODE          ! reload tracers
553!OLI_CODE          DO j = 1, jpj
554!OLI_CODE             DO i = 1, jpi
555!OLI_CODE                IF (zapondn(i,j,n) > zuny) THEN
556!OLI_CODE                   h_il(i,j,n) = zvuin(i,j,n) / zapondn(i,j,n)
557!OLI_CODE                ELSE
558!OLI_CODE                   zvuin(i,j,n) = z0
559!OLI_CODE                   h_il(i,j,n) = z0
560!OLI_CODE                END IF
561!OLI_CODE                IF (aicen(i,j,n) > zuny) THEN
562!OLI_CODE                   a_ip_frac(i,j,n) = zapondn(i,j,n) / aicen(i,j,n) * &
563!OLI_CODE                         (1.0_wp - MAX(z0, SIGN(1.0_wp, -zvolpn(i,j,n))))
564!OLI_CODE                   h_ip(i,j,n) = zhpondn(i,j,n)
565!OLI_CODE                ELSE
566!OLI_CODE                   a_ip_frac(i,j,n) = z0
567!OLI_CODE                   h_ip(i,j,n) = z0
568!OLI_CODE                   h_il(i,j,n) = z0
569!OLI_CODE                END IF
570!OLI_CODE             END DO ! i
571!OLI_CODE          END DO    ! j
572!OLI_CODE
573!OLI_CODE       END DO       ! n
574!OLI_CODE
575!OLI_CODE    END SUBROUTINE compute_mp_topo
576!OLI_CODE
577!OLI_CODE
578!OLI_CODE    SUBROUTINE pond_area(aice,vice,rhos,             &
579!OLI_CODE                         aicen, vicen, vsnon, ticen, &
580!OLI_CODE                         salin, zvolpn, zvolp,         &
581!OLI_CODE                         zapondn,zhpondn,dvolp)
582!OLI_CODE       !!-------------------------------------------------------------------
583!OLI_CODE       !!                ***  ROUTINE pond_area  ***
584!OLI_CODE       !!
585!OLI_CODE       !! ** Purpose :   Compute melt pond area, depth and melting rates
586!OLI_CODE       !!------------------------------------------------------------------
587!OLI_CODE       REAL (wp), INTENT(IN) :: &
588!OLI_CODE          aice,vice
589!OLI_CODE
590!OLI_CODE       REAL (wp), DIMENSION(jpl), INTENT(IN) :: &
591!OLI_CODE          aicen, vicen, vsnon, rhos
592!OLI_CODE
593!OLI_CODE       REAL (wp), DIMENSION(nlay_i,jpl), INTENT(IN) :: &
594!OLI_CODE          ticen, salin
595!OLI_CODE
596!OLI_CODE       REAL (wp), DIMENSION(jpl), INTENT(INOUT) :: &
597!OLI_CODE          zvolpn
598!OLI_CODE
599!OLI_CODE       REAL (wp), INTENT(INOUT) :: &
600!OLI_CODE          zvolp, dvolp
601!OLI_CODE
602!OLI_CODE       REAL (wp), DIMENSION(jpl), INTENT(OUT) :: &
603!OLI_CODE          zapondn, zhpondn
604!OLI_CODE
605!OLI_CODE       INTEGER :: &
606!OLI_CODE          n, ns,   &
607!OLI_CODE          m_index, &
608!OLI_CODE          permflag
609!OLI_CODE
610!OLI_CODE       REAL (wp), DIMENSION(jpl) :: &
611!OLI_CODE          hicen, &
612!OLI_CODE          hsnon, &
613!OLI_CODE          asnon, &
614!OLI_CODE          alfan, &
615!OLI_CODE          betan, &
616!OLI_CODE          cum_max_vol, &
617!OLI_CODE          reduced_aicen       
618!OLI_CODE
619!OLI_CODE       REAL (wp), DIMENSION(0:jpl) :: &
620!OLI_CODE          cum_max_vol_tmp
621!OLI_CODE
622!OLI_CODE       REAL (wp) :: &
623!OLI_CODE          hpond, &
624!OLI_CODE          drain, &
625!OLI_CODE          floe_weight, &
626!OLI_CODE          pressure_head, &
627!OLI_CODE          hsl_rel, &
628!OLI_CODE          deltah, &
629!OLI_CODE          perm, &
630!OLI_CODE          apond, &
631!OLI_CODE          msno
632!OLI_CODE
633!OLI_CODE       REAL (wp), parameter :: &
634!OLI_CODE          viscosity = 1.79e-3_wp, &  ! kinematic water viscosity in kg/m/s
635!OLI_CODE          z0        = 0.0_wp    , &
636!OLI_CODE          c1        = 1.0_wp    , &
637!OLI_CODE          p4        = 0.4_wp    , &
638!OLI_CODE          p6        = 0.6_wp    , &
639!OLI_CODE          zuny      = 1.0e-11_wp
640!OLI_CODE         
641!OLI_CODE      !-----------|
642!OLI_CODE      !           |
643!OLI_CODE      !           |-----------|
644!OLI_CODE      !___________|___________|______________________________________sea-level
645!OLI_CODE      !           |           |
646!OLI_CODE      !           |           |---^--------|
647!OLI_CODE      !           |           |   |        |
648!OLI_CODE      !           |           |   |        |-----------|              |-------
649!OLI_CODE      !           |           |   |alfan(n)|           |              |
650!OLI_CODE      !           |           |   |        |           |--------------|
651!OLI_CODE      !           |           |   |        |           |              |
652!OLI_CODE      !---------------------------v-------------------------------------------
653!OLI_CODE      !           |           |   ^        |           |              |
654!OLI_CODE      !           |           |   |        |           |--------------|
655!OLI_CODE      !           |           |   |betan(n)|           |              |
656!OLI_CODE      !           |           |   |        |-----------|              |-------
657!OLI_CODE      !           |           |   |        |
658!OLI_CODE      !           |           |---v------- |
659!OLI_CODE      !           |           |
660!OLI_CODE      !           |-----------|
661!OLI_CODE      !           |
662!OLI_CODE      !-----------|
663!OLI_CODE     
664!OLI_CODE       !-------------------------------------------------------------------
665!OLI_CODE       ! initialize
666!OLI_CODE       !-------------------------------------------------------------------
667!OLI_CODE
668!OLI_CODE       DO n = 1, jpl
669!OLI_CODE
670!OLI_CODE          zapondn(n) = z0
671!OLI_CODE          zhpondn(n) = z0
672!OLI_CODE
673!OLI_CODE          IF (aicen(n) < zuny)  THEN
674!OLI_CODE             hicen(n) =  z0
675!OLI_CODE             hsnon(n) = z0
676!OLI_CODE             reduced_aicen(n) = z0
677!OLI_CODE          ELSE
678!OLI_CODE             hicen(n) = vicen(n) / aicen(n)
679!OLI_CODE             hsnon(n) = vsnon(n) / aicen(n)
680!OLI_CODE             reduced_aicen(n) = c1 ! n=jpl
681!OLI_CODE             IF (n < jpl) reduced_aicen(n) = aicen(n) &
682!OLI_CODE                                  * (-0.024_wp*hicen(n) + 0.832_wp)
683!OLI_CODE             asnon(n) = reduced_aicen(n)
684!OLI_CODE          END IF
685!OLI_CODE
686!OLI_CODE ! This choice for alfa and beta ignores hydrostatic equilibium of categories.
687!OLI_CODE ! Hydrostatic equilibium of the entire ITD is accounted for below, assuming
688!OLI_CODE ! a surface topography implied by alfa=0.6 and beta=0.4, and rigidity across all
689!OLI_CODE ! categories.  alfa and beta partition the ITD - they are areas not thicknesses!
690!OLI_CODE ! Multiplying by hicen, alfan and betan (below) are thus volumes per unit area.
691!OLI_CODE ! Here, alfa = 60% of the ice area (and since hice is constant in a category,
692!OLI_CODE ! alfan = 60% of the ice volume) in each category lies above the reference line,
693!OLI_CODE ! and 40% below. Note: p6 is an arbitrary choice, but alfa+beta=1 is required.
694!OLI_CODE
695!OLI_CODE          alfan(n) = p6 * hicen(n)
696!OLI_CODE          betan(n) = p4 * hicen(n)
697!OLI_CODE       
698!OLI_CODE          cum_max_vol(n)     = z0
699!OLI_CODE          cum_max_vol_tmp(n) = z0
700!OLI_CODE     
701!OLI_CODE       END DO ! jpl
702!OLI_CODE
703!OLI_CODE       cum_max_vol_tmp(0) = z0
704!OLI_CODE       drain = z0
705!OLI_CODE       dvolp = z0
706!OLI_CODE     
707!OLI_CODE       !--------------------------------------------------------------------------
708!OLI_CODE       ! the maximum amount of water that can be contained up to each ice category
709!OLI_CODE       !--------------------------------------------------------------------------
710!OLI_CODE     
711!OLI_CODE       DO n = 1, jpl-1 ! last category can not hold any volume
712!OLI_CODE
713!OLI_CODE          IF (alfan(n+1) >= alfan(n) .and. alfan(n+1) > z0) THEN
714!OLI_CODE
715!OLI_CODE             ! total volume in level including snow
716!OLI_CODE             cum_max_vol_tmp(n) = cum_max_vol_tmp(n-1) + &
717!OLI_CODE                (alfan(n+1) - alfan(n)) * sum(reduced_aicen(1:n))
718!OLI_CODE
719!OLI_CODE
720!OLI_CODE             ! subtract snow solid volumes from lower categories in current level
721!OLI_CODE             DO ns = 1, n
722!OLI_CODE                cum_max_vol_tmp(n) = cum_max_vol_tmp(n) &
723!OLI_CODE                   - rhos(ns)/rauw  * &    ! fraction of snow that is occupied by solid ??rauw
724!OLI_CODE                     asnon(ns)  * &    ! area of snow from that category
725!OLI_CODE                     max(min(hsnon(ns)+alfan(ns)-alfan(n), alfan(n+1)- &
726!OLI_CODE                                   alfan(n)), z0) 
727!OLI_CODE                                       ! thickness of snow from ns layer in n layer
728!OLI_CODE             END DO
729!OLI_CODE
730!OLI_CODE          ELSE ! assume higher categories unoccupied
731!OLI_CODE             cum_max_vol_tmp(n) = cum_max_vol_tmp(n-1)
732!OLI_CODE          END IF
733!OLI_CODE          !IF (cum_max_vol_tmp(n) < z0) THEN
734!OLI_CODE          !   call abort_ice('negative melt pond volume')
735!OLI_CODE          !END IF
736!OLI_CODE       END DO
737!OLI_CODE       cum_max_vol_tmp(jpl) = cum_max_vol_tmp(jpl-1)  ! last category holds no volume
738!OLI_CODE       cum_max_vol  (1:jpl) = cum_max_vol_tmp(1:jpl)
739!OLI_CODE     
740!OLI_CODE       !----------------------------------------------------------------
741!OLI_CODE       ! is there more meltwater than can be held in the floe?
742!OLI_CODE       !----------------------------------------------------------------
743!OLI_CODE       IF (zvolp >= cum_max_vol(jpl)) THEN
744!OLI_CODE          drain = zvolp - cum_max_vol(jpl) + zuny
745!OLI_CODE          zvolp = zvolp - drain
746!OLI_CODE          dvolp = drain
747!OLI_CODE          IF (zvolp < zuny) THEN
748!OLI_CODE             dvolp = dvolp + zvolp
749!OLI_CODE             zvolp = z0
750!OLI_CODE          END IF
751!OLI_CODE       END IF
752!OLI_CODE     
753!OLI_CODE       ! height and area corresponding to the remaining volume
754!OLI_CODE
755!OLI_CODE       call calc_hpond(reduced_aicen, asnon, hsnon, rhos, alfan, &
756!OLI_CODE            zvolp, cum_max_vol, hpond, m_index)
757!OLI_CODE     
758!OLI_CODE       DO n=1, m_index
759!OLI_CODE          zhpondn(n) = hpond - alfan(n) + alfan(1)
760!OLI_CODE          zapondn(n) = reduced_aicen(n)
761!OLI_CODE       END DO
762!OLI_CODE       apond = sum(zapondn(1:m_index))
763!OLI_CODE     
764!OLI_CODE       !------------------------------------------------------------------------
765!OLI_CODE       ! drainage due to ice permeability - Darcy's law
766!OLI_CODE       !------------------------------------------------------------------------
767!OLI_CODE     
768!OLI_CODE       ! sea water level
769!OLI_CODE       msno = z0
770!OLI_CODE       DO n=1,jpl
771!OLI_CODE         msno = msno + vsnon(n) * rhos(n)
772!OLI_CODE       END DO
773!OLI_CODE       floe_weight = (msno + rhoic*vice + rau0*zvolp) / aice
774!OLI_CODE       hsl_rel = floe_weight / rau0 &
775!OLI_CODE               - ((sum(betan(:)*aicen(:))/aice) + alfan(1))
776!OLI_CODE     
777!OLI_CODE       deltah = hpond - hsl_rel
778!OLI_CODE       pressure_head = grav * rau0 * max(deltah, z0)
779!OLI_CODE
780!OLI_CODE       ! drain IF ice is permeable   
781!OLI_CODE       permflag = 0
782!OLI_CODE       IF (pressure_head > z0) THEN
783!OLI_CODE       DO n = 1, jpl-1
784!OLI_CODE          IF (hicen(n) /= z0) THEN
785!OLI_CODE             CALL permeability_phi(ticen(:,n), salin(:,n), vicen(n), perm)
786!OLI_CODE             IF (perm > z0) permflag = 1
787!OLI_CODE             drain = perm*zapondn(n)*pressure_head*rdt_ice / &
788!OLI_CODE                                      (viscosity*hicen(n))
789!OLI_CODE             dvolp = dvolp + min(drain, zvolp)
790!OLI_CODE             zvolp = max(zvolp - drain, z0)
791!OLI_CODE             IF (zvolp < zuny) THEN
792!OLI_CODE                dvolp = dvolp + zvolp
793!OLI_CODE                zvolp = z0
794!OLI_CODE             END IF
795!OLI_CODE          END IF
796!OLI_CODE       END DO
797!OLI_CODE 
798!OLI_CODE       ! adjust melt pond DIMENSIONs
799!OLI_CODE       IF (permflag > 0) THEN
800!OLI_CODE          ! recompute pond depth   
801!OLI_CODE          CALL calc_hpond(reduced_aicen, asnon, hsnon, rhos, alfan, &
802!OLI_CODE                          zvolp, cum_max_vol, hpond, m_index)
803!OLI_CODE          DO n=1, m_index
804!OLI_CODE             zhpondn(n) = hpond - alfan(n) + alfan(1)
805!OLI_CODE             zapondn(n) = reduced_aicen(n)
806!OLI_CODE          END DO
807!OLI_CODE          apond = sum(zapondn(1:m_index))
808!OLI_CODE       END IF
809!OLI_CODE       END IF ! pressure_head
810!OLI_CODE
811!OLI_CODE       !------------------------------------------------------------------------
812!OLI_CODE       ! total melt pond volume in category DOes not include snow volume
813!OLI_CODE       ! snow in melt ponds is not melted
814!OLI_CODE       !------------------------------------------------------------------------
815!OLI_CODE
816!OLI_CODE       ! Calculate pond volume for lower categories
817!OLI_CODE       DO n=1,m_index-1
818!OLI_CODE          zvolpn(n) = zapondn(n) * zhpondn(n) &
819!OLI_CODE                   - (rhos(n)/rauw) * asnon(n) * min(hsnon(n), zhpondn(n))!
820!OLI_CODE       END DO
821!OLI_CODE
822!OLI_CODE       ! Calculate pond volume for highest category = remaining pond volume
823!OLI_CODE       IF (m_index == 1) zvolpn(m_index) = zvolp
824!OLI_CODE       IF (m_index > 1) THEN
825!OLI_CODE         IF (zvolp > sum(zvolpn(1:m_index-1))) THEN
826!OLI_CODE           zvolpn(m_index) = zvolp - sum(zvolpn(1:m_index-1))
827!OLI_CODE         ELSE
828!OLI_CODE           zvolpn(m_index) = z0
829!OLI_CODE           zhpondn(m_index) = z0
830!OLI_CODE           zapondn(m_index) = z0
831!OLI_CODE           ! If remaining pond volume is negative reduce pond volume of
832!OLI_CODE           ! lower category
833!OLI_CODE           IF (zvolp+zuny < sum(zvolpn(1:m_index-1))) &
834!OLI_CODE             zvolpn(m_index-1) = zvolpn(m_index-1)-sum(zvolpn(1:m_index-1))&
835!OLI_CODE                                + zvolp
836!OLI_CODE         END IF
837!OLI_CODE       END IF
838!OLI_CODE
839!OLI_CODE       DO n=1,m_index
840!OLI_CODE          IF (zapondn(n) > zuny) THEN
841!OLI_CODE              zhpondn(n) = zvolpn(n) / zapondn(n)
842!OLI_CODE          ELSE
843!OLI_CODE             dvolp = dvolp + zvolpn(n)
844!OLI_CODE             zhpondn(n) = z0
845!OLI_CODE             zvolpn(n) = z0
846!OLI_CODE             zapondn(n) = z0
847!OLI_CODE          end IF
848!OLI_CODE       END DO
849!OLI_CODE       DO n = m_index+1, jpl
850!OLI_CODE          zhpondn(n) = z0
851!OLI_CODE          zapondn(n) = z0
852!OLI_CODE          zvolpn (n) = z0
853!OLI_CODE       END DO
854!OLI_CODE
855!OLI_CODE    END SUBROUTINE pond_area
856!OLI_CODE   
857!OLI_CODE
858!OLI_CODE    SUBROUTINE calc_hpond(aicen, asnon, hsnon, rhos, alfan, &
859!OLI_CODE                          zvolp, cum_max_vol,                &
860!OLI_CODE                          hpond, m_index)
861!OLI_CODE       !!-------------------------------------------------------------------
862!OLI_CODE       !!                ***  ROUTINE calc_hpond  ***
863!OLI_CODE       !!
864!OLI_CODE       !! ** Purpose :   Compute melt pond depth
865!OLI_CODE       !!-------------------------------------------------------------------
866!OLI_CODE     
867!OLI_CODE       REAL (wp), DIMENSION(jpl), INTENT(IN) :: &
868!OLI_CODE          aicen, &
869!OLI_CODE          asnon, &
870!OLI_CODE          hsnon, &
871!OLI_CODE          rhos,  &
872!OLI_CODE          alfan, &
873!OLI_CODE          cum_max_vol
874!OLI_CODE     
875!OLI_CODE       REAL (wp), INTENT(IN) :: &
876!OLI_CODE          zvolp
877!OLI_CODE     
878!OLI_CODE       REAL (wp), INTENT(OUT) :: &
879!OLI_CODE          hpond
880!OLI_CODE     
881!OLI_CODE       INTEGER, INTENT(OUT) :: &
882!OLI_CODE          m_index
883!OLI_CODE     
884!OLI_CODE       INTEGER :: n, ns
885!OLI_CODE     
886!OLI_CODE       REAL (wp), DIMENSION(0:jpl+1) :: &
887!OLI_CODE          hitl, &
888!OLI_CODE          aicetl
889!OLI_CODE     
890!OLI_CODE       REAL (wp) :: &
891!OLI_CODE          rem_vol, &
892!OLI_CODE          area, &
893!OLI_CODE          vol, &
894!OLI_CODE          tmp, &
895!OLI_CODE          z0   = 0.0_wp,    &   
896!OLI_CODE          zuny = 1.0e-11_wp
897!OLI_CODE     
898!OLI_CODE       !----------------------------------------------------------------
899!OLI_CODE       ! hpond is zero if zvolp is zero - have we fully drained?
900!OLI_CODE       !----------------------------------------------------------------
901!OLI_CODE     
902!OLI_CODE       IF (zvolp < zuny) THEN
903!OLI_CODE        hpond = z0
904!OLI_CODE        m_index = 0
905!OLI_CODE       ELSE
906!OLI_CODE       
907!OLI_CODE        !----------------------------------------------------------------
908!OLI_CODE        ! Calculate the category where water fills up to
909!OLI_CODE        !----------------------------------------------------------------
910!OLI_CODE       
911!OLI_CODE        !----------|
912!OLI_CODE        !          |
913!OLI_CODE        !          |
914!OLI_CODE        !          |----------|                                     -- --
915!OLI_CODE        !__________|__________|_________________________________________ ^
916!OLI_CODE        !          |          |             rem_vol     ^                | Semi-filled
917!OLI_CODE        !          |          |----------|-- -- -- - ---|-- ---- -- -- --v layer
918!OLI_CODE        !          |          |          |              |
919!OLI_CODE        !          |          |          |              |hpond
920!OLI_CODE        !          |          |          |----------|   |     |-------
921!OLI_CODE        !          |          |          |          |   |     |
922!OLI_CODE        !          |          |          |          |---v-----|
923!OLI_CODE        !          |          | m_index  |          |         |
924!OLI_CODE        !-------------------------------------------------------------
925!OLI_CODE       
926!OLI_CODE        m_index = 0  ! 1:m_index categories have water in them
927!OLI_CODE        DO n = 1, jpl
928!OLI_CODE           IF (zvolp <= cum_max_vol(n)) THEN
929!OLI_CODE              m_index = n
930!OLI_CODE              IF (n == 1) THEN
931!OLI_CODE                 rem_vol = zvolp
932!OLI_CODE              ELSE
933!OLI_CODE                 rem_vol = zvolp - cum_max_vol(n-1)
934!OLI_CODE              END IF
935!OLI_CODE              exit ! to break out of the loop
936!OLI_CODE           END IF
937!OLI_CODE        END DO
938!OLI_CODE        m_index = min(jpl-1, m_index)
939!OLI_CODE       
940!OLI_CODE        !----------------------------------------------------------------
941!OLI_CODE        ! semi-filled layer may have m_index different snow in it
942!OLI_CODE        !----------------------------------------------------------------
943!OLI_CODE       
944!OLI_CODE        !-----------------------------------------------------------  ^
945!OLI_CODE        !                                                             |  alfan(m_index+1)
946!OLI_CODE        !                                                             |
947!OLI_CODE        !hitl(3)-->                             |----------|          |
948!OLI_CODE        !hitl(2)-->                |------------| * * * * *|          |
949!OLI_CODE        !hitl(1)-->     |----------|* * * * * * |* * * * * |          |
950!OLI_CODE        !hitl(0)-->-------------------------------------------------  |  ^
951!OLI_CODE        !                various snow from lower categories          |  |alfa(m_index)
952!OLI_CODE       
953!OLI_CODE        ! hitl - heights of the snow layers from thinner and current categories
954!OLI_CODE        ! aicetl - area of each snow depth in this layer
955!OLI_CODE       
956!OLI_CODE        hitl(:) = z0
957!OLI_CODE        aicetl(:) = z0
958!OLI_CODE        DO n = 1, m_index
959!OLI_CODE           hitl(n)   = max(min(hsnon(n) + alfan(n) - alfan(m_index), &
960!OLI_CODE                                  alfan(m_index+1) - alfan(m_index)), z0)
961!OLI_CODE           aicetl(n) = asnon(n)
962!OLI_CODE           
963!OLI_CODE           aicetl(0) = aicetl(0) + (aicen(n) - asnon(n))
964!OLI_CODE        END DO
965!OLI_CODE        hitl(m_index+1) = alfan(m_index+1) - alfan(m_index)
966!OLI_CODE        aicetl(m_index+1) = z0
967!OLI_CODE       
968!OLI_CODE        !----------------------------------------------------------------
969!OLI_CODE        ! reorder array according to hitl
970!OLI_CODE        ! snow heights not necessarily in height order
971!OLI_CODE        !----------------------------------------------------------------
972!OLI_CODE       
973!OLI_CODE        DO ns = 1, m_index+1
974!OLI_CODE           DO n = 0, m_index - ns + 1
975!OLI_CODE              IF (hitl(n) > hitl(n+1)) THEN ! swap order
976!OLI_CODE                 tmp = hitl(n)
977!OLI_CODE                 hitl(n) = hitl(n+1)
978!OLI_CODE                 hitl(n+1) = tmp
979!OLI_CODE                 tmp = aicetl(n)
980!OLI_CODE                 aicetl(n) = aicetl(n+1)
981!OLI_CODE                 aicetl(n+1) = tmp
982!OLI_CODE              END IF
983!OLI_CODE           END DO
984!OLI_CODE        END DO
985!OLI_CODE       
986!OLI_CODE        !----------------------------------------------------------------
987!OLI_CODE        ! divide semi-filled layer into set of sublayers each vertically homogenous
988!OLI_CODE        !----------------------------------------------------------------
989!OLI_CODE       
990!OLI_CODE        !hitl(3)----------------------------------------------------------------
991!OLI_CODE        !                                                       | * * * * * * * * 
992!OLI_CODE        !                                                       |* * * * * * * * *
993!OLI_CODE        !hitl(2)----------------------------------------------------------------
994!OLI_CODE        !                                    | * * * * * * * *  | * * * * * * * * 
995!OLI_CODE        !                                    |* * * * * * * * * |* * * * * * * * *
996!OLI_CODE        !hitl(1)----------------------------------------------------------------
997!OLI_CODE        !                 | * * * * * * * *  | * * * * * * * *  | * * * * * * * * 
998!OLI_CODE        !                 |* * * * * * * * * |* * * * * * * * * |* * * * * * * * *
999!OLI_CODE        !hitl(0)----------------------------------------------------------------
1000!OLI_CODE        !    aicetl(0)         aicetl(1)           aicetl(2)          aicetl(3)           
1001!OLI_CODE       
1002!OLI_CODE        ! move up over layers incrementing volume
1003!OLI_CODE        DO n = 1, m_index+1
1004!OLI_CODE           
1005!OLI_CODE           area = sum(aicetl(:)) - &                 ! total area of sub-layer
1006!OLI_CODE                (rhos(n)/rau0) * sum(aicetl(n:jpl+1)) ! area of sub-layer occupied by snow
1007!OLI_CODE           
1008!OLI_CODE           vol = (hitl(n) - hitl(n-1)) * area      ! thickness of sub-layer times area
1009!OLI_CODE           
1010!OLI_CODE           IF (vol >= rem_vol) THEN  ! have reached the sub-layer with the depth within
1011!OLI_CODE              hpond = rem_vol / area + hitl(n-1) + alfan(m_index) - &
1012!OLI_CODE                           alfan(1)
1013!OLI_CODE              exit
1014!OLI_CODE           ELSE  ! still in sub-layer below the sub-layer with the depth
1015!OLI_CODE              rem_vol = rem_vol - vol
1016!OLI_CODE           END IF
1017!OLI_CODE           
1018!OLI_CODE        END DO
1019!OLI_CODE       
1020!OLI_CODE       END IF
1021!OLI_CODE     
1022!OLI_CODE    END SUBROUTINE calc_hpond
1023!OLI_CODE   
1024!OLI_CODE
1025!OLI_CODE    SUBROUTINE permeability_phi(ticen, salin, vicen, perm)
1026!OLI_CODE       !!-------------------------------------------------------------------
1027!OLI_CODE       !!                ***  ROUTINE permeability_phi  ***
1028!OLI_CODE       !!
1029!OLI_CODE       !! ** Purpose :   Determine the liquid fraction of brine in the ice
1030!OLI_CODE       !!                and its permeability
1031!OLI_CODE       !!-------------------------------------------------------------------
1032!OLI_CODE       REAL (wp), DIMENSION(nlay_i), INTENT(IN) :: &
1033!OLI_CODE          ticen,  & ! energy of melting for each ice layer (J/m2)
1034!OLI_CODE          salin
1035!OLI_CODE
1036!OLI_CODE       REAL (wp), INTENT(IN) :: &
1037!OLI_CODE          vicen     ! ice volume
1038!OLI_CODE     
1039!OLI_CODE       REAL (wp), INTENT(OUT) :: &
1040!OLI_CODE          perm      ! permeability
1041!OLI_CODE
1042!OLI_CODE       REAL (wp) ::   &
1043!OLI_CODE          Sbr        ! brine salinity
1044!OLI_CODE
1045!OLI_CODE       REAL (wp), DIMENSION(nlay_i) ::   &
1046!OLI_CODE          Tin, &    ! ice temperature
1047!OLI_CODE          phi       ! liquid fraction
1048!OLI_CODE
1049!OLI_CODE       INTEGER :: k
1050!OLI_CODE     
1051!OLI_CODE       REAL (wp) :: &
1052!OLI_CODE          c2    = 2.0_wp
1053!OLI_CODE 
1054!OLI_CODE       !-----------------------------------------------------------------
1055!OLI_CODE       ! Compute ice temperatures from enthalpies using quadratic formula
1056!OLI_CODE       !-----------------------------------------------------------------
1057!OLI_CODE
1058!OLI_CODE       DO k = 1,nlay_i
1059!OLI_CODE          Tin(k) = ticen(k)
1060!OLI_CODE       END DO
1061!OLI_CODE
1062!OLI_CODE       !-----------------------------------------------------------------
1063!OLI_CODE       ! brine salinity and liquid fraction
1064!OLI_CODE       !-----------------------------------------------------------------
1065!OLI_CODE
1066!OLI_CODE       IF (maxval(Tin-rtt) <= -c2) THEN
1067!OLI_CODE
1068!OLI_CODE          DO k = 1,nlay_i
1069!OLI_CODE             Sbr = - 1.2_wp                 &
1070!OLI_CODE                   -21.8_wp     * (Tin(k)-rtt)    &
1071!OLI_CODE                   - 0.919_wp   * (Tin(k)-rtt)**2 &
1072!OLI_CODE                   - 0.01878_wp * (Tin(k)-rtt)**3
1073!OLI_CODE             phi(k) = salin(k)/Sbr ! liquid fraction
1074!OLI_CODE          END DO ! k
1075!OLI_CODE       
1076!OLI_CODE       ELSE
1077!OLI_CODE
1078!OLI_CODE          DO k = 1,nlay_i
1079!OLI_CODE             Sbr = -17.6_wp    * (Tin(k)-rtt)    &
1080!OLI_CODE                   - 0.389_wp  * (Tin(k)-rtt)**2 &
1081!OLI_CODE                   - 0.00362_wp* (Tin(k)-rtt)**3
1082!OLI_CODE             phi(k) = salin(k)/Sbr ! liquid fraction
1083!OLI_CODE          END DO
1084!OLI_CODE
1085!OLI_CODE       END IF
1086!OLI_CODE     
1087!OLI_CODE       !-----------------------------------------------------------------
1088!OLI_CODE       ! permeability
1089!OLI_CODE       !-----------------------------------------------------------------
1090!OLI_CODE
1091!OLI_CODE       perm = 3.0e-08_wp * (minval(phi))**3
1092!OLI_CODE     
1093!OLI_CODE    END SUBROUTINE permeability_phi
1094!OLI_CODE   
1095!OLI_CODE #else
1096!OLI_CODE    !!----------------------------------------------------------------------
1097!OLI_CODE    !!   Default option         Dummy Module          No LIM-3 sea-ice model
1098!OLI_CODE    !!----------------------------------------------------------------------
1099!OLI_CODE CONTAINS
1100!OLI_CODE    SUBROUTINE lim_mp_init          ! Empty routine
1101!OLI_CODE    END SUBROUTINE lim_mp_init   
1102!OLI_CODE    SUBROUTINE lim_mp               ! Empty routine
1103!OLI_CODE    END SUBROUTINE lim_mp
1104!OLI_CODE    SUBROUTINE compute_mp_topo      ! Empty routine
1105!OLI_CODE    END SUBROUTINE compute_mp_topo       
1106!OLI_CODE    SUBROUTINE pond_area            ! Empty routine
1107!OLI_CODE    END SUBROUTINE pond_area   
1108!OLI_CODE    SUBROUTINE calc_hpond           ! Empty routine
1109!OLI_CODE    END SUBROUTINE calc_hpond   
1110!OLI_CODE    SUBROUTINE permeability_phy     ! Empty routine
1111!OLI_CODE    END SUBROUTINE permeability_phy   
1112!OLI_CODE #endif
1113!OLI_CODE    !!======================================================================
1114!OLI_CODE END MODULE limmp_topo
1115!OLI_CODE
Note: See TracBrowser for help on using the repository browser.