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.

icbini.F90 in branches/2012/dev_r3337_NOCS10_ICB/NEMOGCM/NEMO/OPA_SRC/ICB – NEMO

Context Navigation

source: branches/2012/dev_r3337_NOCS10_ICB/NEMOGCM/NEMO/OPA_SRC/ICB/icbini.F90 @ 3370

Last change on this file since 3370 was 3370, checked in by sga, 12 years ago
NEMO branch dev_r3337_NOCS10_ICB: lots of cosmetic Gurvanistic changes (the odd space or exclamation mark!)
File size: 23.2 KB

Line
1	MODULE icbini
2
3	!!======================================================================
4	!! * MODULE icbini *
5	!! Icebergs: initialise variables for iceberg tracking
6	!!======================================================================
7	!! History : - ! 2010-01 (T. Martin & A. Adcroft) Original code
8	!! 3.3 ! 2011-03 (G. Madec) Part conversion to NEMO form ; Removal of mapping from another grid
9	!! - ! 2011-04 (S. Alderson) Split into separate modules ; Restore restart routines
10	!! - ! 2011-05 (S. Alderson) generate_test_icebergs restored ; new forcing arrays with extra halo ;
11	!! - ! north fold exchange arrays added
12	!!----------------------------------------------------------------------
13	!!----------------------------------------------------------------------
14	!! icb_init : initialise icebergs
15	!! icb_gen : generate test icebergs
16	!! icb_nam : read iceberg namelist
17	!!----------------------------------------------------------------------
18	USE dom_oce ! ocean domain
19	USE in_out_manager ! IO routines and numout in particular
20	USE lib_mpp ! mpi library and lk_mpp in particular
21	USE sbc_oce ! ocean: surface boundary condition
22	USE iom ! IOM library
23	USE fldread ! field read
24	USE lbclnk ! lateral boundary condition - MPP link
25	!
26	USE icb_oce ! define iceberg arrays
27	USE icbutl ! iceberg utility routines
28	USE icbrst ! iceberg restart routines
29	USE icbtrj ! iceberg trajectory I/O routines
30	USE icbdia ! iceberg budget routines
31
32	IMPLICIT NONE
33	PRIVATE
34
35	PUBLIC icb_init ! routine called in nemogcm.F90 module
36	PUBLIC icb_gen ! routine called in icbclv.F90 module
37
38	CHARACTER(len=100) :: cn_dir = './' ! Root directory for location of icb files
39	TYPE(FLD_N) :: sn_icb ! information about the calving file to be read
40
41	!!----------------------------------------------------------------------
42	!! NEMO/OPA 3.3 , NEMO Consortium (2011)
43	!! $Id:$
44	!! Software governed by the CeCILL licence (NEMOGCM/NEMO_CeCILL.txt)
45	!!----------------------------------------------------------------------
46	CONTAINS
47
48	INTEGER FUNCTION icb_alloc()
49	!!----------------------------------------------------------------------
50	!! * ROUTINE icb_alloc *
51	!!----------------------------------------------------------------------
52	!
53	INTEGER :: ill
54
55	icb_alloc = 0
56	ALLOCATE(berg_grid, STAT=ill)
57	icb_alloc = icb_alloc + ill
58	!
59	ALLOCATE( berg_grid%calving (jpi,jpj) , STAT=ill)
60	icb_alloc = icb_alloc + ill
61	ALLOCATE( berg_grid%calving_hflx (jpi,jpj) , STAT=ill)
62	icb_alloc = icb_alloc + ill
63	ALLOCATE( berg_grid%stored_heat (jpi,jpj) , STAT=ill)
64	icb_alloc = icb_alloc + ill
65	ALLOCATE( berg_grid%floating_melt(jpi,jpj) , STAT=ill)
66	icb_alloc = icb_alloc + ill
67	ALLOCATE( berg_grid%maxclass(jpi,jpj) , STAT=ill)
68	icb_alloc = icb_alloc + ill
69	!
70	ALLOCATE( berg_grid%stored_ice (jpi,jpj,nclasses) , STAT=ill)
71	icb_alloc = icb_alloc + ill
72	!
73	ALLOCATE( berg_grid%tmp (jpi,jpj) , STAT=ill)
74	icb_alloc = icb_alloc + ill
75	!
76	! expanded arrays for bilinear interpolation
77	ALLOCATE( uo_e(0:jpi+1,0:jpj+1) , STAT=ill)
78	icb_alloc = icb_alloc + ill
79	ALLOCATE( vo_e(0:jpi+1,0:jpj+1) , STAT=ill)
80	icb_alloc = icb_alloc + ill
81	ALLOCATE( ff_e(0:jpi+1,0:jpj+1) , STAT=ill)
82	icb_alloc = icb_alloc + ill
83	ALLOCATE( ua_e(0:jpi+1,0:jpj+1) , STAT=ill)
84	icb_alloc = icb_alloc + ill
85	ALLOCATE( va_e(0:jpi+1,0:jpj+1) , STAT=ill)
86	icb_alloc = icb_alloc + ill
87	#if defined key_lim2 \|\| defined key_lim3
88	ALLOCATE( ui_e(0:jpi+1,0:jpj+1) , STAT=ill)
89	icb_alloc = icb_alloc + ill
90	ALLOCATE( vi_e(0:jpi+1,0:jpj+1) , STAT=ill)
91	icb_alloc = icb_alloc + ill
92	#endif
93	ALLOCATE( ssh_e(0:jpi+1,0:jpj+1) , STAT=ill)
94	icb_alloc = icb_alloc + ill
95	ALLOCATE( first_width (nclasses) , STAT=ill)
96	icb_alloc = icb_alloc + ill
97	ALLOCATE( first_length (nclasses) , STAT=ill)
98	icb_alloc = icb_alloc + ill
99	ALLOCATE( src_calving(jpi,jpj) , STAT=ill)
100	icb_alloc = icb_alloc + ill
101	ALLOCATE( src_calving_hflx(jpi,jpj) , STAT=ill)
102	icb_alloc = icb_alloc + ill
103
104	ALLOCATE( nicbfldpts(jpi) , STAT=ill)
105	icb_alloc = icb_alloc + ill
106	ALLOCATE( nicbflddest(jpi) , STAT=ill)
107	icb_alloc = icb_alloc + ill
108	ALLOCATE( nicbfldproc(jpni) , STAT=ill)
109	icb_alloc = icb_alloc + ill
110
111	IF( lk_mpp ) CALL mpp_sum ( icb_alloc )
112	IF( icb_alloc > 0 ) CALL ctl_warn('icb_alloc: allocation of arrays failed')
113
114	END FUNCTION icb_alloc
115
116	SUBROUTINE icb_init( pdt, kt )
117	!!----------------------------------------------------------------------
118	!! * ROUTINE dom_init *
119	!!
120	!! ** Purpose : iceberg initialization.
121	!!
122	!! ** Method : - blah blah
123	!!----------------------------------------------------------------------
124	REAL(wp), INTENT(in) :: pdt ! iceberg time-step (rdt*nn_fsbc)
125	INTEGER , INTENT(in) :: kt ! time step number
126	!
127	INTEGER :: ji, jj, jn ! dummy loop indices
128	INTEGER :: i1, i2, i3 ! local integers
129	INTEGER :: ii, inum, ivar ! - -
130	INTEGER :: istat1, istat2, istat3 ! - -
131	CHARACTER(len=300) :: cl_sdist ! local character
132	!!----------------------------------------------------------------------
133	!
134	CALL icb_nam ! Read and print namelist parameters
135	!
136	IF( .NOT. ln_icebergs ) RETURN
137
138	! ! allocate gridded fields
139	IF( icb_alloc() /= 0 ) CALL ctl_stop( 'STOP', 'icb_alloc : unable to allocate arrays' )
140
141	! ! open ascii output file or files for iceberg status information
142	! ! note that we choose to do this on all processors since we cannot
143	! ! predict where icebergs will be ahead of time
144	CALL ctl_opn( numicb, 'icebergs.stat', 'REPLACE', 'FORMATTED', 'SEQUENTIAL', -1, numout, lwp, narea )
145
146	! set parameters (mostly from namelist)
147	!
148	berg_dt = pdt
149	first_width (:) = SQRT( rn_initial_mass(:) / ( rn_LoW_ratio * rn_rho_bergs * rn_initial_thickness(:) ) )
150	first_length(:) = rn_LoW_ratio * first_width(:)
151
152	berg_grid%calving (:,:) = 0._wp
153	berg_grid%calving_hflx (:,:) = 0._wp
154	berg_grid%stored_heat (:,:) = 0._wp
155	berg_grid%floating_melt(:,:) = 0._wp
156	berg_grid%maxclass (:,:) = nclasses
157	berg_grid%stored_ice (:,:,:) = 0._wp
158	berg_grid%tmp (:,:) = 0._wp
159	src_calving (:,:) = 0._wp
160	src_calving_hflx (:,:) = 0._wp
161
162	! ! domain for icebergs
163	IF( lk_mpp .AND. jpni == 1 ) CALL ctl_stop( 'icbinit: having ONE processor in x currently does not work' )
164	! NB: the issue here is simply that cyclic east-west boundary condition have not been coded in mpp case
165	! for the north fold we work out which points communicate by asking
166	! lbc_lnk to pass processor number (valid even in single processor case)
167	! borrow src_calving arrays for this
168	!
169	! pack i and j together using a scaling of a power of 10
170	nicbpack = 10000
171	IF( jpiglo >= nicbpack ) CALL ctl_stop( 'icbini: processor index packing failure' )
172	nicbfldproc(:) = -1
173
174	DO jj = 1, jpj
175	DO ji = 1, jpi
176	src_calving_hflx(ji,jj) = narea
177	src_calving (ji,jj) = nicbpack * (njmpp+jj-1) + nimpp+ji-1 !!gm use here mjg(jj) and mig(ji)...
178	!!gm src_calving (ji,jj) = nicbpack * mjg(jj) + mig(ji)
179	END DO
180	END DO
181	CALL lbc_lnk( src_calving_hflx, 'T', 1._wp )
182	CALL lbc_lnk( src_calving , 'T', 1._wp )
183
184	! work out interior of processor from exchange array
185	! first entry with narea for this processor is left hand interior index
186	! last entry is right hand interior index
187	jj = jpj/2
188	nicbdi = -1
189	nicbei = -1
190	DO ji = 1, jpi
191	i3 = INT( src_calving(ji,jj) )
192	i2 = INT( i3/nicbpack )
193	i1 = i3 - i2*nicbpack
194	i3 = INT( src_calving_hflx(ji,jj) )
195	IF( i1 == nimpp+ji-1 .AND. i3 == narea ) THEN
196	IF( nicbdi < 0 ) THEN ; nicbdi = ji
197	ELSE ; nicbei = ji
198	ENDIF
199	ENDIF
200	END DO
201	!
202	! repeat for j direction
203	ji = jpi/2
204	nicbdj = -1
205	nicbej = -1
206	DO jj = 1, jpj
207	i3 = INT( src_calving(ji,jj) )
208	i2 = INT( i3/nicbpack )
209	i1 = i3 - i2*nicbpack
210	i3 = INT( src_calving_hflx(ji,jj) )
211	IF( i2 == njmpp+jj-1 .AND. i3 == narea ) THEN
212	IF( nicbdj < 0 ) THEN ; nicbdj = jj
213	ELSE ; nicbej = jj
214	ENDIF
215	ENDIF
216	END DO
217	!
218	! special for east-west boundary exchange we save the destination index
219	i1 = MAX( nicbdi-1, 1)
220	i3 = INT( src_calving(i1,jpj/2) )
221	jj = INT( i3/nicbpack )
222	ricb_left = REAL( i3 - nicbpack*jj, wp )
223	i1 = MIN( nicbei+1, jpi )
224	i3 = INT( src_calving(i1,jpj/2) )
225	jj = INT( i3/nicbpack )
226	ricb_right = REAL( i3 - nicbpack*jj, wp )
227
228	! north fold
229	IF( npolj > 0 ) THEN
230	!
231	! icebergs in row nicbej+1 get passed across fold
232	nicbfldpts(:) = INT( src_calving(:,nicbej+1) )
233	nicbflddest(:) = INT( src_calving_hflx(:,nicbej+1) )
234	!
235	! work out list of unique processors to talk to
236	DO ji = nicbdi, nicbei
237	ii = nicbflddest(ji)
238	DO jn = 1, jpni
239	IF( nicbfldproc(jn) == -1 ) THEN
240	nicbfldproc(jn) = ii
241	EXIT !!gm EXIT should be avoided: use DO WHILE expression instead
242	ENDIF
243	IF( nicbfldproc(jn) == ii ) EXIT
244	END DO
245	END DO
246	ENDIF
247	!
248	IF( nn_verbose_level > 0) THEN
249	WRITE(numicb,*) 'processor ', narea
250	WRITE(numicb,*) 'jpi, jpj ', jpi, jpj
251	WRITE(numicb,*) 'nldi, nlei ', nldi, nlei
252	WRITE(numicb,*) 'nldj, nlej ', nldj, nlej
253	WRITE(numicb,*) 'berg i interior ', nicbdi, nicbei
254	WRITE(numicb,*) 'berg j interior ', nicbdj, nicbej
255	WRITE(numicb,*) 'berg left ', ricb_left
256	WRITE(numicb,*) 'berg right ', ricb_right
257	jj = jpj/2
258	WRITE(numicb,*) "central j line:"
259	WRITE(numicb,*) "i processor"
260	WRITE(numicb,*) (INT(src_calving_hflx(ji,jj)), ji=1,jpi)
261	WRITE(numicb,*) "i point"
262	WRITE(numicb,*) (INT(src_calving(ji,jj)), ji=1,jpi)
263	ji = jpi/2
264	WRITE(numicb,*) "central i line:"
265	WRITE(numicb,*) "j processor"
266	WRITE(numicb,*) (INT(src_calving_hflx(ji,jj)), jj=1,jpj)
267	WRITE(numicb,*) "j point"
268	WRITE(numicb,*) (INT(src_calving(ji,jj)), jj=1,jpj)
269	IF( npolj > 0 ) THEN
270	WRITE(numicb,*) 'north fold destination points '
271	WRITE(numicb,*) nicbfldpts
272	WRITE(numicb,*) 'north fold destination procs '
273	WRITE(numicb,*) nicbflddest
274	ENDIF
275	CALL flush(numicb)
276	ENDIF
277
278	src_calving (:,:) = 0._wp
279	src_calving_hflx(:,:) = 0._wp
280
281	! assign each new iceberg with a unique number constructed from the processor number
282	! and incremented by the total number of processors
283	num_bergs(:) = 0
284	num_bergs(1) = narea - jpnij
285
286	! when not generating test icebergs we need to setup calving file
287	IF( nn_test_icebergs < 0 ) THEN
288	!
289	! maximum distribution class array does not change in time so read it once
290	cl_sdist = TRIM( cn_dir )//TRIM( sn_icb%clname )
291	CALL iom_open ( cl_sdist, inum ) ! open file
292	ivar = iom_varid( inum, 'maxclass', ldstop=.FALSE. )
293	IF( ivar > 0 ) THEN
294	CALL iom_get ( inum, jpdom_data, 'maxclass', src_calving ) ! read the max distribution array
295	berg_grid%maxclass(:,:) = INT( src_calving )
296	src_calving(:,:) = 0._wp
297	ENDIF
298	CALL iom_close( inum ) ! close file
299	!
300	WRITE(numicb,*)
301	WRITE(numicb,*) ' calving read in a file'
302	ALLOCATE( sf_icb(1), STAT=istat1 ) ! Create sf_icb structure (calving)
303	ALLOCATE( sf_icb(1)%fnow(jpi,jpj,1), STAT=istat2 )
304	ALLOCATE( sf_icb(1)%fdta(jpi,jpj,1,2), STAT=istat3 )
305	IF( istat1+istat2+istat3 > 0 ) THEN
306	CALL ctl_stop( 'sbc_icb: unable to allocate sf_icb structure' ) ; RETURN
307	ENDIF
308	! ! fill sf_icb with the namelist (sn_icb) and control print
309	CALL fld_fill( sf_icb, (/ sn_icb /), cn_dir, 'icb_init', 'read calving data', 'namicb' )
310	!
311	ENDIF
312
313	IF( .NOT.ln_rstart ) THEN
314	IF( nn_test_icebergs > 0 ) CALL icb_gen()
315	ELSE
316	IF( nn_test_icebergs > 0 ) THEN
317	CALL icb_gen()
318	ELSE
319	CALL icebergs_read_restart()
320	l_restarted_bergs = .TRUE.
321	ENDIF
322	ENDIF
323	!
324	IF( nn_sample_rate .GT. 0 ) CALL traj_init( nitend )
325	!
326	CALL icb_budget_init()
327	!
328	IF( nn_verbose_level >= 2 ) CALL print_bergs('icb_init, initial status', nit000-1)
329	!
330	END SUBROUTINE icb_init
331
332	SUBROUTINE icb_gen()
333	!!----------------------------------------------------------------------
334	!! * ROUTINE icb_gen *
335	!!
336	!! ** Purpose : iceberg generation
337	!!
338	!! ** Method : - blah blah
339	!!----------------------------------------------------------------------
340	INTEGER :: ji, jj, ibergs
341	TYPE(iceberg) :: localberg ! NOT a pointer but an actual local variable
342	TYPE(point) :: localpt
343	INTEGER :: iyr, imon, iday, ihr, imin, isec
344	INTEGER :: iberg
345	!!----------------------------------------------------------------------
346
347	! For convenience
348	iberg = nn_test_icebergs
349
350	! call get_date(Time, iyr, imon, iday, ihr, imin, isec)
351	! Convert nemo time variables from dom_oce into local versions
352	iyr = nyear
353	imon = nmonth
354	iday = nday
355	ihr = INT(nsec_day/3600)
356	imin = INT((nsec_day-ihr*3600)/60)
357	isec = nsec_day - ihr3600 - imin60
358
359	! no overlap for icebergs since we want only one instance of each across the whole domain
360	! so restrict area of interest
361	! use tmask here because tmask_i has been doctored on one side of the north fold line
362
363	DO jj = nicbdj, nicbej
364	DO ji = nicbdi, nicbei
365	IF( tmask(ji,jj,1) > 0._wp .AND. &
366	rn_test_box(1) < glamt(ji,jj) .AND. glamt(ji,jj) < rn_test_box(2) .AND. &
367	rn_test_box(3) < gphit(ji,jj) .AND. gphit(ji,jj) < rn_test_box(4) ) THEN
368	localberg%mass_scaling = rn_mass_scaling(iberg)
369	localpt%xi = REAL( nimpp+ji-1, wp )
370	localpt%yj = REAL( njmpp+jj-1, wp )
371	localpt%lon = bilin(glamt, localpt%xi, localpt%yj, 'T', 0, 0 )
372	localpt%lat = bilin(gphit, localpt%xi, localpt%yj, 'T', 0, 0 )
373	localpt%mass = rn_initial_mass (iberg)
374	localpt%thickness = rn_initial_thickness(iberg)
375	localpt%width = first_width (iberg)
376	localpt%length = first_length(iberg)
377	localpt%year = iyr
378	localpt%day = FLOAT(iday)+(FLOAT(ihr)+FLOAT(imin)/60._wp)/24._wp
379	localpt%mass_of_bits = 0._wp
380	localpt%heat_density = 0._wp
381	localpt%uvel = 0._wp
382	localpt%vvel = 0._wp
383	CALL increment_kounter()
384	localberg%number(:) = num_bergs(:)
385	call add_new_berg_to_list(localberg, localpt)
386	ENDIF
387	END DO
388	END DO
389	!
390	ibergs = count_bergs()
391	IF( lk_mpp ) CALL mpp_sum(ibergs)
392	WRITE(numicb,'(a,i6,a)') 'diamonds, icb_gen: ',ibergs,' were generated'
393	!
394	END SUBROUTINE icb_gen
395
396	SUBROUTINE icb_nam
397	!!----------------------------------------------------------------------
398	!! * ROUTINE icb_nam *
399	!!
400	!! ** Purpose : read iceberg namelist and print the variables.
401	!!
402	!! ** input : - namberg namelist
403	!!----------------------------------------------------------------------
404	INTEGER :: jn ! dummy loop indices
405	REAL(wp) :: zfact ! local scalar
406	!
407	NAMELIST/namberg/ ln_icebergs , ln_bergdia , nn_sample_rate , rn_initial_mass , &
408	& rn_distribution, rn_mass_scaling, rn_initial_thickness, nn_verbose_write , &
409	& rn_rho_bergs , rn_LoW_ratio , nn_verbose_level , ln_operator_splitting, &
410	& rn_bits_erosion_fraction , rn_sicn_shift , ln_passive_mode , &
411	& ln_time_average_weight , nn_test_icebergs , rn_test_box , &
412	& rn_speed_limit , cn_dir, sn_icb
413	!!----------------------------------------------------------------------
414
415	! (NB: frequency positive => hours, negative => months)
416	! ! file ! frequency ! variable ! time intep ! clim ! 'yearly' or ! weights ! rotation !
417	! ! name ! (hours) ! name ! (T/F) ! (T/F) ! 'monthly' ! filename ! pairs !
418	sn_icb = FLD_N( 'calving' , -1 , 'calving' , .TRUE. , .TRUE. , 'yearly' , '' , '' )
419
420	REWIND( numnam ) ! Namelist namrun : iceberg parameters
421	READ ( numnam, namberg )
422
423	!!gm bug here in mpp : the return instruction will be done only on the 1st processor (lwp=True)
424	! IF( .NOT. ln_icebergs .AND. lwp ) THEN
425	! WRITE(numout,*)
426	! WRITE(numout,*) 'icb_nam : iceberg initialization through namberg namelist read'
427	! WRITE(numout,*) '~~~~~~~~ '
428	! WRITE(numout,*) 'NO icebergs used'
429	! RETURN
430	! ENDIF
431	!!gm solution:
432
433	IF( .NOT. ln_icebergs ) THEN ! no icebergs
434	IF(lwp) THEN
435	WRITE(numout,*)
436	WRITE(numout,*) 'icb_nam : ln_icebergs = F , NO icebergs used'
437	WRITE(numout,*) '~~~~~~~~ '
438	ENDIF
439	RETURN
440	ENDIF
441	!!gm end
442
443	IF( nn_test_icebergs > nclasses ) THEN
444	IF(lwp) WRITE(numout,*) 'Resetting nn_test_icebergs to ', nclasses
445	nn_test_icebergs = nclasses
446	ENDIF
447
448	zfact = SUM( rn_distribution )
449	IF( zfact < 1._wp ) THEN
450	IF( zfact <= 0._wp ) THEN
451	CALL ctl_stop( 'icb_init: sum of berg distribution equal to zero' )
452	ELSE
453	rn_distribution(:) = rn_distribution(:) / zfact
454	CALL ctl_warn( 'icb_init: sum of berg input distribution not equal to one and so RESCALED' )
455	ENDIF
456	ENDIF
457
458	IF(lwp) THEN ! control print
459	WRITE(numout,*)
460	WRITE(numout,*) 'icb_nam : iceberg initialization through namberg namelist read'
461	WRITE(numout,*) '~~~~~~~~ '
462	WRITE(numout,*) ' Calculate budgets ln_bergdia = ', ln_bergdia
463	WRITE(numout,*) ' Period between sampling of position for trajectory storage nn_sample_rate = ', nn_sample_rate
464	WRITE(numout,*) ' Mass thresholds between iceberg classes (kg) rn_initial_mass ='
465	DO jn=1,nclasses
466	WRITE(numout,'(a,f15.2)') ' ',rn_initial_mass(jn)
467	ENDDO
468	WRITE(numout,*) ' Fraction of calving to apply to this class (non-dim) rn_distribution ='
469	DO jn = 1, nclasses
470	WRITE(numout,'(a,f10.2)') ' ',rn_distribution(jn)
471	END DO
472	WRITE(numout,*) ' Ratio between effective and real iceberg mass (non-dim) rn_mass_scaling = '
473	DO jn = 1, nclasses
474	WRITE(numout,'(a,f10.2)') ' ',rn_mass_scaling(jn)
475	END DO
476	WRITE(numout,*) ' Total thickness of newly calved bergs (m) rn_initial_thickness = '
477	DO jn = 1, nclasses
478	WRITE(numout,'(a,f10.2)') ' ',rn_initial_thickness(jn)
479	END DO
480	WRITE(numout,*) ' Timesteps between verbose messages nn_verbose_write = ', nn_verbose_write
481
482	WRITE(numout,*) ' Density of icebergs rn_rho_bergs = ', rn_rho_bergs
483	WRITE(numout,*) ' Initial ratio L/W for newly calved icebergs rn_LoW_ratio = ', rn_LoW_ratio
484	WRITE(numout,*) ' Turn on more verbose output level = ', nn_verbose_level
485	WRITE(numout,*) ' Use first order operator splitting for thermodynamics ', &
486	& 'use_operator_splitting = ', ln_operator_splitting
487	WRITE(numout,*) ' Fraction of erosion melt flux to divert to bergy bits ', &
488	& 'bits_erosion_fraction = ', rn_bits_erosion_fraction
489
490	WRITE(numout,*) ' Shift of sea-ice concentration in erosion flux modulation ', &
491	& '(0<sicn_shift<1) rn_sicn_shift = ', rn_sicn_shift
492	WRITE(numout,*) ' Do not add freshwater flux from icebergs to ocean ', &
493	& ' passive_mode = ', ln_passive_mode
494	WRITE(numout,*) ' Time average the weight on the ocean time_average_weight = ', ln_time_average_weight
495	WRITE(numout,*) ' Create icebergs in absence of a restart file nn_test_icebergs = ', nn_test_icebergs
496	WRITE(numout,*) ' in lon/lat box = ', rn_test_box
497	WRITE(numout,*) ' CFL speed limit for a berg speed_limit = ', rn_speed_limit
498	WRITE(numout,*) ' Writing Iceberg status information to icebergs.stat file '
499	ENDIF
500	!
501	END SUBROUTINE icb_nam
502
503	!!======================================================================
504
505	END MODULE icbini

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

Download in other formats: