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.

limmp.F90 in branches/2016/dev_r6859_LIM3_meltponds/NEMOGCM/NEMO/LIM_SRC_3 – NEMO

Context Navigation

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, 7 years ago
Commit infrastructure for melt pond impletation
File size: 51.5 KB

Line
1	MODULE 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	!!----------------------------------------------------------------------
69	CONTAINS
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)
89	901 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 )
93	902 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	!!----------------------------------------------------------------------
110	CONTAINS
111	SUBROUTINE lim_mp_init ! Empty routine
112	END SUBROUTINE lim_mp_init
113	#endif
114
115	!!======================================================================
116	END 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 = rcdiczdTice zr1_rlfus
482	!OLI_CODE zdHui = sqrt(zomegardt_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_icezr1_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 + rhoicvice + rau0zvolp) / 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 = permzapondn(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.

Download in other formats: