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 @ 8085

Last change on this file since 8085 was 8085, checked in by vancop, 7 years ago
More on melt ponds in LIM
File size: 89.2 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	!! lim_mp_topo : main melt pond routine for the "topographic" formulation (FloccoFeltham)
17	!! lim_mp_area : ??? compute melt pond fraction per category
18	!! lim_mp_perm : computes permeability (should be a FUNCTION!)
19	!! calc_hpond : computes melt pond depth
20	!! permeability_phy : computes permeability
21
22	!!----------------------------------------------------------------------
23	USE phycst ! physical constants
24	USE dom_oce ! ocean space and time domain
25	! USE sbc_ice ! Surface boundary condition: ice fields
26	USE ice ! LIM-3 variables
27	USE lbclnk ! lateral boundary conditions - MPP exchanges
28	USE lib_mpp ! MPP library
29	USE wrk_nemo ! work arrays
30	USE in_out_manager ! I/O manager
31	USE lib_fortran ! glob_sum
32	USE timing ! Timing
33	! USE limcons ! conservation tests
34	! USE limctl ! control prints
35	! USE limvar
36
37	!OLI_CODE USE ice_oce, ONLY: rdt_ice, tatm_ice
38	!OLI_CODE USE phycst
39	!OLI_CODE USE dom_ice
40	!OLI_CODE USE dom_oce
41	!OLI_CODE USE sbc_oce
42	!OLI_CODE USE sbc_ice
43	!OLI_CODE USE par_ice
44	!OLI_CODE USE par_oce
45	!OLI_CODE USE ice
46	!OLI_CODE USE thd_ice
47	!OLI_CODE USE in_out_manager
48	!OLI_CODE USE lbclnk
49	!OLI_CODE USE lib_mpp
50	!OLI_CODE
51	!OLI_CODE IMPLICIT NONE
52	!OLI_CODE PRIVATE
53	!OLI_CODE
54	!OLI_CODE PUBLIC lim_mp_init
55	!OLI_CODE PUBLIC lim_mp
56
57	IMPLICIT NONE
58	PRIVATE
59
60	PUBLIC lim_mp_init ! routine called by sbcice_lim.F90
61	PUBLIC lim_mp ! routine called by sbcice_lim.F90
62
63	!! * Substitutions
64	# include "vectopt_loop_substitute.h90"
65	!!----------------------------------------------------------------------
66	!! NEMO/LIM3 4.0 , UCL - NEMO Consortium (2011)
67	!! $Id: limdyn.F90 6994 2016-10-05 13:07:10Z clem $
68	!! Software governed by the CeCILL licence (NEMOGCM/NEMO_CeCILL.txt)
69	!!----------------------------------------------------------------------
70	CONTAINS
71
72	SUBROUTINE lim_mp_init
73	!!-------------------------------------------------------------------
74	!! * ROUTINE lim_mp_init *
75	!!
76	!! ** Purpose : Physical constants and parameters linked to melt ponds
77	!! over sea ice
78	!!
79	!! ** Method : Read the namicemp namelist and check the melt pond
80	!! parameter values called at the first timestep (nit000)
81	!!
82	!! ** input : Namelist namicemp
83	!!-------------------------------------------------------------------
84	INTEGER :: ios ! Local integer output status for namelist read
85	NAMELIST/namicemp/ ln_pnd, nn_pnd_scheme, nn_pnd_cpl, rn_apnd
86	!!-------------------------------------------------------------------
87
88	REWIND( numnam_ice_ref ) ! Namelist namicemp in reference namelist : Melt Ponds
89	READ ( numnam_ice_ref, namicemp, IOSTAT = ios, ERR = 901)
90	901 IF( ios /= 0 ) CALL ctl_nam ( ios , 'namicemp in reference namelist', lwp )
91
92	REWIND( numnam_ice_cfg ) ! Namelist namicemp in configuration namelist : Melt Ponds
93	READ ( numnam_ice_cfg, namicemp, IOSTAT = ios, ERR = 902 )
94	902 IF( ios /= 0 ) CALL ctl_nam ( ios , 'namicemp in configuration namelist', lwp )
95	IF(lwm) WRITE ( numoni, namicemp )
96
97	IF(lwp) THEN ! control print
98	WRITE(numout,*)
99	WRITE(numout,*) 'lim_mp_init : ice parameters for melt ponds'
100	WRITE(numout,*) '~~~~~~~~~~~~'
101	WRITE(numout,*)' Activate melt ponds ln_pnd = ', ln_pnd
102	WRITE(numout,*)' Type of melt pond scheme =0 presc, =1 empirical = 2 topo nn_pnd_scheme = ', nn_pnd_scheme
103	WRITE(numout,*)' Type of melt pond coupling =0 pass., =1 full, =2 rad, 3=fw nn_pnd_cpl = ', nn_pnd_cpl
104	WRITE(numout,*)' Prescribed pond fraction rn_apnd = ', rn_apnd
105	ENDIF
106
107	IF ( ln_pnd == .FALSE. ) THEN
108	WRITE(numout) ' Melt ponds are not activated '
109	WRITE(numout) ' nn_pnd_scheme, nn_pnd_cpl and rn_apnd are set to zero '
110	nn_pnd_scheme = 0
111	nn_pnd_cpl = 0
112	rn_apnd = 0._wp
113	ENDIF
114	!
115	END SUBROUTINE lim_mp_init
116
117
118
119	SUBROUTINE lim_mp( kt )
120	!!-------------------------------------------------------------------
121	!! * ROUTINE lim_mp *
122	!!
123	!! ** Purpose : change melt pond fraction
124	!!
125	!! ** Method : brutal force
126	!!
127	!! ** Action : -
128	!! -
129	!!------------------------------------------------------------------------------------
130
131	INTEGER, INTENT(in) :: kt ! number of iteration
132	INTEGER :: ji, jj, jl ! dummy loop indices
133
134	! REAL(wp), POINTER, DIMENSION(:,:) :: zfsurf ! surface heat flux(obsolete, should be droped)
135	!
136	!!-------------------------------------------------------------------
137
138	IF( nn_timing == 1 ) CALL timing_start('limthd')
139
140	IF( nn_timing == 1 ) CALL timing_start('lim_mp')
141
142	SELECT CASE ( nn_pnd_scheme )
143
144	CASE (1)
145
146	CALL lim_mp_cesm ! empirical melt ponds
147
148	CASE (2)
149
150	CALL lim_mp_topo (at_i, a_i, &
151	& vt_i, v_i, v_s, t_i, s_i, a_ip_frac, &
152	& h_ip, t_su)
153
154	END SELECT
155
156	! we should probably not aggregate here since we do it in lim_var_agg
157	! before output, unless we need the total volume and faction else where
158
159	! we should also make sure a_ip and v_ip are properly updated at the end
160	! of the routine
161
162	END SUBROUTINE lim_mp
163
164
165
166	SUBROUTINE lim_mp_cesm
167	!!-------------------------------------------------------------------
168	!! * ROUTINE lim_mp_cesm *
169	!!
170	!! ** Purpose : Compute melt pond evolution
171	!!
172	!! ** Method : Empirical method. A fraction of meltwater is accumulated
173	!! in pond volume. It is then released exponentially when
174	!! surface is freezingAccumulation of meltwater and exponential release
175	!!
176	!! ** Tunable parameters :
177	!!
178	!!
179	!! ** Note : Stolen from CICE for quick test of the melt pond
180	!! radiation and freshwater interfaces
181	!!
182	!! ** References : Holland, M. M. et al (J Clim 2012)
183	!!
184	!!-------------------------------------------------------------------
185
186	INTEGER, POINTER, DIMENSION(:) :: indxi ! compressed indices for cells with ice melting
187	INTEGER, POINTER, DIMENSION(:) :: indxj !
188
189	REAL(wp), POINTER, DIMENSION(:,:) :: zwfx_mlw ! available meltwater for melt ponding
190	REAL(wp), POINTER, DIMENSION(:,:,:) :: zrfrac ! fraction of available meltwater retained for melt ponding
191
192	REAL(wp), PARAMETER :: zrmin = 0.15_wp ! minimum fraction of available meltwater retained for melt ponding
193	REAL(wp), PARAMETER :: zrmax = 0.70_wp ! maximum '' '' '' '' ''
194	REAL(wp), PARAMETER :: zrexp = 0.01_wp ! rate constant to refreeze melt ponds
195	REAL(wp), PARAMETER :: zpnd_aspect = 0.8_wp ! pond aspect ratio
196
197	REAL(wp) :: zhi ! dummy ice thickness
198	REAL(wp) :: zhs ! dummy snow depth
199	REAL(wp) :: zTp ! reference temperature
200	REAL(wp) :: zdTs ! dummy temperature difference
201	REAL(wp) :: z1_rhofw ! inverse freshwater density
202	REAL(wp) :: z1_zpnd_aspect ! inverse pond aspect ratio
203	REAL(wp) :: zvpold ! dummy pond volume
204
205	INTEGER :: ji, jj, jl, ij ! loop indices
206	INTEGER :: icells ! size of dummy array
207
208	!!-------------------------------------------------------------------
209
210	CALL wrk_alloc( jpi*jpj, indxi, indxj)
211	CALL wrk_alloc( jpi,jpj, zwfx_mlw )
212	CALL wrk_alloc( jpi,jpj,jpl, zrfrac )
213
214	z1_rhofw = 1. / rhofw
215	z1_zpnd_aspect = 1. / zpnd_aspect
216	zTp = -2.
217
218	!------------------------------------------------------------------
219	! Available melt water for melt ponding and corresponding fraction
220	!------------------------------------------------------------------
221
222	zwfx_mlw(:,:) = wfx_sum(:,:) + wfx_snw(:,:) ! available meltwater for melt ponding
223
224	zrfrac(:,:,:) = zrmin + ( zrmax - zrmin ) * a_i(:,:,:)
225
226	DO jl = 1, jpl
227
228	! v_ip(:,:,jl) ! Initialize things
229	! a_ip(:,:,jl)
230	! volpn(:,:) = hpnd(:,:) * apnd(:,:) * aicen(:,:)
231
232	!------------------------------------------------------------------------------
233	! Identify grid cells where ponds should be updated (can probably be improved)
234	!------------------------------------------------------------------------------
235
236	indxi(:) = 0
237	indxj(:) = 0
238	icells = 0
239
240	DO jj = 1, jpj
241	DO ji = 1, jpi
242	IF ( a_i(ji,jj,jl) > epsi10 ) THEN
243	icells = icells + 1
244	indxi(icells) = ji
245	indxj(icells) = jj
246	ENDIF
247	END DO ! ji
248	END DO ! jj
249
250	DO ij = 1, icells
251
252	ji = indxi(ij)
253	jj = indxj(ij)
254
255	zhi = v_i(ji,jj,jl) / a_i(ji,jj,jl)
256	zhs = v_s(ji,jj,jl) / a_i(ji,jj,jl)
257
258	IF ( zhi < rn_himin) THEN !--- Remove ponds on thin ice if ice is too thin
259
260	a_ip(ji,jj,jl) = 0._wp !--- Dump ponds
261	v_ip(ji,jj,jl) = 0._wp
262	a_ip_frac(ji,jj,jl) = 0._wp
263	h_ip(ji,jj,jl) = 0._wp
264
265	IF ( ( nn_pnd_cpl == 1 ) .OR. ( nn_pnd_cpl == 3 ) ) & !--- Give freshwater to the ocean
266	wfx_pnd(ji,jj) = wfx_pnd(ji,jj) + v_ip(ji,jj,jl)
267
268
269	ELSE !--- Update pond characteristics
270
271	!--- Add retained melt water to melt ponds
272	v_ip(ji,jj,jl) = v_ip(ji,jj,jl) + zrfrac(ji,jj,jl) * z1_rhofw * zwfx_mlw(ji,jj) * a_i(ji,jj,jl) * rdt_ice
273
274	!--- Shrink pond due to refreezing
275	zdTs = MAX ( zTp - t_su(ji,jj,jl) + rt0 , 0. )
276
277	zvpold = v_ip(ji,jj,jl)
278
279	v_ip(ji,jj,jl) = v_ip(ji,jj,jl) * EXP( zrexp * zdTs / zTp )
280
281	!--- Dump meltwater due to refreezing ( of course this is wrong
282	!--- but this parameterization is too simple )
283	IF ( ( nn_pnd_cpl == 1 ) .OR. ( nn_pnd_cpl == 3 ) ) THEN
284
285	wfx_pnd(ji,jj) = wfx_pnd(ji,jj) + rhofw * ( v_ip(ji,jj,jl) - zvpold ) * r1_rdtice
286
287	ENDIF
288
289	a_ip_frac(ji,jj,jl) = MIN( 1._wp , SQRT( v_ip(ji,jj,jl) * z1_zpnd_aspect / a_i(ji,jj,jl) ) )
290
291	h_ip(ji,jj,jl) = zpnd_aspect * a_ip_frac(ji,jj,jl)
292
293	a_ip(ji,jj,jl) = a_ip_frac(ji,jj,jl) * a_i(ji,jj,jl)
294
295	!-----------------------------------------------------------
296	! Limit pond depth
297	!-----------------------------------------------------------
298	! hpondn = min(hpondn, dpthhi*hi)
299
300	!--- Give freshwater to the ocean ?
301
302	ENDIF
303
304	END DO
305
306	END DO ! jpl
307
308	!--- Remove retained meltwater from surface fluxes
309
310	IF ( ( nn_pnd_cpl .EQ. 1 ) .OR. ( nn_pnd_cpl .EQ. 3 ) ) THEN
311
312	wfx_snw(:,:) = wfx_snw(:,:) * ( 1. - zrmin - ( zrmax - zrmin ) * at_i(:,:) )
313
314	wfx_sum(:,:) = wfx_sum(:,:) * ( 1. - zrmin - ( zrmax - zrmin ) * at_i(:,:) )
315
316	ENDIF
317
318	END SUBROUTINE lim_mp_cesm
319
320	SUBROUTINE lim_mp_topo (aice, aicen, &
321	vice, vicen, &
322	vsnon, &
323	ticen, salin, &
324	a_ip_frac, h_ip, &
325	Tsfc )
326	!!-------------------------------------------------------------------
327	!! * ROUTINE lim_mp_topo *
328	!!
329	!! ** Purpose : Compute melt pond evolution based on the ice
330	!! topography as inferred from the ice thickness
331	!! distribution.
332	!!
333	!! ** Method : This code is initially based on Flocco and Feltham
334	!! (2007) and Flocco et al. (2010). More to come...
335	!!
336	!! ** Tunable parameters :
337	!!
338	!! ** Note :
339	!!
340	!! ** References
341	!! Flocco, D. and D. L. Feltham, 2007. A continuum model of melt pond
342	!! evolution on Arctic sea ice. J. Geophys. Res. 112, C08016, doi:
343	!! 10.1029/2006JC003836.
344	!! Flocco, D., D. L. Feltham and A. K. Turner, 2010. Incorporation of
345	!! a physically based melt pond scheme into the sea ice component of a
346	!! climate model. J. Geophys. Res. 115, C08012,
347	!! doi: 10.1029/2009JC005568.
348	!!
349	!!-------------------------------------------------------------------
350
351	REAL (wp), DIMENSION (jpi,jpj), &
352	INTENT(IN) :: &
353	aice, & ! total ice area fraction
354	vice ! total ice volume (m)
355
356	REAL (wp), DIMENSION (jpi,jpj,jpl), &
357	INTENT(IN) :: &
358	aicen, & ! ice area fraction, per category
359	vsnon, & ! snow volume, per category (m)
360	vicen ! ice volume, per category (m)
361
362	REAL (wp), DIMENSION (jpi,jpj,nlay_i,jpl), &
363	INTENT(IN) :: &
364	ticen, & ! ice enthalpy, per category
365	salin
366
367	REAL (wp), DIMENSION (jpi,jpj,jpl), &
368	INTENT(INOUT) :: &
369	a_ip_frac , & ! pond area fraction of ice, per ice category
370	h_ip ! pond depth, per ice category (m)
371
372	REAL (wp), DIMENSION (jpi,jpj,jpl), &
373	INTENT(IN) :: &
374	Tsfc ! snow/sea ice surface temperature
375
376	! local variables
377	REAL (wp), DIMENSION (jpi,jpj,jpl) :: &
378	zTsfcn, & ! ice/snow surface temperature (C)
379	zvolpn, & ! pond volume per unit area, per category (m)
380	zvuin ! water-equivalent volume of ice lid on melt pond ('upper ice', m)
381
382	REAL (wp), DIMENSION (jpi,jpj,jpl) :: &
383	zapondn,& ! pond area fraction, per category
384	zhpondn ! pond depth, per category (m)
385
386	REAL (wp), DIMENSION (jpi,jpj) :: &
387	zvolp ! total volume of pond, per unit area of pond (m)
388
389	REAL (wp) :: &
390	zhi, & ! ice thickness (m)
391	zdHui, & ! change in thickness of ice lid (m)
392	zomega, & ! conduction
393	zdTice, & ! temperature difference across ice lid (C)
394	zdvice, & ! change in ice volume (m)
395	zTavg, & ! mean surface temperature across categories (C)
396	zTp, & ! pond freezing temperature (C)
397	zdvn ! change in melt pond volume for fresh water budget
398	INTEGER, DIMENSION (jpi*jpj) :: &
399	indxi, indxj ! compressed indices for cells with ice melting
400
401	INTEGER :: n,k,i,j,ij,icells,indxij ! loop indices
402
403	INTEGER, DIMENSION (jpl) :: &
404	kcells ! cells where ice lid combines with vice
405
406	INTEGER, DIMENSION (jpi*jpj,jpl) :: &
407	indxii, indxjj ! i,j indices for kcells loop
408
409	REAL (wp), parameter :: &
410	zhicemin = 0.1_wp , & ! minimum ice thickness with ponds (m)
411	zTd = 0.15_wp, & ! temperature difference for freeze-up (C)
412	zr1_rlfus = 1._wp / 0.334e+6 / 917._wp , & ! (J/m^3)
413	zmin_volp = 1.e-4_wp, & ! minimum pond volume (m)
414	z0 = 0._wp, &
415	zTimelt = 0._wp, &
416	z01 = 0.01_wp, &
417	z25 = 0.25_wp, &
418	z5 = 0.5_wp
419
420	!---------------------------------------------------------------
421	! Initialization
422	!---------------------------------------------------------------
423
424	zhpondn(:,:,:) = 0._wp
425	zapondn(:,:,:) = 0._wp
426	indxii(:,:) = 0
427	indxjj(:,:) = 0
428	kcells(:) = 0
429
430	zvolp(:,:) = wfx_sum(:,:) + wfx_snw(:,:) + vt_ip(:,:) ! Total available melt water, to be distributed as melt ponds
431	zTsfcn(:,:,:) = zTsfcn(:,:,:) - rt0 ! Convert in Celsius
432
433	! The freezing temperature for meltponds is assumed slightly below 0C,
434	! as if meltponds had a little salt in them. The salt budget is not
435	! altered for meltponds, but if it were then an actual pond freezing
436	! temperature could be computed.
437
438	! zTp = zTimelt - zTd ---> for lids
439
440	!-----------------------------------------------------------------
441	! Identify grid cells with ponds
442	!-----------------------------------------------------------------
443
444	icells = 0
445	DO j = 1, jpj
446	DO i = 1, jpi
447	zhi = z0
448	IF (aice(i,j) > epsi10 ) zhi = vice(i,j)/aice(i,j)
449	IF ( aice(i,j) > z01 .and. zhi > zhicemin .and. &
450	zvolp(i,j) > zmin_volp*aice(i,j)) THEN
451	icells = icells + 1
452	indxi(icells) = i
453	indxj(icells) = j
454	ELSE ! remove ponds on thin ice
455	!fpond(i,j) = fpond(i,j) - zvolp(i,j)
456	zvolpn(i,j,:) = z0
457	zvuin (i,j,:) = z0
458	zvolp (i,j) = z0
459	END IF
460	END DO ! i
461	END DO ! j
462
463	DO ij = 1, icells
464	i = indxi(ij)
465	j = indxj(ij)
466
467	!--------------------------------------------------------------
468	! calculate pond area and depth
469	!--------------------------------------------------------------
470	CALL lim_mp_area(aice(i,j),vice(i,j), &
471	aicen(i,j,:), vicen(i,j,:), vsnon(i,j,:), &
472	ticen(i,j,:,:), salin(i,j,:,:), &
473	zvolpn(i,j,:), zvolp(i,j), &
474	zapondn(i,j,:),zhpondn(i,j,:), zdvn)
475	! outputs are
476	! - zdvn
477	! - zvolpn
478	! - zvolp
479	! - zapondn
480	! - zhpondn
481
482	wfx_pnd(i,j) = wfx_pnd(i,j) + zdvn ! update flux from ponds to ocean
483
484	! mean surface temperature MV - why do we need that ? --> for the lid
485
486	! zTavg = z0
487	! DO n = 1, jpl
488	! zTavg = zTavg + zTsfcn(i,j,n)*aicen(i,j,n)
489	! END DO
490	! zTavg = zTavg / aice(i,j)
491
492	END DO ! ij
493
494	!---------------------------------------------------------------
495	! Update pond volume and fraction
496	!---------------------------------------------------------------
497
498	a_ip(:,:,:) = zapondn(:,:,:)
499	v_ip(:,:,:) = zapondn(:,:,:) * zhpondn(:,:,:)
500	a_ip_frac(:,:,:) = 0._wp
501	h_ip (:,:,:) = 0._wp
502
503	END SUBROUTINE lim_mp_topo
504
505	SUBROUTINE lim_mp_area(aice,vice, &
506	aicen, vicen, vsnon, ticen, &
507	salin, zvolpn, zvolp, &
508	zapondn,zhpondn,dvolp)
509
510	!!-------------------------------------------------------------------
511	!! * ROUTINE lim_mp_area *
512	!!
513	!! ** Purpose : Given the total volume of meltwater, update
514	!! pond fraction (a_ip) and depth (should be volume)
515	!!
516	!! **
517	!!
518	!!------------------------------------------------------------------
519
520	REAL (wp), INTENT(IN) :: &
521	aice,vice
522
523	REAL (wp), DIMENSION(jpl), INTENT(IN) :: &
524	aicen, vicen, vsnon
525
526	REAL (wp), DIMENSION(nlay_i,jpl), INTENT(IN) :: &
527	ticen, salin
528
529	REAL (wp), DIMENSION(jpl), INTENT(INOUT) :: &
530	zvolpn
531
532	REAL (wp), INTENT(INOUT) :: &
533	zvolp, dvolp
534
535	REAL (wp), DIMENSION(jpl), INTENT(OUT) :: &
536	zapondn, zhpondn
537
538	INTEGER :: &
539	n, ns, &
540	m_index, &
541	permflag
542
543	REAL (wp), DIMENSION(jpl) :: &
544	hicen, &
545	hsnon, &
546	asnon, &
547	alfan, &
548	betan, &
549	cum_max_vol, &
550	reduced_aicen
551
552	REAL (wp), DIMENSION(0:jpl) :: &
553	cum_max_vol_tmp
554
555	REAL (wp) :: &
556	hpond, &
557	drain, &
558	floe_weight, &
559	pressure_head, &
560	hsl_rel, &
561	deltah, &
562	perm, &
563	msno
564
565	REAL (wp), parameter :: &
566	viscosity = 1.79e-3_wp, & ! kinematic water viscosity in kg/m/s
567	z0 = 0.0_wp , &
568	c1 = 1.0_wp , &
569	p4 = 0.4_wp , &
570	p6 = 0.6_wp , &
571	epsi10 = 1.0e-11_wp
572
573	!-----------\|
574	! \|
575	! \|-----------\|
576	!___________\|___________\|______________________________________sea-level
577	! \| \|
578	! \| \|---^--------\|
579	! \| \| \| \|
580	! \| \| \| \|-----------\| \|-------
581	! \| \| \|alfan(n)\| \| \|
582	! \| \| \| \| \|--------------\|
583	! \| \| \| \| \| \|
584	!---------------------------v-------------------------------------------
585	! \| \| ^ \| \| \|
586	! \| \| \| \| \|--------------\|
587	! \| \| \|betan(n)\| \| \|
588	! \| \| \| \|-----------\| \|-------
589	! \| \| \| \|
590	! \| \|---v------- \|
591	! \| \|
592	! \|-----------\|
593	! \|
594	!-----------\|
595
596	!-------------------------------------------------------------------
597	! initialize
598	!-------------------------------------------------------------------
599
600	DO n = 1, jpl
601
602	zapondn(n) = z0
603	zhpondn(n) = z0
604
605	!----------------------------------------
606	! X) compute the effective snow fraction
607	!----------------------------------------
608	IF (aicen(n) < epsi10) THEN
609	hicen(n) = z0
610	hsnon(n) = z0
611	reduced_aicen(n) = z0
612	ELSE
613	hicen(n) = vicen(n) / aicen(n)
614	hsnon(n) = vsnon(n) / aicen(n)
615	reduced_aicen(n) = c1 ! n=jpl
616	IF (n < jpl) reduced_aicen(n) = aicen(n) &
617	* (-0.024_wp*hicen(n) + 0.832_wp)
618	asnon(n) = reduced_aicen(n) ! effective snow fraction (empirical)
619	! MV should check whether this makes sense to have the same effective snow fraction in here
620	END IF
621
622	! This choice for alfa and beta ignores hydrostatic equilibium of categories.
623	! Hydrostatic equilibium of the entire ITD is accounted for below, assuming
624	! a surface topography implied by alfa=0.6 and beta=0.4, and rigidity across all
625	! categories. alfa and beta partition the ITD - they are areas not thicknesses!
626	! Multiplying by hicen, alfan and betan (below) are thus volumes per unit area.
627	! Here, alfa = 60% of the ice area (and since hice is constant in a category,
628	! alfan = 60% of the ice volume) in each category lies above the reference line,
629	! and 40% below. Note: p6 is an arbitrary choice, but alfa+beta=1 is required.
630
631	! MV:
632	! Note that this choice is not in the original FF07 paper and has been adopted in CICE
633	! No reason why is explained in the doc, but I guess there is a reason. I'll try to investigate, maybe
634
635	! Where does that choice come from
636
637	alfan(n) = 0.6 * hicen(n)
638	betan(n) = 0.4 * hicen(n)
639
640	cum_max_vol(n) = z0
641	cum_max_vol_tmp(n) = z0
642
643	END DO ! jpl
644
645	cum_max_vol_tmp(0) = z0
646	drain = z0
647	dvolp = z0
648
649	!----------------------------------------------------------
650	! x) Drain overflow water, update pond fraction and volume
651	!----------------------------------------------------------
652
653	!--------------------------------------------------------------------------
654	! the maximum amount of water that can be contained up to each ice category
655	!--------------------------------------------------------------------------
656
657	! MV
658	! If melt ponds are too deep to be sustainable given the ITD (OVERFLOW)
659	! Then the excess volume cum_max_vol(jl) drains out of the system
660	! It should be added to wfx_pnd
661	! END MV
662
663	DO n = 1, jpl-1 ! last category can not hold any volume
664
665	IF (alfan(n+1) >= alfan(n) .and. alfan(n+1) > z0) THEN
666
667	! total volume in level including snow
668	cum_max_vol_tmp(n) = cum_max_vol_tmp(n-1) + &
669	(alfan(n+1) - alfan(n)) * sum(reduced_aicen(1:n))
670
671	! subtract snow solid volumes from lower categories in current level
672	DO ns = 1, n
673	cum_max_vol_tmp(n) = cum_max_vol_tmp(n) &
674	- rhosn/rhofw * & ! free air fraction that can be filled by water
675	asnon(ns) * & ! effective areal fraction of snow in that category
676	max(min(hsnon(ns)+alfan(ns)-alfan(n), alfan(n+1)- &
677	alfan(n)), z0)
678	END DO
679
680	ELSE ! assume higher categories unoccupied
681	cum_max_vol_tmp(n) = cum_max_vol_tmp(n-1)
682	END IF
683	!IF (cum_max_vol_tmp(n) < z0) THEN
684	! call abort_ice('negative melt pond volume')
685	!END IF
686	END DO
687	cum_max_vol_tmp(jpl) = cum_max_vol_tmp(jpl-1) ! last category holds no volume
688	cum_max_vol (1:jpl) = cum_max_vol_tmp(1:jpl)
689
690	!----------------------------------------------------------------
691	! is there more meltwater than can be held in the floe?
692	!----------------------------------------------------------------
693	IF (zvolp >= cum_max_vol(jpl)) THEN
694	drain = zvolp - cum_max_vol(jpl) + epsi10
695	zvolp = zvolp - drain ! update meltwater volume available
696	dvolp = drain ! this is the drained water
697	IF (zvolp < epsi10) THEN
698	dvolp = dvolp + zvolp
699	zvolp = z0
700	END IF
701	END IF
702
703	! height and area corresponding to the remaining volume
704
705	! call calc_hpond(reduced_aicen, asnon, hsnon, rhos, alfan, &
706	! zvolp, cum_max_vol, hpond, m_index)
707
708	DO n=1, m_index
709	zhpondn(n) = hpond - alfan(n) + alfan(1) ! here oui choulde update
710	! volume instead, no ?
711	zapondn(n) = reduced_aicen(n)
712	! in practise, pond fraction depends on the empirical snow fraction
713	! so in turn on ice thickness
714	END DO
715
716	!------------------------------------------------------------------------
717	! Drainage through brine network (permeability)
718	!------------------------------------------------------------------------
719	!!! drainage due to ice permeability - Darcy's law
720
721	! sea water level
722	msno = z0
723	DO n=1,jpl
724	msno = msno + vsnon(n) * rhosn
725	END DO
726	floe_weight = (msno + rhoicvice + rau0zvolp) / aice
727	hsl_rel = floe_weight / rau0 &
728	- ((sum(betan(:)*aicen(:))/aice) + alfan(1))
729
730	deltah = hpond - hsl_rel
731	pressure_head = grav * rau0 * max(deltah, z0)
732
733	! drain IF ice is permeable
734	permflag = 0
735	IF (pressure_head > z0) THEN
736	DO n = 1, jpl-1
737	IF (hicen(n) /= z0) THEN
738	perm = 0. ! MV ugly dummy patch
739	CALL lim_mp_perm(ticen(:,n), salin(:,n), vicen(n), perm)
740	IF (perm > z0) permflag = 1
741
742	drain = permzapondn(n)pressure_head*rdt_ice / &
743	(viscosity*hicen(n))
744	dvolp = dvolp + min(drain, zvolp)
745	zvolp = max(zvolp - drain, z0)
746	IF (zvolp < epsi10) THEN
747	dvolp = dvolp + zvolp
748	zvolp = z0
749	END IF
750	END IF
751	END DO
752
753	! adjust melt pond DIMENSIONs
754	IF (permflag > 0) THEN
755	! recompute pond depth
756	! CALL calc_hpond(reduced_aicen, asnon, hsnon, rhos, alfan, &
757	! zvolp, cum_max_vol, hpond, m_index)
758	DO n=1, m_index
759	zhpondn(n) = hpond - alfan(n) + alfan(1)
760	zapondn(n) = reduced_aicen(n)
761	END DO
762	END IF
763	END IF ! pressure_head
764
765	!-------------------------------
766	! X) remove water from the snow
767	!-------------------------------
768	!------------------------------------------------------------------------
769	! total melt pond volume in category DOes not include snow volume
770	! snow in melt ponds is not melted
771	!------------------------------------------------------------------------
772
773	! Calculate pond volume for lower categories
774	DO n=1,m_index-1
775	zvolpn(n) = zapondn(n) * zhpondn(n) & ! what is not in the snow
776	- (rhosn/rhofw) * asnon(n) * min(hsnon(n), zhpondn(n))
777	END DO
778
779	! Calculate pond volume for highest category = remaining pond volume
780
781	! The following is completely unclear to Martin at least
782	! Could we redefine properly and recode in a more readable way ?
783
784	! m_index = last category with melt pond
785
786	IF (m_index == 1) zvolpn(m_index) = zvolp ! volume of mw in 1st category is the total volume of melt water
787
788	IF (m_index > 1) THEN
789	IF (zvolp > sum(zvolpn(1:m_index-1))) THEN
790	zvolpn(m_index) = zvolp - sum(zvolpn(1:m_index-1)) !
791	ELSE
792	zvolpn(m_index) = z0
793	zhpondn(m_index) = z0
794	zapondn(m_index) = z0
795	! If remaining pond volume is negative reduce pond volume of
796	! lower category
797	IF (zvolp+epsi10 < sum(zvolpn(1:m_index-1))) &
798	zvolpn(m_index-1) = zvolpn(m_index-1)-sum(zvolpn(1:m_index-1))&
799	+ zvolp
800	END IF
801	END IF
802
803	DO n=1,m_index
804	IF (zapondn(n) > epsi10) THEN
805	zhpondn(n) = zvolpn(n) / zapondn(n)
806	ELSE
807	dvolp = dvolp + zvolpn(n)
808	zhpondn(n) = z0
809	zvolpn(n) = z0
810	zapondn(n) = z0
811	end IF
812	END DO
813	DO n = m_index+1, jpl
814	zhpondn(n) = z0
815	zapondn(n) = z0
816	zvolpn (n) = z0
817	END DO
818
819	END SUBROUTINE lim_mp_area
820
821	!OLI_CODE
822	!OLI_CODE
823	!OLI_CODE SUBROUTINE calc_hpond(aicen, asnon, hsnon, rhos, alfan, &
824	!OLI_CODE zvolp, cum_max_vol, &
825	!OLI_CODE hpond, m_index)
826	!OLI_CODE !!-------------------------------------------------------------------
827	!OLI_CODE !! * ROUTINE calc_hpond *
828	!OLI_CODE !!
829	!OLI_CODE !! ** Purpose : Compute melt pond depth
830	!OLI_CODE !!-------------------------------------------------------------------
831	!OLI_CODE
832	!OLI_CODE REAL (wp), DIMENSION(jpl), INTENT(IN) :: &
833	!OLI_CODE aicen, &
834	!OLI_CODE asnon, &
835	!OLI_CODE hsnon, &
836	!OLI_CODE rhos, &
837	!OLI_CODE alfan, &
838	!OLI_CODE cum_max_vol
839	!OLI_CODE
840	!OLI_CODE REAL (wp), INTENT(IN) :: &
841	!OLI_CODE zvolp
842	!OLI_CODE
843	!OLI_CODE REAL (wp), INTENT(OUT) :: &
844	!OLI_CODE hpond
845	!OLI_CODE
846	!OLI_CODE INTEGER, INTENT(OUT) :: &
847	!OLI_CODE m_index
848	!OLI_CODE
849	!OLI_CODE INTEGER :: n, ns
850	!OLI_CODE
851	!OLI_CODE REAL (wp), DIMENSION(0:jpl+1) :: &
852	!OLI_CODE hitl, &
853	!OLI_CODE aicetl
854	!OLI_CODE
855	!OLI_CODE REAL (wp) :: &
856	!OLI_CODE rem_vol, &
857	!OLI_CODE area, &
858	!OLI_CODE vol, &
859	!OLI_CODE tmp, &
860	!OLI_CODE z0 = 0.0_wp, &
861	!OLI_CODE epsi10 = 1.0e-11_wp
862	!OLI_CODE
863	!OLI_CODE !----------------------------------------------------------------
864	!OLI_CODE ! hpond is zero if zvolp is zero - have we fully drained?
865	!OLI_CODE !----------------------------------------------------------------
866	!OLI_CODE
867	!OLI_CODE IF (zvolp < epsi10) THEN
868	!OLI_CODE hpond = z0
869	!OLI_CODE m_index = 0
870	!OLI_CODE ELSE
871	!OLI_CODE
872	!OLI_CODE !----------------------------------------------------------------
873	!OLI_CODE ! Calculate the category where water fills up to
874	!OLI_CODE !----------------------------------------------------------------
875	!OLI_CODE
876	!OLI_CODE !----------\|
877	!OLI_CODE ! \|
878	!OLI_CODE ! \|
879	!OLI_CODE ! \|----------\| -- --
880	!OLI_CODE !__________\|__________\|_________________________________________ ^
881	!OLI_CODE ! \| \| rem_vol ^ \| Semi-filled
882	!OLI_CODE ! \| \|----------\|-- -- -- - ---\|-- ---- -- -- --v layer
883	!OLI_CODE ! \| \| \| \|
884	!OLI_CODE ! \| \| \| \|hpond
885	!OLI_CODE ! \| \| \|----------\| \| \|-------
886	!OLI_CODE ! \| \| \| \| \| \|
887	!OLI_CODE ! \| \| \| \|---v-----\|
888	!OLI_CODE ! \| \| m_index \| \| \|
889	!OLI_CODE !-------------------------------------------------------------
890	!OLI_CODE
891	!OLI_CODE m_index = 0 ! 1:m_index categories have water in them
892	!OLI_CODE DO n = 1, jpl
893	!OLI_CODE IF (zvolp <= cum_max_vol(n)) THEN
894	!OLI_CODE m_index = n
895	!OLI_CODE IF (n == 1) THEN
896	!OLI_CODE rem_vol = zvolp
897	!OLI_CODE ELSE
898	!OLI_CODE rem_vol = zvolp - cum_max_vol(n-1)
899	!OLI_CODE END IF
900	!OLI_CODE exit ! to break out of the loop
901	!OLI_CODE END IF
902	!OLI_CODE END DO
903	!OLI_CODE m_index = min(jpl-1, m_index)
904	!OLI_CODE
905	!OLI_CODE !----------------------------------------------------------------
906	!OLI_CODE ! semi-filled layer may have m_index different snow in it
907	!OLI_CODE !----------------------------------------------------------------
908	!OLI_CODE
909	!OLI_CODE !----------------------------------------------------------- ^
910	!OLI_CODE ! \| alfan(m_index+1)
911	!OLI_CODE ! \|
912	!OLI_CODE !hitl(3)--> \|----------\| \|
913	!OLI_CODE !hitl(2)--> \|------------\| * * * * *\| \|
914	!OLI_CODE !hitl(1)--> \|----------\|* * * * * * \|* * * * * \| \|
915	!OLI_CODE !hitl(0)-->------------------------------------------------- \| ^
916	!OLI_CODE ! various snow from lower categories \| \|alfa(m_index)
917	!OLI_CODE
918	!OLI_CODE ! hitl - heights of the snow layers from thinner and current categories
919	!OLI_CODE ! aicetl - area of each snow depth in this layer
920	!OLI_CODE
921	!OLI_CODE hitl(:) = z0
922	!OLI_CODE aicetl(:) = z0
923	!OLI_CODE DO n = 1, m_index
924	!OLI_CODE hitl(n) = max(min(hsnon(n) + alfan(n) - alfan(m_index), &
925	!OLI_CODE alfan(m_index+1) - alfan(m_index)), z0)
926	!OLI_CODE aicetl(n) = asnon(n)
927	!OLI_CODE
928	!OLI_CODE aicetl(0) = aicetl(0) + (aicen(n) - asnon(n))
929	!OLI_CODE END DO
930	!OLI_CODE hitl(m_index+1) = alfan(m_index+1) - alfan(m_index)
931	!OLI_CODE aicetl(m_index+1) = z0
932	!OLI_CODE
933	!OLI_CODE !----------------------------------------------------------------
934	!OLI_CODE ! reorder array according to hitl
935	!OLI_CODE ! snow heights not necessarily in height order
936	!OLI_CODE !----------------------------------------------------------------
937	!OLI_CODE
938	!OLI_CODE DO ns = 1, m_index+1
939	!OLI_CODE DO n = 0, m_index - ns + 1
940	!OLI_CODE IF (hitl(n) > hitl(n+1)) THEN ! swap order
941	!OLI_CODE tmp = hitl(n)
942	!OLI_CODE hitl(n) = hitl(n+1)
943	!OLI_CODE hitl(n+1) = tmp
944	!OLI_CODE tmp = aicetl(n)
945	!OLI_CODE aicetl(n) = aicetl(n+1)
946	!OLI_CODE aicetl(n+1) = tmp
947	!OLI_CODE END IF
948	!OLI_CODE END DO
949	!OLI_CODE END DO
950	!OLI_CODE
951	!OLI_CODE !----------------------------------------------------------------
952	!OLI_CODE ! divide semi-filled layer into set of sublayers each vertically homogenous
953	!OLI_CODE !----------------------------------------------------------------
954	!OLI_CODE
955	!OLI_CODE !hitl(3)----------------------------------------------------------------
956	!OLI_CODE ! \| * * * * * * * *
957	!OLI_CODE ! \|* * * * * * * * *
958	!OLI_CODE !hitl(2)----------------------------------------------------------------
959	!OLI_CODE ! \| * * * * * * * * \| * * * * * * * *
960	!OLI_CODE ! \|* * * * * * * * * \|* * * * * * * * *
961	!OLI_CODE !hitl(1)----------------------------------------------------------------
962	!OLI_CODE ! \| * * * * * * * * \| * * * * * * * * \| * * * * * * * *
963	!OLI_CODE ! \|* * * * * * * * * \|* * * * * * * * * \|* * * * * * * * *
964	!OLI_CODE !hitl(0)----------------------------------------------------------------
965	!OLI_CODE ! aicetl(0) aicetl(1) aicetl(2) aicetl(3)
966	!OLI_CODE
967	!OLI_CODE ! move up over layers incrementing volume
968	!OLI_CODE DO n = 1, m_index+1
969	!OLI_CODE
970	!OLI_CODE area = sum(aicetl(:)) - & ! total area of sub-layer
971	!OLI_CODE (rhos(n)/rau0) * sum(aicetl(n:jpl+1)) ! area of sub-layer occupied by snow
972	!OLI_CODE
973	!OLI_CODE vol = (hitl(n) - hitl(n-1)) * area ! thickness of sub-layer times area
974	!OLI_CODE
975	!OLI_CODE IF (vol >= rem_vol) THEN ! have reached the sub-layer with the depth within
976	!OLI_CODE hpond = rem_vol / area + hitl(n-1) + alfan(m_index) - &
977	!OLI_CODE alfan(1)
978	!OLI_CODE exit
979	!OLI_CODE ELSE ! still in sub-layer below the sub-layer with the depth
980	!OLI_CODE rem_vol = rem_vol - vol
981	!OLI_CODE END IF
982	!OLI_CODE
983	!OLI_CODE END DO
984	!OLI_CODE
985	!OLI_CODE END IF
986	!OLI_CODE
987	!OLI_CODE END SUBROUTINE calc_hpond
988	!OLI_CODE
989	!OLI_CODE
990	SUBROUTINE lim_mp_perm(ticen, salin, vicen, perm)
991	!!-------------------------------------------------------------------
992	!! * ROUTINE lim_mp_perm *
993	!!
994	!! ** Purpose : Determine the liquid fraction of brine in the ice
995	!! and its permeability
996	!!-------------------------------------------------------------------
997	REAL (wp), DIMENSION(nlay_i), INTENT(IN) :: &
998	ticen, & ! energy of melting for each ice layer (J/m2)
999	salin
1000
1001	REAL (wp), INTENT(IN) :: &
1002	vicen ! ice volume
1003
1004	REAL (wp), INTENT(OUT) :: &
1005	perm ! permeability
1006
1007	REAL (wp) :: &
1008	Sbr ! brine salinity
1009
1010	REAL (wp), DIMENSION(nlay_i) :: &
1011	Tin, & ! ice temperature
1012	phi ! liquid fraction
1013
1014	INTEGER :: k
1015
1016	REAL (wp) :: &
1017	c2 = 2.0_wp
1018
1019	!-----------------------------------------------------------------
1020	! Compute ice temperatures from enthalpies using quadratic formula
1021	!-----------------------------------------------------------------
1022
1023	DO k = 1,nlay_i
1024	Tin(k) = ticen(k)
1025	END DO
1026
1027	!-----------------------------------------------------------------
1028	! brine salinity and liquid fraction
1029	!-----------------------------------------------------------------
1030
1031	IF (maxval(Tin-rtt) <= -c2) THEN
1032
1033	DO k = 1,nlay_i
1034	Sbr = - 1.2_wp &
1035	-21.8_wp * (Tin(k)-rtt) &
1036	- 0.919_wp * (Tin(k)-rtt)**2 &
1037	- 0.01878_wp * (Tin(k)-rtt)**3
1038	phi(k) = salin(k)/Sbr ! liquid fraction
1039	END DO ! k
1040
1041	ELSE
1042
1043	DO k = 1,nlay_i
1044	Sbr = -17.6_wp * (Tin(k)-rtt) &
1045	- 0.389_wp * (Tin(k)-rtt)**2 &
1046	- 0.00362_wp* (Tin(k)-rtt)**3
1047	phi(k) = salin(k)/Sbr ! liquid fraction
1048	END DO
1049
1050	END IF
1051
1052	!-----------------------------------------------------------------
1053	! permeability
1054	!-----------------------------------------------------------------
1055
1056	perm = 3.0e-08_wp * (minval(phi))**3 ! REFERENCE PLEASE (this fucking
1057	! bastard of Golden)
1058
1059	END SUBROUTINE lim_mp_perm
1060	!OLI_CODE
1061	!OLI_CODE #else
1062	!OLI_CODE !!----------------------------------------------------------------------
1063	!OLI_CODE !! Default option Dummy Module No LIM-3 sea-ice model
1064	!OLI_CODE !!----------------------------------------------------------------------
1065	!OLI_CODE CONTAINS
1066	!OLI_CODE SUBROUTINE lim_mp_init ! Empty routine
1067	!OLI_CODE END SUBROUTINE lim_mp_init
1068	!OLI_CODE SUBROUTINE lim_mp ! Empty routine
1069	!OLI_CODE END SUBROUTINE lim_mp
1070	!OLI_CODE SUBROUTINE compute_mp_topo ! Empty routine
1071	!OLI_CODE END SUBROUTINE compute_mp_topo
1072	!OLI_CODE SUBROUTINE pond_area ! Empty routine
1073	!OLI_CODE END SUBROUTINE pond_area
1074	!OLI_CODE SUBROUTINE calc_hpond ! Empty routine
1075	!OLI_CODE END SUBROUTINE calc_hpond
1076	!OLI_CODE SUBROUTINE permeability_phy ! Empty routine
1077	!OLI_CODE END SUBROUTINE permeability_phy
1078	!OLI_CODE #endif
1079	!OLI_CODE !!======================================================================
1080	!OLI_CODE END MODULE limmp_topo
1081
1082
1083	!OLI_CODE MODULE limmp_topo
1084	!OLI_CODE !!======================================================================
1085	!OLI_CODE !! * MODULE limmp_topo *
1086	!OLI_CODE !! LIM-3 sea-ice : computation of melt ponds' properties
1087	!OLI_CODE !!======================================================================
1088	!OLI_CODE !! History : Original code by Daniela Flocco and Adrian Turner
1089	!OLI_CODE !! ! 2012-09 (O. Lecomte) Adaptation for routine inclusion in
1090	!OLI_CODE !! NEMO-LIM3.1
1091	!OLI_CODE !! ! 2016-11 (O. Lecomte, C. Rousset, M. Vancoppenolle)
1092	!OLI_CODE !! Adaptation for merge with NEMO-LIM3.6
1093	!OLI_CODE !!----------------------------------------------------------------------
1094	!OLI_CODE #if defined key_lim3
1095	!OLI_CODE !!----------------------------------------------------------------------
1096	!OLI_CODE !! 'key_lim3' LIM-3 sea-ice model
1097	!OLI_CODE !!----------------------------------------------------------------------
1098	!OLI_CODE !! lim_mp_init : melt pond properties initialization
1099	!OLI_CODE !! lim_mp : melt pond routine caller
1100	!OLI_CODE !! compute_mp_topo : Actual melt pond routine
1101	!OLI_CODE !!----------------------------------------------------------------------
1102	!OLI_CODE USE ice_oce, ONLY: rdt_ice, tatm_ice
1103	!OLI_CODE USE phycst
1104	!OLI_CODE USE dom_ice
1105	!OLI_CODE USE dom_oce
1106	!OLI_CODE USE sbc_oce
1107	!OLI_CODE USE sbc_ice
1108	!OLI_CODE USE par_ice
1109	!OLI_CODE USE par_oce
1110	!OLI_CODE USE ice
1111	!OLI_CODE USE thd_ice
1112	!OLI_CODE USE in_out_manager
1113	!OLI_CODE USE lbclnk
1114	!OLI_CODE USE lib_mpp
1115	!OLI_CODE
1116	!OLI_CODE IMPLICIT NONE
1117	!OLI_CODE PRIVATE
1118	!OLI_CODE
1119	!OLI_CODE PUBLIC lim_mp_init
1120	!OLI_CODE PUBLIC lim_mp
1121	!OLI_CODE
1122	!OLI_CODE CONTAINS
1123	!OLI_CODE
1124	!OLI_CODE SUBROUTINE lim_mp_init
1125	!OLI_CODE !!-------------------------------------------------------------------
1126	!OLI_CODE !! * ROUTINE lim_mp_init *
1127	!OLI_CODE !!
1128	!OLI_CODE !! ** Purpose : Initialize melt ponds
1129	!OLI_CODE !!-------------------------------------------------------------------
1130	!OLI_CODE a_ip_frac(:,:,:) = 0._wp
1131	!OLI_CODE a_ip(:,:,:) = 0._wp
1132	!OLI_CODE h_ip(:,:,:) = 0._wp
1133	!OLI_CODE v_ip(:,:,:) = 0._wp
1134	!OLI_CODE h_il(:,:,:) = 0._wp
1135	!OLI_CODE v_il(:,:,:) = 0._wp
1136	!OLI_CODE
1137	!OLI_CODE END SUBROUTINE lim_mp_init
1138	!OLI_CODE
1139	!OLI_CODE
1140	!OLI_CODE SUBROUTINE lim_mp
1141	!OLI_CODE !!-------------------------------------------------------------------
1142	!OLI_CODE !! * ROUTINE lim_mp *
1143	!OLI_CODE !!
1144	!OLI_CODE !! ** Purpose : Compute surface heat flux and call main melt pond
1145	!OLI_CODE !! routine
1146	!OLI_CODE !!-------------------------------------------------------------------
1147	!OLI_CODE
1148	!OLI_CODE INTEGER :: ji, jj, jl ! dummy loop indices
1149	!OLI_CODE
1150	!OLI_CODE fsurf(:,:) = 0.e0
1151	!OLI_CODE DO jl = 1, jpl
1152	!OLI_CODE DO jj = 1, jpj
1153	!OLI_CODE DO ji = 1, jpi
1154	!OLI_CODE fsurf(ji,jj) = fsurf(ji,jj) + a_i(ji,jj,jl) * &
1155	!OLI_CODE (qns_ice(ji,jj,jl) + (1.0 - izero(ji,jj,jl)) &
1156	!OLI_CODE * qsr_ice(ji,jj,jl))
1157	!OLI_CODE END DO
1158	!OLI_CODE END DO
1159	!OLI_CODE END DO
1160	!OLI_CODE
1161	!OLI_CODE CALL compute_mp_topo(at_i, a_i, &
1162	!OLI_CODE vt_i, v_i, v_s, rhosn_glo, t_i, s_i, a_ip_frac, &
1163	!OLI_CODE h_ip, h_il, t_su, tatm_ice, diag_sur_me*rdt_ice, &
1164	!OLI_CODE fsurf, fwoc)
1165	!OLI_CODE
1166	!OLI_CODE at_ip(:,:) = 0.0
1167	!OLI_CODE vt_ip(:,:) = 0.0
1168	!OLI_CODE vt_il(:,:) = 0.0
1169	!OLI_CODE DO jl = 1, jpl
1170	!OLI_CODE DO jj = 1, jpj
1171	!OLI_CODE DO ji = 1, jpi
1172	!OLI_CODE a_ip(ji,jj,jl) = MAX(0.0_wp, a_ip_frac(ji,jj,jl) * &
1173	!OLI_CODE a_i(ji,jj,jl))
1174	!OLI_CODE v_ip(ji,jj,jl) = MAX(0.0_wp, a_ip_frac(ji,jj,jl) * &
1175	!OLI_CODE a_i(ji,jj,jl) * h_ip(ji,jj,jl))
1176	!OLI_CODE v_il(ji,jj,jl) = MAX(0.0_wp, a_ip_frac(ji,jj,jl) * &
1177	!OLI_CODE a_i(ji,jj,jl) * h_il(ji,jj,jl))
1178	!OLI_CODE at_ip(ji,jj) = at_ip(ji,jj) + a_ip(ji,jj,jl)
1179	!OLI_CODE vt_ip(ji,jj) = vt_ip(ji,jj) + v_ip(ji,jj,jl)
1180	!OLI_CODE vt_il(ji,jj) = vt_il(ji,jj) + v_il(ji,jj,jl)
1181	!OLI_CODE END DO
1182	!OLI_CODE END DO
1183	!OLI_CODE END DO
1184	!OLI_CODE
1185	!OLI_CODE END SUBROUTINE lim_mp
1186	!OLI_CODE
1187	!OLI_CODE
1188	!OLI_CODE SUBROUTINE compute_mp_topo(aice, aicen, &
1189	!OLI_CODE vice, vicen, &
1190	!OLI_CODE vsnon, rhos, &
1191	!OLI_CODE ticen, salin, &
1192	!OLI_CODE a_ip_frac, h_ip, &
1193	!OLI_CODE h_il, Tsfc, &
1194	!OLI_CODE potT, meltt, &
1195	!OLI_CODE fsurf, fwoc)
1196	!OLI_CODE !!-------------------------------------------------------------------
1197	!OLI_CODE !! * ROUTINE compute_mp_topo *
1198	!OLI_CODE !!
1199	!OLI_CODE !! ** Purpose : Compute melt pond evolution based on the ice
1200	!OLI_CODE !! topography as inferred from the ice thickness
1201	!OLI_CODE !! distribution.
1202	!OLI_CODE !!
1203	!OLI_CODE !! ** Method : This code is initially based on Flocco and Feltham
1204	!OLI_CODE !! (2007) and Flocco et al. (2010). More to come...
1205	!OLI_CODE !!
1206	!OLI_CODE !! ** Tunable parameters :
1207	!OLI_CODE !!
1208	!OLI_CODE !! ** Note :
1209	!OLI_CODE !!
1210	!OLI_CODE !! ** References
1211	!OLI_CODE !! Flocco, D. and D. L. Feltham, 2007. A continuum model of melt pond
1212	!OLI_CODE !! evolution on Arctic sea ice. J. Geophys. Res. 112, C08016, doi:
1213	!OLI_CODE !! 10.1029/2006JC003836.
1214	!OLI_CODE !! Flocco, D., D. L. Feltham and A. K. Turner, 2010. Incorporation of
1215	!OLI_CODE !! a physically based melt pond scheme into the sea ice component of a
1216	!OLI_CODE !! climate model. J. Geophys. Res. 115, C08012,
1217	!OLI_CODE !! doi: 10.1029/2009JC005568.
1218	!OLI_CODE !!
1219	!OLI_CODE !!-------------------------------------------------------------------
1220	!OLI_CODE
1221	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj), &
1222	!OLI_CODE INTENT(IN) :: &
1223	!OLI_CODE aice, & ! total ice area fraction
1224	!OLI_CODE vice ! total ice volume (m)
1225	!OLI_CODE
1226	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj,jpl), &
1227	!OLI_CODE INTENT(IN) :: &
1228	!OLI_CODE aicen, & ! ice area fraction, per category
1229	!OLI_CODE vsnon, & ! snow volume, per category (m)
1230	!OLI_CODE rhos, & ! equivalent snow density, per category (kg/m^3)
1231	!OLI_CODE vicen ! ice volume, per category (m)
1232	!OLI_CODE
1233	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj,nlay_i,jpl), &
1234	!OLI_CODE INTENT(IN) :: &
1235	!OLI_CODE ticen, & ! ice enthalpy, per category
1236	!OLI_CODE salin
1237	!OLI_CODE
1238	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj,jpl), &
1239	!OLI_CODE INTENT(INOUT) :: &
1240	!OLI_CODE a_ip_frac , & ! pond area fraction of ice, per ice category
1241	!OLI_CODE h_ip , & ! pond depth, per ice category (m)
1242	!OLI_CODE h_il ! Refrozen ice lid thickness, per ice category (m)
1243	!OLI_CODE
1244	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj), &
1245	!OLI_CODE INTENT(IN) :: &
1246	!OLI_CODE potT, & ! air potential temperature
1247	!OLI_CODE meltt, & ! total surface meltwater flux
1248	!OLI_CODE fsurf ! thermodynamic heat flux at ice/snow surface (W/m^2)
1249	!OLI_CODE
1250	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj), &
1251	!OLI_CODE INTENT(INOUT) :: &
1252	!OLI_CODE fwoc ! fresh water flux to the ocean (from draining and other pond volume adjustments)
1253	!OLI_CODE ! (m)
1254	!OLI_CODE
1255	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj,jpl), &
1256	!OLI_CODE INTENT(IN) :: &
1257	!OLI_CODE Tsfc ! snow/sea ice surface temperature
1258	!OLI_CODE
1259	!OLI_CODE ! local variables
1260	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj,jpl) :: &
1261	!OLI_CODE zTsfcn, & ! ice/snow surface temperature (C)
1262	!OLI_CODE zvolpn, & ! pond volume per unit area, per category (m)
1263	!OLI_CODE zvuin ! water-equivalent volume of ice lid on melt pond ('upper ice', m)
1264	!OLI_CODE
1265	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj,jpl) :: &
1266	!OLI_CODE zapondn,& ! pond area fraction, per category
1267	!OLI_CODE zhpondn ! pond depth, per category (m)
1268	!OLI_CODE
1269	!OLI_CODE REAL (wp), DIMENSION (jpi,jpj) :: &
1270	!OLI_CODE zvolp ! total volume of pond, per unit area of pond (m)
1271	!OLI_CODE
1272	!OLI_CODE REAL (wp) :: &
1273	!OLI_CODE zhi, & ! ice thickness (m)
1274	!OLI_CODE zdHui, & ! change in thickness of ice lid (m)
1275	!OLI_CODE zomega, & ! conduction
1276	!OLI_CODE zdTice, & ! temperature difference across ice lid (C)
1277	!OLI_CODE zdvice, & ! change in ice volume (m)
1278	!OLI_CODE zTavg, & ! mean surface temperature across categories (C)
1279	!OLI_CODE zTp, & ! pond freezing temperature (C)
1280	!OLI_CODE zdvn ! change in melt pond volume for fresh water budget
1281	!OLI_CODE INTEGER, DIMENSION (jpi*jpj) :: &
1282	!OLI_CODE indxi, indxj ! compressed indices for cells with ice melting
1283	!OLI_CODE
1284	!OLI_CODE INTEGER :: n,k,i,j,ij,icells,indxij ! loop indices
1285	!OLI_CODE
1286	!OLI_CODE INTEGER, DIMENSION (jpl) :: &
1287	!OLI_CODE kcells ! cells where ice lid combines with vice
1288	!OLI_CODE
1289	!OLI_CODE INTEGER, DIMENSION (jpi*jpj,jpl) :: &
1290	!OLI_CODE indxii, indxjj ! i,j indices for kcells loop
1291	!OLI_CODE
1292	!OLI_CODE REAL (wp), parameter :: &
1293	!OLI_CODE zhicemin = 0.1_wp , & ! minimum ice thickness with ponds (m)
1294	!OLI_CODE zTd = 0.15_wp, & ! temperature difference for freeze-up (C)
1295	!OLI_CODE zr1_rlfus = 1._wp / 0.334e+6 / 917._wp , & ! (J/m^3)
1296	!OLI_CODE zmin_volp = 1.e-4_wp, & ! minimum pond volume (m)
1297	!OLI_CODE z0 = 0._wp, &
1298	!OLI_CODE zTimelt = 0._wp, &
1299	!OLI_CODE z01 = 0.01_wp, &
1300	!OLI_CODE z25 = 0.25_wp, &
1301	!OLI_CODE z5 = 0.5_wp, &
1302	!OLI_CODE epsi10 = 1.0e-11_wp
1303	!OLI_CODE !---------------------------------------------------------------
1304	!OLI_CODE ! initialize
1305	!OLI_CODE !---------------------------------------------------------------
1306	!OLI_CODE
1307	!OLI_CODE DO j = 1, jpj
1308	!OLI_CODE DO i = 1, jpi
1309	!OLI_CODE zvolp(i,j) = z0
1310	!OLI_CODE END DO
1311	!OLI_CODE END DO
1312	!OLI_CODE DO n = 1, jpl
1313	!OLI_CODE DO j = 1, jpj
1314	!OLI_CODE DO i = 1, jpi
1315	!OLI_CODE ! load tracers
1316	!OLI_CODE zvolp(i,j) = zvolp(i,j) + h_ip(i,j,n) &
1317	!OLI_CODE * a_ip_frac(i,j,n) * aicen(i,j,n)
1318	!OLI_CODE zTsfcn(i,j,n) = Tsfc(i,j,n) - rtt ! convert in Celsius - Oli
1319	!OLI_CODE zvuin (i,j,n) = h_il(i,j,n) &
1320	!OLI_CODE * a_ip_frac(i,j,n) * aicen(i,j,n)
1321	!OLI_CODE
1322	!OLI_CODE zhpondn(i,j,n) = z0 ! pond depth, per category
1323	!OLI_CODE zapondn(i,j,n) = z0 ! pond area, per category
1324	!OLI_CODE END DO
1325	!OLI_CODE END DO
1326	!OLI_CODE indxii(:,n) = 0
1327	!OLI_CODE indxjj(:,n) = 0
1328	!OLI_CODE kcells (n) = 0
1329	!OLI_CODE END DO
1330	!OLI_CODE
1331	!OLI_CODE ! The freezing temperature for meltponds is assumed slightly below 0C,
1332	!OLI_CODE ! as if meltponds had a little salt in them. The salt budget is not
1333	!OLI_CODE ! altered for meltponds, but if it were then an actual pond freezing
1334	!OLI_CODE ! temperature could be computed.
1335	!OLI_CODE
1336	!OLI_CODE zTp = zTimelt - zTd
1337	!OLI_CODE
1338	!OLI_CODE !-----------------------------------------------------------------
1339	!OLI_CODE ! Identify grid cells with ponds
1340	!OLI_CODE !-----------------------------------------------------------------
1341	!OLI_CODE
1342	!OLI_CODE icells = 0
1343	!OLI_CODE DO j = 1, jpj
1344	!OLI_CODE DO i = 1, jpi
1345	!OLI_CODE zhi = z0
1346	!OLI_CODE IF (aice(i,j) > epsi10) zhi = vice(i,j)/aice(i,j)
1347	!OLI_CODE IF ( aice(i,j) > z01 .and. zhi > zhicemin .and. &
1348	!OLI_CODE zvolp(i,j) > zmin_volp*aice(i,j)) THEN
1349	!OLI_CODE icells = icells + 1
1350	!OLI_CODE indxi(icells) = i
1351	!OLI_CODE indxj(icells) = j
1352	!OLI_CODE ELSE ! remove ponds on thin ice
1353	!OLI_CODE !fpond(i,j) = fpond(i,j) - zvolp(i,j)
1354	!OLI_CODE zvolpn(i,j,:) = z0
1355	!OLI_CODE zvuin (i,j,:) = z0
1356	!OLI_CODE zvolp (i,j) = z0
1357	!OLI_CODE END IF
1358	!OLI_CODE END DO ! i
1359	!OLI_CODE END DO ! j
1360	!OLI_CODE
1361	!OLI_CODE DO ij = 1, icells
1362	!OLI_CODE i = indxi(ij)
1363	!OLI_CODE j = indxj(ij)
1364	!OLI_CODE
1365	!OLI_CODE !--------------------------------------------------------------
1366	!OLI_CODE ! calculate pond area and depth
1367	!OLI_CODE !--------------------------------------------------------------
1368	!OLI_CODE CALL pond_area(aice(i,j),vice(i,j),rhos(i,j,:), &
1369	!OLI_CODE aicen(i,j,:), vicen(i,j,:), vsnon(i,j,:), &
1370	!OLI_CODE ticen(i,j,:,:), salin(i,j,:,:), &
1371	!OLI_CODE zvolpn(i,j,:), zvolp(i,j), &
1372	!OLI_CODE zapondn(i,j,:),zhpondn(i,j,:), zdvn)
1373	!OLI_CODE
1374	!OLI_CODE fwoc(i,j) = fwoc(i,j) + zdvn ! -> Goes to fresh water budget
1375	!OLI_CODE
1376	!OLI_CODE ! mean surface temperature
1377	!OLI_CODE zTavg = z0
1378	!OLI_CODE DO n = 1, jpl
1379	!OLI_CODE zTavg = zTavg + zTsfcn(i,j,n)*aicen(i,j,n)
1380	!OLI_CODE END DO
1381	!OLI_CODE zTavg = zTavg / aice(i,j)
1382	!OLI_CODE
1383	!OLI_CODE DO n = 1, jpl-1
1384	!OLI_CODE
1385	!OLI_CODE IF (zvuin(i,j,n) > epsi10) THEN
1386	!OLI_CODE
1387	!OLI_CODE !----------------------------------------------------------------
1388	!OLI_CODE ! melting: floating upper ice layer melts in whole or part
1389	!OLI_CODE !----------------------------------------------------------------
1390	!OLI_CODE ! IF (zTsfcn(i,j,n) > zTp) THEN
1391	!OLI_CODE IF (zTavg > zTp) THEN
1392	!OLI_CODE
1393	!OLI_CODE zdvice = min(meltt(i,j)*zapondn(i,j,n), zvuin(i,j,n))
1394	!OLI_CODE IF (zdvice > epsi10) THEN
1395	!OLI_CODE zvuin (i,j,n) = zvuin (i,j,n) - zdvice
1396	!OLI_CODE zvolpn(i,j,n) = zvolpn(i,j,n) + zdvice
1397	!OLI_CODE zvolp (i,j) = zvolp (i,j) + zdvice
1398	!OLI_CODE !fwoc(i,j) = fwoc(i,j) + zdvice
1399	!OLI_CODE
1400	!OLI_CODE IF (zvuin(i,j,n) < epsi10 .and. zvolpn(i,j,n) > puny) THEN
1401	!OLI_CODE ! ice lid melted and category is pond covered
1402	!OLI_CODE zvolpn(i,j,n) = zvolpn(i,j,n) + zvuin(i,j,n)
1403	!OLI_CODE !fwoc(i,j) = fwoc(i,j) + zvuin(i,j,n)
1404	!OLI_CODE zvuin(i,j,n) = z0
1405	!OLI_CODE END IF
1406	!OLI_CODE zhpondn(i,j,n) = zvolpn(i,j,n) / zapondn(i,j,n)
1407	!OLI_CODE END IF
1408	!OLI_CODE
1409	!OLI_CODE !----------------------------------------------------------------
1410	!OLI_CODE ! freezing: existing upper ice layer grows
1411	!OLI_CODE !----------------------------------------------------------------
1412	!OLI_CODE ELSE IF (zvolpn(i,j,n) > epsi10) THEN ! zTavg <= zTp
1413	!OLI_CODE
1414	!OLI_CODE ! dIFferential growth of base of surface floating ice layer
1415	!OLI_CODE zdTice = max(-zTavg, z0) ! > 0
1416	!OLI_CODE zomega = rcdiczdTice zr1_rlfus
1417	!OLI_CODE zdHui = sqrt(zomegardt_ice + z25(zvuin(i,j,n)/ &
1418	!OLI_CODE aicen(i,j,n))*2)- z5 zvuin(i,j,n)/aicen(i,j,n)
1419	!OLI_CODE
1420	!OLI_CODE zdvice = min(zdHui*zapondn(i,j,n), zvolpn(i,j,n))
1421	!OLI_CODE IF (zdvice > epsi10) THEN
1422	!OLI_CODE zvuin (i,j,n) = zvuin (i,j,n) + zdvice
1423	!OLI_CODE zvolpn(i,j,n) = zvolpn(i,j,n) - zdvice
1424	!OLI_CODE zvolp (i,j) = zvolp (i,j) - zdvice
1425	!OLI_CODE !fwoc(i,j) = fwoc(i,j) - zdvice
1426	!OLI_CODE zhpondn(i,j,n) = zvolpn(i,j,n) / zapondn(i,j,n)
1427	!OLI_CODE END IF
1428	!OLI_CODE
1429	!OLI_CODE END IF ! zTavg
1430	!OLI_CODE
1431	!OLI_CODE !----------------------------------------------------------------
1432	!OLI_CODE ! freezing: upper ice layer begins to form
1433	!OLI_CODE ! note: albedo does not change
1434	!OLI_CODE !----------------------------------------------------------------
1435	!OLI_CODE ELSE ! zvuin < epsi10
1436	!OLI_CODE
1437	!OLI_CODE ! thickness of newly formed ice
1438	!OLI_CODE ! the surface temperature of a meltpond is the same as that
1439	!OLI_CODE ! of the ice underneath (0C), and the thermodynamic surface
1440	!OLI_CODE ! flux is the same
1441	!OLI_CODE zdHui = max(-fsurf(i,j)rdt_icezr1_rlfus, z0)
1442	!OLI_CODE zdvice = min(zdHui*zapondn(i,j,n), zvolpn(i,j,n))
1443	!OLI_CODE IF (zdvice > epsi10) THEN
1444	!OLI_CODE zvuin (i,j,n) = zdvice
1445	!OLI_CODE zvolpn(i,j,n) = zvolpn(i,j,n) - zdvice
1446	!OLI_CODE zvolp (i,j) = zvolp (i,j) - zdvice
1447	!OLI_CODE !fwoc(i,j) = fwoc(i,j) - zdvice
1448	!OLI_CODE zhpondn(i,j,n)= zvolpn(i,j,n) / zapondn(i,j,n)
1449	!OLI_CODE END IF
1450	!OLI_CODE
1451	!OLI_CODE END IF ! zvuin
1452	!OLI_CODE
1453	!OLI_CODE END DO ! jpl
1454	!OLI_CODE
1455	!OLI_CODE END DO ! ij
1456	!OLI_CODE
1457	!OLI_CODE !---------------------------------------------------------------
1458	!OLI_CODE ! remove ice lid if there is no liquid pond
1459	!OLI_CODE ! zvuin may be nonzero on category jpl due to dynamics
1460	!OLI_CODE !---------------------------------------------------------------
1461	!OLI_CODE
1462	!OLI_CODE DO j = 1, jpj
1463	!OLI_CODE DO i = 1, jpi
1464	!OLI_CODE DO n = 1, jpl
1465	!OLI_CODE IF (aicen(i,j,n) > epsi10 .and. zvolpn(i,j,n) < puny &
1466	!OLI_CODE .and. zvuin (i,j,n) > epsi10) THEN
1467	!OLI_CODE kcells(n) = kcells(n) + 1
1468	!OLI_CODE indxij = kcells(n)
1469	!OLI_CODE indxii(indxij,n) = i
1470	!OLI_CODE indxjj(indxij,n) = j
1471	!OLI_CODE END IF
1472	!OLI_CODE END DO
1473	!OLI_CODE END DO ! i
1474	!OLI_CODE END DO ! j
1475	!OLI_CODE
1476	!OLI_CODE DO n = 1, jpl
1477	!OLI_CODE
1478	!OLI_CODE IF (kcells(n) > 0) THEN
1479	!OLI_CODE DO ij = 1, kcells(n)
1480	!OLI_CODE i = indxii(ij,n)
1481	!OLI_CODE j = indxjj(ij,n)
1482	!OLI_CODE fwoc(i,j) = fwoc(i,j) + rhoic/rauw * zvuin(i,j,n) ! Completely refrozen lid goes into ocean (to be changed)
1483	!OLI_CODE zvuin(i,j,n) = z0
1484	!OLI_CODE END DO ! ij
1485	!OLI_CODE END IF
1486	!OLI_CODE
1487	!OLI_CODE ! reload tracers
1488	!OLI_CODE DO j = 1, jpj
1489	!OLI_CODE DO i = 1, jpi
1490	!OLI_CODE IF (zapondn(i,j,n) > epsi10) THEN
1491	!OLI_CODE h_il(i,j,n) = zvuin(i,j,n) / zapondn(i,j,n)
1492	!OLI_CODE ELSE
1493	!OLI_CODE zvuin(i,j,n) = z0
1494	!OLI_CODE h_il(i,j,n) = z0
1495	!OLI_CODE END IF
1496	!OLI_CODE IF (aicen(i,j,n) > epsi10) THEN
1497	!OLI_CODE a_ip_frac(i,j,n) = zapondn(i,j,n) / aicen(i,j,n) * &
1498	!OLI_CODE (1.0_wp - MAX(z0, SIGN(1.0_wp, -zvolpn(i,j,n))))
1499	!OLI_CODE h_ip(i,j,n) = zhpondn(i,j,n)
1500	!OLI_CODE ELSE
1501	!OLI_CODE a_ip_frac(i,j,n) = z0
1502	!OLI_CODE h_ip(i,j,n) = z0
1503	!OLI_CODE h_il(i,j,n) = z0
1504	!OLI_CODE END IF
1505	!OLI_CODE END DO ! i
1506	!OLI_CODE END DO ! j
1507	!OLI_CODE
1508	!OLI_CODE END DO ! n
1509	!OLI_CODE
1510	!OLI_CODE END SUBROUTINE compute_mp_topo
1511	!OLI_CODE
1512	!OLI_CODE
1513	!OLI_CODE SUBROUTINE pond_area(aice,vice,rhos, &
1514	!OLI_CODE aicen, vicen, vsnon, ticen, &
1515	!OLI_CODE salin, zvolpn, zvolp, &
1516	!OLI_CODE zapondn,zhpondn,dvolp)
1517	!OLI_CODE !!-------------------------------------------------------------------
1518	!OLI_CODE !! * ROUTINE pond_area *
1519	!OLI_CODE !!
1520	!OLI_CODE !! ** Purpose : Compute melt pond area, depth and melting rates
1521	!OLI_CODE !!------------------------------------------------------------------
1522	!OLI_CODE REAL (wp), INTENT(IN) :: &
1523	!OLI_CODE aice,vice
1524	!OLI_CODE
1525	!OLI_CODE REAL (wp), DIMENSION(jpl), INTENT(IN) :: &
1526	!OLI_CODE aicen, vicen, vsnon, rhos
1527	!OLI_CODE
1528	!OLI_CODE REAL (wp), DIMENSION(nlay_i,jpl), INTENT(IN) :: &
1529	!OLI_CODE ticen, salin
1530	!OLI_CODE
1531	!OLI_CODE REAL (wp), DIMENSION(jpl), INTENT(INOUT) :: &
1532	!OLI_CODE zvolpn
1533	!OLI_CODE
1534	!OLI_CODE REAL (wp), INTENT(INOUT) :: &
1535	!OLI_CODE zvolp, dvolp
1536	!OLI_CODE
1537	!OLI_CODE REAL (wp), DIMENSION(jpl), INTENT(OUT) :: &
1538	!OLI_CODE zapondn, zhpondn
1539	!OLI_CODE
1540	!OLI_CODE INTEGER :: &
1541	!OLI_CODE n, ns, &
1542	!OLI_CODE m_index, &
1543	!OLI_CODE permflag
1544	!OLI_CODE
1545	!OLI_CODE REAL (wp), DIMENSION(jpl) :: &
1546	!OLI_CODE hicen, &
1547	!OLI_CODE hsnon, &
1548	!OLI_CODE asnon, &
1549	!OLI_CODE alfan, &
1550	!OLI_CODE betan, &
1551	!OLI_CODE cum_max_vol, &
1552	!OLI_CODE reduced_aicen
1553	!OLI_CODE
1554	!OLI_CODE REAL (wp), DIMENSION(0:jpl) :: &
1555	!OLI_CODE cum_max_vol_tmp
1556	!OLI_CODE
1557	!OLI_CODE REAL (wp) :: &
1558	!OLI_CODE hpond, &
1559	!OLI_CODE drain, &
1560	!OLI_CODE floe_weight, &
1561	!OLI_CODE pressure_head, &
1562	!OLI_CODE hsl_rel, &
1563	!OLI_CODE deltah, &
1564	!OLI_CODE perm, &
1565	!OLI_CODE apond, &
1566	!OLI_CODE msno
1567	!OLI_CODE
1568	!OLI_CODE REAL (wp), parameter :: &
1569	!OLI_CODE viscosity = 1.79e-3_wp, & ! kinematic water viscosity in kg/m/s
1570	!OLI_CODE z0 = 0.0_wp , &
1571	!OLI_CODE c1 = 1.0_wp , &
1572	!OLI_CODE p4 = 0.4_wp , &
1573	!OLI_CODE p6 = 0.6_wp , &
1574	!OLI_CODE epsi10 = 1.0e-11_wp
1575	!OLI_CODE
1576	!OLI_CODE !-----------\|
1577	!OLI_CODE ! \|
1578	!OLI_CODE ! \|-----------\|
1579	!OLI_CODE !___________\|___________\|______________________________________sea-level
1580	!OLI_CODE ! \| \|
1581	!OLI_CODE ! \| \|---^--------\|
1582	!OLI_CODE ! \| \| \| \|
1583	!OLI_CODE ! \| \| \| \|-----------\| \|-------
1584	!OLI_CODE ! \| \| \|alfan(n)\| \| \|
1585	!OLI_CODE ! \| \| \| \| \|--------------\|
1586	!OLI_CODE ! \| \| \| \| \| \|
1587	!OLI_CODE !---------------------------v-------------------------------------------
1588	!OLI_CODE ! \| \| ^ \| \| \|
1589	!OLI_CODE ! \| \| \| \| \|--------------\|
1590	!OLI_CODE ! \| \| \|betan(n)\| \| \|
1591	!OLI_CODE ! \| \| \| \|-----------\| \|-------
1592	!OLI_CODE ! \| \| \| \|
1593	!OLI_CODE ! \| \|---v------- \|
1594	!OLI_CODE ! \| \|
1595	!OLI_CODE ! \|-----------\|
1596	!OLI_CODE ! \|
1597	!OLI_CODE !-----------\|
1598	!OLI_CODE
1599	!OLI_CODE !-------------------------------------------------------------------
1600	!OLI_CODE ! initialize
1601	!OLI_CODE !-------------------------------------------------------------------
1602	!OLI_CODE
1603	!OLI_CODE DO n = 1, jpl
1604	!OLI_CODE
1605	!OLI_CODE zapondn(n) = z0
1606	!OLI_CODE zhpondn(n) = z0
1607	!OLI_CODE
1608	!OLI_CODE IF (aicen(n) < epsi10) THEN
1609	!OLI_CODE hicen(n) = z0
1610	!OLI_CODE hsnon(n) = z0
1611	!OLI_CODE reduced_aicen(n) = z0
1612	!OLI_CODE ELSE
1613	!OLI_CODE hicen(n) = vicen(n) / aicen(n)
1614	!OLI_CODE hsnon(n) = vsnon(n) / aicen(n)
1615	!OLI_CODE reduced_aicen(n) = c1 ! n=jpl
1616	!OLI_CODE IF (n < jpl) reduced_aicen(n) = aicen(n) &
1617	!OLI_CODE * (-0.024_wp*hicen(n) + 0.832_wp)
1618	!OLI_CODE asnon(n) = reduced_aicen(n)
1619	!OLI_CODE END IF
1620	!OLI_CODE
1621	!OLI_CODE ! This choice for alfa and beta ignores hydrostatic equilibium of categories.
1622	!OLI_CODE ! Hydrostatic equilibium of the entire ITD is accounted for below, assuming
1623	!OLI_CODE ! a surface topography implied by alfa=0.6 and beta=0.4, and rigidity across all
1624	!OLI_CODE ! categories. alfa and beta partition the ITD - they are areas not thicknesses!
1625	!OLI_CODE ! Multiplying by hicen, alfan and betan (below) are thus volumes per unit area.
1626	!OLI_CODE ! Here, alfa = 60% of the ice area (and since hice is constant in a category,
1627	!OLI_CODE ! alfan = 60% of the ice volume) in each category lies above the reference line,
1628	!OLI_CODE ! and 40% below. Note: p6 is an arbitrary choice, but alfa+beta=1 is required.
1629	!OLI_CODE
1630	!OLI_CODE alfan(n) = p6 * hicen(n)
1631	!OLI_CODE betan(n) = p4 * hicen(n)
1632	!OLI_CODE
1633	!OLI_CODE cum_max_vol(n) = z0
1634	!OLI_CODE cum_max_vol_tmp(n) = z0
1635	!OLI_CODE
1636	!OLI_CODE END DO ! jpl
1637	!OLI_CODE
1638	!OLI_CODE cum_max_vol_tmp(0) = z0
1639	!OLI_CODE drain = z0
1640	!OLI_CODE dvolp = z0
1641	!OLI_CODE
1642	!OLI_CODE !--------------------------------------------------------------------------
1643	!OLI_CODE ! the maximum amount of water that can be contained up to each ice category
1644	!OLI_CODE !--------------------------------------------------------------------------
1645	!OLI_CODE
1646	!OLI_CODE DO n = 1, jpl-1 ! last category can not hold any volume
1647	!OLI_CODE
1648	!OLI_CODE IF (alfan(n+1) >= alfan(n) .and. alfan(n+1) > z0) THEN
1649	!OLI_CODE
1650	!OLI_CODE ! total volume in level including snow
1651	!OLI_CODE cum_max_vol_tmp(n) = cum_max_vol_tmp(n-1) + &
1652	!OLI_CODE (alfan(n+1) - alfan(n)) * sum(reduced_aicen(1:n))
1653	!OLI_CODE
1654	!OLI_CODE
1655	!OLI_CODE ! subtract snow solid volumes from lower categories in current level
1656	!OLI_CODE DO ns = 1, n
1657	!OLI_CODE cum_max_vol_tmp(n) = cum_max_vol_tmp(n) &
1658	!OLI_CODE - rhos(ns)/rauw * & ! fraction of snow that is occupied by solid ??rauw
1659	!OLI_CODE asnon(ns) * & ! area of snow from that category
1660	!OLI_CODE max(min(hsnon(ns)+alfan(ns)-alfan(n), alfan(n+1)- &
1661	!OLI_CODE alfan(n)), z0)
1662	!OLI_CODE ! thickness of snow from ns layer in n layer
1663	!OLI_CODE END DO
1664	!OLI_CODE
1665	!OLI_CODE ELSE ! assume higher categories unoccupied
1666	!OLI_CODE cum_max_vol_tmp(n) = cum_max_vol_tmp(n-1)
1667	!OLI_CODE END IF
1668	!OLI_CODE !IF (cum_max_vol_tmp(n) < z0) THEN
1669	!OLI_CODE ! call abort_ice('negative melt pond volume')
1670	!OLI_CODE !END IF
1671	!OLI_CODE END DO
1672	!OLI_CODE cum_max_vol_tmp(jpl) = cum_max_vol_tmp(jpl-1) ! last category holds no volume
1673	!OLI_CODE cum_max_vol (1:jpl) = cum_max_vol_tmp(1:jpl)
1674	!OLI_CODE
1675	!OLI_CODE !----------------------------------------------------------------
1676	!OLI_CODE ! is there more meltwater than can be held in the floe?
1677	!OLI_CODE !----------------------------------------------------------------
1678	!OLI_CODE IF (zvolp >= cum_max_vol(jpl)) THEN
1679	!OLI_CODE drain = zvolp - cum_max_vol(jpl) + epsi10
1680	!OLI_CODE zvolp = zvolp - drain
1681	!OLI_CODE dvolp = drain
1682	!OLI_CODE IF (zvolp < epsi10) THEN
1683	!OLI_CODE dvolp = dvolp + zvolp
1684	!OLI_CODE zvolp = z0
1685	!OLI_CODE END IF
1686	!OLI_CODE END IF
1687	!OLI_CODE
1688	!OLI_CODE ! height and area corresponding to the remaining volume
1689	!OLI_CODE
1690	!OLI_CODE call calc_hpond(reduced_aicen, asnon, hsnon, rhos, alfan, &
1691	!OLI_CODE zvolp, cum_max_vol, hpond, m_index)
1692	!OLI_CODE
1693	!OLI_CODE DO n=1, m_index
1694	!OLI_CODE zhpondn(n) = hpond - alfan(n) + alfan(1)
1695	!OLI_CODE zapondn(n) = reduced_aicen(n)
1696	!OLI_CODE END DO
1697	!OLI_CODE apond = sum(zapondn(1:m_index))
1698	!OLI_CODE
1699	!OLI_CODE !------------------------------------------------------------------------
1700	!OLI_CODE ! drainage due to ice permeability - Darcy's law
1701	!OLI_CODE !------------------------------------------------------------------------
1702	!OLI_CODE
1703	!OLI_CODE ! sea water level
1704	!OLI_CODE msno = z0
1705	!OLI_CODE DO n=1,jpl
1706	!OLI_CODE msno = msno + vsnon(n) * rhos(n)
1707	!OLI_CODE END DO
1708	!OLI_CODE floe_weight = (msno + rhoicvice + rau0zvolp) / aice
1709	!OLI_CODE hsl_rel = floe_weight / rau0 &
1710	!OLI_CODE - ((sum(betan(:)*aicen(:))/aice) + alfan(1))
1711	!OLI_CODE
1712	!OLI_CODE deltah = hpond - hsl_rel
1713	!OLI_CODE pressure_head = grav * rau0 * max(deltah, z0)
1714	!OLI_CODE
1715	!OLI_CODE ! drain IF ice is permeable
1716	!OLI_CODE permflag = 0
1717	!OLI_CODE IF (pressure_head > z0) THEN
1718	!OLI_CODE DO n = 1, jpl-1
1719	!OLI_CODE IF (hicen(n) /= z0) THEN
1720	!OLI_CODE CALL permeability_phi(ticen(:,n), salin(:,n), vicen(n), perm)
1721	!OLI_CODE IF (perm > z0) permflag = 1
1722	!OLI_CODE drain = permzapondn(n)pressure_head*rdt_ice / &
1723	!OLI_CODE (viscosity*hicen(n))
1724	!OLI_CODE dvolp = dvolp + min(drain, zvolp)
1725	!OLI_CODE zvolp = max(zvolp - drain, z0)
1726	!OLI_CODE IF (zvolp < epsi10) THEN
1727	!OLI_CODE dvolp = dvolp + zvolp
1728	!OLI_CODE zvolp = z0
1729	!OLI_CODE END IF
1730	!OLI_CODE END IF
1731	!OLI_CODE END DO
1732	!OLI_CODE
1733	!OLI_CODE ! adjust melt pond DIMENSIONs
1734	!OLI_CODE IF (permflag > 0) THEN
1735	!OLI_CODE ! recompute pond depth
1736	!OLI_CODE CALL calc_hpond(reduced_aicen, asnon, hsnon, rhos, alfan, &
1737	!OLI_CODE zvolp, cum_max_vol, hpond, m_index)
1738	!OLI_CODE DO n=1, m_index
1739	!OLI_CODE zhpondn(n) = hpond - alfan(n) + alfan(1)
1740	!OLI_CODE zapondn(n) = reduced_aicen(n)
1741	!OLI_CODE END DO
1742	!OLI_CODE apond = sum(zapondn(1:m_index))
1743	!OLI_CODE END IF
1744	!OLI_CODE END IF ! pressure_head
1745	!OLI_CODE
1746	!OLI_CODE !------------------------------------------------------------------------
1747	!OLI_CODE ! total melt pond volume in category DOes not include snow volume
1748	!OLI_CODE ! snow in melt ponds is not melted
1749	!OLI_CODE !------------------------------------------------------------------------
1750	!OLI_CODE
1751	!OLI_CODE ! Calculate pond volume for lower categories
1752	!OLI_CODE DO n=1,m_index-1
1753	!OLI_CODE zvolpn(n) = zapondn(n) * zhpondn(n) &
1754	!OLI_CODE - (rhos(n)/rauw) * asnon(n) * min(hsnon(n), zhpondn(n))!
1755	!OLI_CODE END DO
1756	!OLI_CODE
1757	!OLI_CODE ! Calculate pond volume for highest category = remaining pond volume
1758	!OLI_CODE IF (m_index == 1) zvolpn(m_index) = zvolp
1759	!OLI_CODE IF (m_index > 1) THEN
1760	!OLI_CODE IF (zvolp > sum(zvolpn(1:m_index-1))) THEN
1761	!OLI_CODE zvolpn(m_index) = zvolp - sum(zvolpn(1:m_index-1))
1762	!OLI_CODE ELSE
1763	!OLI_CODE zvolpn(m_index) = z0
1764	!OLI_CODE zhpondn(m_index) = z0
1765	!OLI_CODE zapondn(m_index) = z0
1766	!OLI_CODE ! If remaining pond volume is negative reduce pond volume of
1767	!OLI_CODE ! lower category
1768	!OLI_CODE IF (zvolp+epsi10 < sum(zvolpn(1:m_index-1))) &
1769	!OLI_CODE zvolpn(m_index-1) = zvolpn(m_index-1)-sum(zvolpn(1:m_index-1))&
1770	!OLI_CODE + zvolp
1771	!OLI_CODE END IF
1772	!OLI_CODE END IF
1773	!OLI_CODE
1774	!OLI_CODE DO n=1,m_index
1775	!OLI_CODE IF (zapondn(n) > epsi10) THEN
1776	!OLI_CODE zhpondn(n) = zvolpn(n) / zapondn(n)
1777	!OLI_CODE ELSE
1778	!OLI_CODE dvolp = dvolp + zvolpn(n)
1779	!OLI_CODE zhpondn(n) = z0
1780	!OLI_CODE zvolpn(n) = z0
1781	!OLI_CODE zapondn(n) = z0
1782	!OLI_CODE end IF
1783	!OLI_CODE END DO
1784	!OLI_CODE DO n = m_index+1, jpl
1785	!OLI_CODE zhpondn(n) = z0
1786	!OLI_CODE zapondn(n) = z0
1787	!OLI_CODE zvolpn (n) = z0
1788	!OLI_CODE END DO
1789	!OLI_CODE
1790	!OLI_CODE END SUBROUTINE pond_area
1791	!OLI_CODE
1792	!OLI_CODE
1793	!OLI_CODE SUBROUTINE calc_hpond(aicen, asnon, hsnon, rhos, alfan, &
1794	!OLI_CODE zvolp, cum_max_vol, &
1795	!OLI_CODE hpond, m_index)
1796	!OLI_CODE !!-------------------------------------------------------------------
1797	!OLI_CODE !! * ROUTINE calc_hpond *
1798	!OLI_CODE !!
1799	!OLI_CODE !! ** Purpose : Compute melt pond depth
1800	!OLI_CODE !!-------------------------------------------------------------------
1801	!OLI_CODE
1802	!OLI_CODE REAL (wp), DIMENSION(jpl), INTENT(IN) :: &
1803	!OLI_CODE aicen, &
1804	!OLI_CODE asnon, &
1805	!OLI_CODE hsnon, &
1806	!OLI_CODE rhos, &
1807	!OLI_CODE alfan, &
1808	!OLI_CODE cum_max_vol
1809	!OLI_CODE
1810	!OLI_CODE REAL (wp), INTENT(IN) :: &
1811	!OLI_CODE zvolp
1812	!OLI_CODE
1813	!OLI_CODE REAL (wp), INTENT(OUT) :: &
1814	!OLI_CODE hpond
1815	!OLI_CODE
1816	!OLI_CODE INTEGER, INTENT(OUT) :: &
1817	!OLI_CODE m_index
1818	!OLI_CODE
1819	!OLI_CODE INTEGER :: n, ns
1820	!OLI_CODE
1821	!OLI_CODE REAL (wp), DIMENSION(0:jpl+1) :: &
1822	!OLI_CODE hitl, &
1823	!OLI_CODE aicetl
1824	!OLI_CODE
1825	!OLI_CODE REAL (wp) :: &
1826	!OLI_CODE rem_vol, &
1827	!OLI_CODE area, &
1828	!OLI_CODE vol, &
1829	!OLI_CODE tmp, &
1830	!OLI_CODE z0 = 0.0_wp, &
1831	!OLI_CODE epsi10 = 1.0e-11_wp
1832	!OLI_CODE
1833	!OLI_CODE !----------------------------------------------------------------
1834	!OLI_CODE ! hpond is zero if zvolp is zero - have we fully drained?
1835	!OLI_CODE !----------------------------------------------------------------
1836	!OLI_CODE
1837	!OLI_CODE IF (zvolp < epsi10) THEN
1838	!OLI_CODE hpond = z0
1839	!OLI_CODE m_index = 0
1840	!OLI_CODE ELSE
1841	!OLI_CODE
1842	!OLI_CODE !----------------------------------------------------------------
1843	!OLI_CODE ! Calculate the category where water fills up to
1844	!OLI_CODE !----------------------------------------------------------------
1845	!OLI_CODE
1846	!OLI_CODE !----------\|
1847	!OLI_CODE ! \|
1848	!OLI_CODE ! \|
1849	!OLI_CODE ! \|----------\| -- --
1850	!OLI_CODE !__________\|__________\|_________________________________________ ^
1851	!OLI_CODE ! \| \| rem_vol ^ \| Semi-filled
1852	!OLI_CODE ! \| \|----------\|-- -- -- - ---\|-- ---- -- -- --v layer
1853	!OLI_CODE ! \| \| \| \|
1854	!OLI_CODE ! \| \| \| \|hpond
1855	!OLI_CODE ! \| \| \|----------\| \| \|-------
1856	!OLI_CODE ! \| \| \| \| \| \|
1857	!OLI_CODE ! \| \| \| \|---v-----\|
1858	!OLI_CODE ! \| \| m_index \| \| \|
1859	!OLI_CODE !-------------------------------------------------------------
1860	!OLI_CODE
1861	!OLI_CODE m_index = 0 ! 1:m_index categories have water in them
1862	!OLI_CODE DO n = 1, jpl
1863	!OLI_CODE IF (zvolp <= cum_max_vol(n)) THEN
1864	!OLI_CODE m_index = n
1865	!OLI_CODE IF (n == 1) THEN
1866	!OLI_CODE rem_vol = zvolp
1867	!OLI_CODE ELSE
1868	!OLI_CODE rem_vol = zvolp - cum_max_vol(n-1)
1869	!OLI_CODE END IF
1870	!OLI_CODE exit ! to break out of the loop
1871	!OLI_CODE END IF
1872	!OLI_CODE END DO
1873	!OLI_CODE m_index = min(jpl-1, m_index)
1874	!OLI_CODE
1875	!OLI_CODE !----------------------------------------------------------------
1876	!OLI_CODE ! semi-filled layer may have m_index different snow in it
1877	!OLI_CODE !----------------------------------------------------------------
1878	!OLI_CODE
1879	!OLI_CODE !----------------------------------------------------------- ^
1880	!OLI_CODE ! \| alfan(m_index+1)
1881	!OLI_CODE ! \|
1882	!OLI_CODE !hitl(3)--> \|----------\| \|
1883	!OLI_CODE !hitl(2)--> \|------------\| * * * * *\| \|
1884	!OLI_CODE !hitl(1)--> \|----------\|* * * * * * \|* * * * * \| \|
1885	!OLI_CODE !hitl(0)-->------------------------------------------------- \| ^
1886	!OLI_CODE ! various snow from lower categories \| \|alfa(m_index)
1887	!OLI_CODE
1888	!OLI_CODE ! hitl - heights of the snow layers from thinner and current categories
1889	!OLI_CODE ! aicetl - area of each snow depth in this layer
1890	!OLI_CODE
1891	!OLI_CODE hitl(:) = z0
1892	!OLI_CODE aicetl(:) = z0
1893	!OLI_CODE DO n = 1, m_index
1894	!OLI_CODE hitl(n) = max(min(hsnon(n) + alfan(n) - alfan(m_index), &
1895	!OLI_CODE alfan(m_index+1) - alfan(m_index)), z0)
1896	!OLI_CODE aicetl(n) = asnon(n)
1897	!OLI_CODE
1898	!OLI_CODE aicetl(0) = aicetl(0) + (aicen(n) - asnon(n))
1899	!OLI_CODE END DO
1900	!OLI_CODE hitl(m_index+1) = alfan(m_index+1) - alfan(m_index)
1901	!OLI_CODE aicetl(m_index+1) = z0
1902	!OLI_CODE
1903	!OLI_CODE !----------------------------------------------------------------
1904	!OLI_CODE ! reorder array according to hitl
1905	!OLI_CODE ! snow heights not necessarily in height order
1906	!OLI_CODE !----------------------------------------------------------------
1907	!OLI_CODE
1908	!OLI_CODE DO ns = 1, m_index+1
1909	!OLI_CODE DO n = 0, m_index - ns + 1
1910	!OLI_CODE IF (hitl(n) > hitl(n+1)) THEN ! swap order
1911	!OLI_CODE tmp = hitl(n)
1912	!OLI_CODE hitl(n) = hitl(n+1)
1913	!OLI_CODE hitl(n+1) = tmp
1914	!OLI_CODE tmp = aicetl(n)
1915	!OLI_CODE aicetl(n) = aicetl(n+1)
1916	!OLI_CODE aicetl(n+1) = tmp
1917	!OLI_CODE END IF
1918	!OLI_CODE END DO
1919	!OLI_CODE END DO
1920	!OLI_CODE
1921	!OLI_CODE !----------------------------------------------------------------
1922	!OLI_CODE ! divide semi-filled layer into set of sublayers each vertically homogenous
1923	!OLI_CODE !----------------------------------------------------------------
1924	!OLI_CODE
1925	!OLI_CODE !hitl(3)----------------------------------------------------------------
1926	!OLI_CODE ! \| * * * * * * * *
1927	!OLI_CODE ! \|* * * * * * * * *
1928	!OLI_CODE !hitl(2)----------------------------------------------------------------
1929	!OLI_CODE ! \| * * * * * * * * \| * * * * * * * *
1930	!OLI_CODE ! \|* * * * * * * * * \|* * * * * * * * *
1931	!OLI_CODE !hitl(1)----------------------------------------------------------------
1932	!OLI_CODE ! \| * * * * * * * * \| * * * * * * * * \| * * * * * * * *
1933	!OLI_CODE ! \|* * * * * * * * * \|* * * * * * * * * \|* * * * * * * * *
1934	!OLI_CODE !hitl(0)----------------------------------------------------------------
1935	!OLI_CODE ! aicetl(0) aicetl(1) aicetl(2) aicetl(3)
1936	!OLI_CODE
1937	!OLI_CODE ! move up over layers incrementing volume
1938	!OLI_CODE DO n = 1, m_index+1
1939	!OLI_CODE
1940	!OLI_CODE area = sum(aicetl(:)) - & ! total area of sub-layer
1941	!OLI_CODE (rhos(n)/rau0) * sum(aicetl(n:jpl+1)) ! area of sub-layer occupied by snow
1942	!OLI_CODE
1943	!OLI_CODE vol = (hitl(n) - hitl(n-1)) * area ! thickness of sub-layer times area
1944	!OLI_CODE
1945	!OLI_CODE IF (vol >= rem_vol) THEN ! have reached the sub-layer with the depth within
1946	!OLI_CODE hpond = rem_vol / area + hitl(n-1) + alfan(m_index) - &
1947	!OLI_CODE alfan(1)
1948	!OLI_CODE exit
1949	!OLI_CODE ELSE ! still in sub-layer below the sub-layer with the depth
1950	!OLI_CODE rem_vol = rem_vol - vol
1951	!OLI_CODE END IF
1952	!OLI_CODE
1953	!OLI_CODE END DO
1954	!OLI_CODE
1955	!OLI_CODE END IF
1956	!OLI_CODE
1957	!OLI_CODE END SUBROUTINE calc_hpond
1958	!OLI_CODE
1959	!OLI_CODE
1960	!OLI_CODE SUBROUTINE permeability_phi(ticen, salin, vicen, perm)
1961	!OLI_CODE !!-------------------------------------------------------------------
1962	!OLI_CODE !! * ROUTINE permeability_phi *
1963	!OLI_CODE !!
1964	!OLI_CODE !! ** Purpose : Determine the liquid fraction of brine in the ice
1965	!OLI_CODE !! and its permeability
1966	!OLI_CODE !!-------------------------------------------------------------------
1967	!OLI_CODE REAL (wp), DIMENSION(nlay_i), INTENT(IN) :: &
1968	!OLI_CODE ticen, & ! energy of melting for each ice layer (J/m2)
1969	!OLI_CODE salin
1970	!OLI_CODE
1971	!OLI_CODE REAL (wp), INTENT(IN) :: &
1972	!OLI_CODE vicen ! ice volume
1973	!OLI_CODE
1974	!OLI_CODE REAL (wp), INTENT(OUT) :: &
1975	!OLI_CODE perm ! permeability
1976	!OLI_CODE
1977	!OLI_CODE REAL (wp) :: &
1978	!OLI_CODE Sbr ! brine salinity
1979	!OLI_CODE
1980	!OLI_CODE REAL (wp), DIMENSION(nlay_i) :: &
1981	!OLI_CODE Tin, & ! ice temperature
1982	!OLI_CODE phi ! liquid fraction
1983	!OLI_CODE
1984	!OLI_CODE INTEGER :: k
1985	!OLI_CODE
1986	!OLI_CODE REAL (wp) :: &
1987	!OLI_CODE c2 = 2.0_wp
1988	!OLI_CODE
1989	!OLI_CODE !-----------------------------------------------------------------
1990	!OLI_CODE ! Compute ice temperatures from enthalpies using quadratic formula
1991	!OLI_CODE !-----------------------------------------------------------------
1992	!OLI_CODE
1993	!OLI_CODE DO k = 1,nlay_i
1994	!OLI_CODE Tin(k) = ticen(k)
1995	!OLI_CODE END DO
1996	!OLI_CODE
1997	!OLI_CODE !-----------------------------------------------------------------
1998	!OLI_CODE ! brine salinity and liquid fraction
1999	!OLI_CODE !-----------------------------------------------------------------
2000	!OLI_CODE
2001	!OLI_CODE IF (maxval(Tin-rtt) <= -c2) THEN
2002	!OLI_CODE
2003	!OLI_CODE DO k = 1,nlay_i
2004	!OLI_CODE Sbr = - 1.2_wp &
2005	!OLI_CODE -21.8_wp * (Tin(k)-rtt) &
2006	!OLI_CODE - 0.919_wp * (Tin(k)-rtt)**2 &
2007	!OLI_CODE - 0.01878_wp * (Tin(k)-rtt)**3
2008	!OLI_CODE phi(k) = salin(k)/Sbr ! liquid fraction
2009	!OLI_CODE END DO ! k
2010	!OLI_CODE
2011	!OLI_CODE ELSE
2012	!OLI_CODE
2013	!OLI_CODE DO k = 1,nlay_i
2014	!OLI_CODE Sbr = -17.6_wp * (Tin(k)-rtt) &
2015	!OLI_CODE - 0.389_wp * (Tin(k)-rtt)**2 &
2016	!OLI_CODE - 0.00362_wp* (Tin(k)-rtt)**3
2017	!OLI_CODE phi(k) = salin(k)/Sbr ! liquid fraction
2018	!OLI_CODE END DO
2019	!OLI_CODE
2020	!OLI_CODE END IF
2021	!OLI_CODE
2022	!OLI_CODE !-----------------------------------------------------------------
2023	!OLI_CODE ! permeability
2024	!OLI_CODE !-----------------------------------------------------------------
2025	!OLI_CODE
2026	!OLI_CODE perm = 3.0e-08_wp * (minval(phi))**3
2027	!OLI_CODE
2028	!OLI_CODE END SUBROUTINE permeability_phi
2029	!OLI_CODE
2030	!OLI_CODE #else
2031	!OLI_CODE !!----------------------------------------------------------------------
2032	!OLI_CODE !! Default option Dummy Module No LIM-3 sea-ice model
2033	!OLI_CODE !!----------------------------------------------------------------------
2034	!OLI_CODE CONTAINS
2035	!OLI_CODE SUBROUTINE lim_mp_init ! Empty routine
2036	!OLI_CODE END SUBROUTINE lim_mp_init
2037	!OLI_CODE SUBROUTINE lim_mp ! Empty routine
2038	!OLI_CODE END SUBROUTINE lim_mp
2039	!OLI_CODE SUBROUTINE compute_mp_topo ! Empty routine
2040	!OLI_CODE END SUBROUTINE compute_mp_topo
2041	!OLI_CODE SUBROUTINE pond_area ! Empty routine
2042	!OLI_CODE END SUBROUTINE pond_area
2043	!OLI_CODE SUBROUTINE calc_hpond ! Empty routine
2044	!OLI_CODE END SUBROUTINE calc_hpond
2045	!OLI_CODE SUBROUTINE permeability_phy ! Empty routine
2046	!OLI_CODE END SUBROUTINE permeability_phy
2047	!OLI_CODE #endif
2048	!OLI_CODE !!======================================================================
2049	!OLI_CODE END MODULE limmp_topo
2050	!OLI_CODE
2051	#else
2052	!!----------------------------------------------------------------------
2053	!! Default option Empty module NO LIM sea-ice model
2054	!!----------------------------------------------------------------------
2055	CONTAINS
2056	SUBROUTINE lim_mp_init ! Empty routine
2057	END SUBROUTINE lim_mp_init
2058	SUBROUTINE lim_mp ! Empty routine
2059	END SUBROUTINE lim_mp
2060	SUBROUTINE lim_mp_topo ! Empty routine
2061	END SUBROUTINE lim_mp_topo
2062	SUBROUTINE lim_mp_cesm ! Empty routine
2063	END SUBROUTINE lim_mp_cesm
2064	SUBROUTINE lim_mp_area ! Empty routine
2065	END SUBROUTINE lim_mp_area
2066	SUBROUTINE lim_mp_perm ! Empty routine
2067	END SUBROUTINE lim_mp_perm
2068	#endif
2069
2070	!!======================================================================
2071	END MODULE limmp

Note: See TracBrowser for help on using the repository browser.

Download in other formats: