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.

dynnxt.F90 in branches/2015/dev_r5151_UKMO_ISF/NEMOGCM/NEMO/OPA_SRC/DYN – NEMO

Context Navigation

source: branches/2015/dev_r5151_UKMO_ISF/NEMOGCM/NEMO/OPA_SRC/DYN/dynnxt.F90 @ 5944

Last change on this file since 5944 was 5944, checked in by mathiot, 8 years ago
ISF: change related to reviewers comments
Property svn:keywords set to `Id`
File size: 19.2 KB

Rev	Line
[3]	1	MODULE dynnxt
[1502]	2	!!=========================================================================
[3]	3	!! * MODULE dynnxt *
	4	!! Ocean dynamics: time stepping
[1502]	5	!!=========================================================================
[1438]	6	!! History : OPA ! 1987-02 (P. Andrich, D. L Hostis) Original code
	7	!! ! 1990-10 (C. Levy, G. Madec)
	8	!! 7.0 ! 1993-03 (M. Guyon) symetrical conditions
	9	!! 8.0 ! 1997-02 (G. Madec & M. Imbard) opa, release 8.0
	10	!! 8.2 ! 1997-04 (A. Weaver) Euler forward step
	11	!! - ! 1997-06 (G. Madec) lateral boudary cond., lbc routine
	12	!! NEMO 1.0 ! 2002-08 (G. Madec) F90: Free form and module
	13	!! - ! 2002-10 (C. Talandier, A-M. Treguier) Open boundary cond.
	14	!! 2.0 ! 2005-11 (V. Garnier) Surface pressure gradient organization
	15	!! 2.3 ! 2007-07 (D. Storkey) Calls to BDY routines.
[1502]	16	!! 3.2 ! 2009-06 (G. Madec, R.Benshila) re-introduce the vvl option
[2528]	17	!! 3.3 ! 2010-09 (D. Storkey, E.O'Dea) Bug fix for BDY module
[2723]	18	!! 3.3 ! 2011-03 (P. Oddo) Bug fix for time-splitting+(BDY-OBC) and not VVL
[4292]	19	!! 3.5 ! 2013-07 (J. Chanut) Compliant with time splitting changes
[4990]	20	!! 3.7 ! 2014-04 (G. Madec) add the diagnostic of the time filter trends
[1502]	21	!!-------------------------------------------------------------------------
[1438]	22
[1502]	23	!!-------------------------------------------------------------------------
	24	!! dyn_nxt : obtain the next (after) horizontal velocity
	25	!!-------------------------------------------------------------------------
[3]	26	USE oce ! ocean dynamics and tracers
	27	USE dom_oce ! ocean space and time domain
[2528]	28	USE sbc_oce ! Surface boundary condition: ocean fields
	29	USE phycst ! physical constants
[1502]	30	USE dynspg_oce ! type of surface pressure gradient
	31	USE dynadv ! dynamics: vector invariant versus flux form
	32	USE domvvl ! variable volume
[3294]	33	USE bdy_oce ! ocean open boundary conditions
	34	USE bdydta ! ocean open boundary conditions
	35	USE bdydyn ! ocean open boundary conditions
	36	USE bdyvol ! ocean open boundary condition (bdy_vol routines)
[4990]	37	USE trd_oce ! trends: ocean variables
	38	USE trddyn ! trend manager: dynamics
	39	USE trdken ! trend manager: kinetic energy
	40	!
[1502]	41	USE in_out_manager ! I/O manager
[4990]	42	USE iom ! I/O manager library
[3]	43	USE lbclnk ! lateral boundary condition (or mpp link)
[2715]	44	USE lib_mpp ! MPP library
[3294]	45	USE wrk_nemo ! Memory Allocation
[258]	46	USE prtctl ! Print control
[4990]	47	USE timing ! Timing
[2528]	48	#if defined key_agrif
	49	USE agrif_opa_interp
	50	#endif
[3]	51
	52	IMPLICIT NONE
	53	PRIVATE
	54
[1438]	55	PUBLIC dyn_nxt ! routine called by step.F90
	56
[592]	57	!! * Substitutions
	58	# include "domzgr_substitute.h90"
[2715]	59	!!----------------------------------------------------------------------
[2528]	60	!! NEMO/OPA 3.3 , NEMO Consortium (2010)
[1438]	61	!! $Id$
[2715]	62	!! Software governed by the CeCILL licence (NEMOGCM/NEMO_CeCILL.txt)
	63	!!----------------------------------------------------------------------
[3]	64	CONTAINS
	65
	66	SUBROUTINE dyn_nxt ( kt )
	67	!!----------------------------------------------------------------------
	68	!! * ROUTINE dyn_nxt *
	69	!!
[1502]	70	!! ** Purpose : Compute the after horizontal velocity. Apply the boundary
	71	!! condition on the after velocity, achieved the time stepping
	72	!! by applying the Asselin filter on now fields and swapping
	73	!! the fields.
[3]	74	!!
[1502]	75	!! ** Method : * After velocity is compute using a leap-frog scheme:
	76	!! (ua,va) = (ub,vb) + 2 rdt (ua,va)
	77	!! Note that with flux form advection and variable volume layer
	78	!! (lk_vvl=T), the leap-frog is applied on thickness weighted
	79	!! velocity.
	80	!! Note also that in filtered free surface (lk_dynspg_flt=T),
	81	!! the time stepping has already been done in dynspg module
[3]	82	!!
[1502]	83	!! * Apply lateral boundary conditions on after velocity
	84	!! at the local domain boundaries through lbc_lnk call,
[4328]	85	!! at the one-way open boundaries (lk_bdy=T),
[4990]	86	!! at the AGRIF zoom boundaries (lk_agrif=T)
[3]	87	!!
[1502]	88	!! * Apply the time filter applied and swap of the dynamics
	89	!! arrays to start the next time step:
	90	!! (ub,vb) = (un,vn) + atfp [ (ub,vb) + (ua,va) - 2 (un,vn) ]
	91	!! (un,vn) = (ua,va).
	92	!! Note that with flux form advection and variable volume layer
	93	!! (lk_vvl=T), the time filter is applied on thickness weighted
	94	!! velocity.
	95	!!
	96	!! ** Action : ub,vb filtered before horizontal velocity of next time-step
	97	!! un,vn now horizontal velocity of next time-step
[3]	98	!!----------------------------------------------------------------------
	99	INTEGER, INTENT( in ) :: kt ! ocean time-step index
[2715]	100	!
[3]	101	INTEGER :: ji, jj, jk ! dummy loop indices
[5944]	102	INTEGER :: ikt ! local integers
[1566]	103	#if ! defined key_dynspg_flt
[3]	104	REAL(wp) :: z2dt ! temporary scalar
[1566]	105	#endif
[4990]	106	REAL(wp) :: zue3a, zue3n, zue3b, zuf, zec ! local scalars
	107	REAL(wp) :: zve3a, zve3n, zve3b, zvf, z1_2dt ! - -
	108	REAL(wp), POINTER, DIMENSION(:,:) :: zue, zve
	109	REAL(wp), POINTER, DIMENSION(:,:,:) :: ze3u_f, ze3v_f, zua, zva
[1502]	110	!!----------------------------------------------------------------------
[3294]	111	!
[4990]	112	IF( nn_timing == 1 ) CALL timing_start('dyn_nxt')
[3294]	113	!
[4990]	114	CALL wrk_alloc( jpi,jpj,jpk, ze3u_f, ze3v_f, zua, zva )
	115	IF( lk_dynspg_ts ) CALL wrk_alloc( jpi,jpj, zue, zve )
[3294]	116	!
[3]	117	IF( kt == nit000 ) THEN
	118	IF(lwp) WRITE(numout,*)
	119	IF(lwp) WRITE(numout,*) 'dyn_nxt : time stepping'
	120	IF(lwp) WRITE(numout,*) '~~~~~~~'
	121	ENDIF
	122
[1502]	123	#if defined key_dynspg_flt
	124	!
	125	! Next velocity : Leap-frog time stepping already done in dynspg_flt.F routine
	126	! -------------
[3]	127
[1502]	128	! Update after velocity on domain lateral boundaries (only local domain required)
	129	! --------------------------------------------------
	130	CALL lbc_lnk( ua, 'U', -1. ) ! local domain boundaries
	131	CALL lbc_lnk( va, 'V', -1. )
	132	!
	133	#else
[4292]	134
	135	# if defined key_dynspg_exp
[1502]	136	! Next velocity : Leap-frog time stepping
[1438]	137	! -------------
[1502]	138	z2dt = 2. * rdt ! Euler or leap-frog time step
	139	IF( neuler == 0 .AND. kt == nit000 ) z2dt = rdt
	140	!
	141	IF( ln_dynadv_vec .OR. .NOT. lk_vvl ) THEN ! applied on velocity
[1438]	142	DO jk = 1, jpkm1
[1502]	143	ua(:,:,jk) = ( ub(:,:,jk) + z2dt * ua(:,:,jk) ) * umask(:,:,jk)
	144	va(:,:,jk) = ( vb(:,:,jk) + z2dt * va(:,:,jk) ) * vmask(:,:,jk)
	145	END DO
	146	ELSE ! applied on thickness weighted velocity
	147	DO jk = 1, jpkm1
	148	ua(:,:,jk) = ( ub(:,:,jk) * fse3u_b(:,:,jk) &
	149	& + z2dt * ua(:,:,jk) * fse3u_n(:,:,jk) ) &
[1438]	150	& / fse3u_a(:,:,jk) * umask(:,:,jk)
[1502]	151	va(:,:,jk) = ( vb(:,:,jk) * fse3v_b(:,:,jk) &
	152	& + z2dt * va(:,:,jk) * fse3v_n(:,:,jk) ) &
[1438]	153	& / fse3v_a(:,:,jk) * vmask(:,:,jk)
[592]	154	END DO
	155	ENDIF
[4292]	156	# endif
[592]	157
[4292]	158	# if defined key_dynspg_ts
[4990]	159	!!gm IF ( lk_dynspg_ts ) THEN ....
[4292]	160	! Ensure below that barotropic velocities match time splitting estimate
	161	! Compute actual transport and replace it with ts estimate at "after" time step
[4990]	162	zue(:,:) = fse3u_a(:,:,1) * ua(:,:,1) * umask(:,:,1)
	163	zve(:,:) = fse3v_a(:,:,1) * va(:,:,1) * vmask(:,:,1)
	164	DO jk = 2, jpkm1
	165	zue(:,:) = zue(:,:) + fse3u_a(:,:,jk) * ua(:,:,jk) * umask(:,:,jk)
	166	zve(:,:) = zve(:,:) + fse3v_a(:,:,jk) * va(:,:,jk) * vmask(:,:,jk)
[4370]	167	END DO
	168	DO jk = 1, jpkm1
[4990]	169	ua(:,:,jk) = ( ua(:,:,jk) - zue(:,:) * hur_a(:,:) + ua_b(:,:) ) * umask(:,:,jk)
	170	va(:,:,jk) = ( va(:,:,jk) - zve(:,:) * hvr_a(:,:) + va_b(:,:) ) * vmask(:,:,jk)
[4370]	171	END DO
[1502]	172
[4292]	173	IF (lk_dynspg_ts.AND.(.NOT.ln_bt_fw)) THEN
	174	! Remove advective velocity from "now velocities"
	175	! prior to asselin filtering
[4312]	176	! In the forward case, this is done below after asselin filtering
	177	! so that asselin contribution is removed at the same time
[4292]	178	DO jk = 1, jpkm1
	179	un(:,:,jk) = ( un(:,:,jk) - un_adv(:,:) + un_b(:,:) )*umask(:,:,jk)
	180	vn(:,:,jk) = ( vn(:,:,jk) - vn_adv(:,:) + vn_b(:,:) )*vmask(:,:,jk)
	181	END DO
	182	ENDIF
[4990]	183	!!gm ENDIF
[4292]	184	# endif
	185
[1502]	186	! Update after velocity on domain lateral boundaries
	187	! --------------------------------------------------
	188	CALL lbc_lnk( ua, 'U', -1. ) !* local domain boundaries
	189	CALL lbc_lnk( va, 'V', -1. )
	190	!
[4328]	191	# if defined key_bdy
[1502]	192	! !* BDY open boundaries
[3764]	193	IF( lk_bdy .AND. lk_dynspg_exp ) CALL bdy_dyn( kt )
	194	IF( lk_bdy .AND. lk_dynspg_ts ) CALL bdy_dyn( kt, dyn3d_only=.true. )
[3294]	195
	196	!!$ Do we need a call to bdy_vol here??
	197	!
[1438]	198	# endif
[1502]	199	!
[392]	200	# if defined key_agrif
[1502]	201	CALL Agrif_dyn( kt ) !* AGRIF zoom boundaries
[389]	202	# endif
[3]	203	#endif
[592]	204
[4990]	205	IF( l_trddyn ) THEN ! prepare the atf trend computation + some diagnostics
	206	z1_2dt = 1._wp / (2. * rdt) ! Euler or leap-frog time step
	207	IF( neuler == 0 .AND. kt == nit000 ) z1_2dt = 1._wp / rdt
	208	!
	209	! ! Kinetic energy and Conversion
	210	IF( ln_KE_trd ) CALL trd_dyn( ua, va, jpdyn_ken, kt )
	211	!
	212	IF( ln_dyn_trd ) THEN ! 3D output: total momentum trends
	213	zua(:,:,:) = ( ua(:,:,:) - ub(:,:,:) ) * z1_2dt
	214	zva(:,:,:) = ( va(:,:,:) - vb(:,:,:) ) * z1_2dt
	215	CALL iom_put( "utrd_tot", zua ) ! total momentum trends, except the asselin time filter
	216	CALL iom_put( "vtrd_tot", zva )
	217	ENDIF
	218	!
	219	zua(:,:,:) = un(:,:,:) ! save the now velocity before the asselin filter
	220	zva(:,:,:) = vn(:,:,:) ! (caution: there will be a shift by 1 timestep in the
	221	! ! computation of the asselin filter trends)
	222	ENDIF
	223
[1438]	224	! Time filter and swap of dynamics arrays
	225	! ------------------------------------------
[1502]	226	IF( neuler == 0 .AND. kt == nit000 ) THEN !* Euler at first time-step: only swap
	227	DO jk = 1, jpkm1
	228	un(:,:,jk) = ua(:,:,jk) ! un <-- ua
[1438]	229	vn(:,:,jk) = va(:,:,jk)
	230	END DO
[4292]	231	IF (lk_vvl) THEN
	232	DO jk = 1, jpkm1
	233	fse3t_b(:,:,jk) = fse3t_n(:,:,jk)
	234	fse3u_b(:,:,jk) = fse3u_n(:,:,jk)
	235	fse3v_b(:,:,jk) = fse3v_n(:,:,jk)
	236	ENDDO
	237	ENDIF
[1502]	238	ELSE !* Leap-Frog : Asselin filter and swap
[2528]	239	! ! =============!
	240	IF( .NOT. lk_vvl ) THEN ! Fixed volume !
	241	! ! =============!
[1502]	242	DO jk = 1, jpkm1
[592]	243	DO jj = 1, jpj
[1502]	244	DO ji = 1, jpi
[4990]	245	zuf = un(ji,jj,jk) + atfp * ( ub(ji,jj,jk) - 2._wp * un(ji,jj,jk) + ua(ji,jj,jk) )
	246	zvf = vn(ji,jj,jk) + atfp * ( vb(ji,jj,jk) - 2._wp * vn(ji,jj,jk) + va(ji,jj,jk) )
[1502]	247	!
	248	ub(ji,jj,jk) = zuf ! ub <-- filtered velocity
	249	vb(ji,jj,jk) = zvf
	250	un(ji,jj,jk) = ua(ji,jj,jk) ! un <-- ua
	251	vn(ji,jj,jk) = va(ji,jj,jk)
	252	END DO
	253	END DO
	254	END DO
[2528]	255	! ! ================!
	256	ELSE ! Variable volume !
	257	! ! ================!
[4292]	258	! Before scale factor at t-points
	259	! (used as a now filtered scale factor until the swap)
	260	! ----------------------------------------------------
	261	IF (lk_dynspg_ts.AND.ln_bt_fw) THEN
[4338]	262	! No asselin filtering on thicknesses if forward time splitting
[4292]	263	fse3t_b(:,:,:) = fse3t_n(:,:,:)
	264	ELSE
	265	fse3t_b(:,:,:) = fse3t_n(:,:,:) + atfp * ( fse3t_b(:,:,:) - 2._wp * fse3t_n(:,:,:) + fse3t_a(:,:,:) )
	266	! Add volume filter correction: compatibility with tracer advection scheme
	267	! => time filter + conservation correction (only at the first level)
[5624]	268	DO jj = 1,jpj
	269	DO ji = 1,jpi
[5944]	270	ikt = mikt(ji,jj)
	271	fse3t_b(ji,jj,ikt) = fse3t_b(ji,jj,ikt) - atfp * rdt * r1_rau0 &
[5624]	272	& * ( (emp_b(ji,jj) - emp(ji,jj) ) &
	273	& - (rnf_b(ji,jj) - rnf(ji,jj) ) &
[5944]	274	& + (fwfisf_b(ji,jj) - fwfisf(ji,jj) ) ) * tmask(ji,jj,ikt)
[5624]	275	END DO
	276	END DO
[4292]	277	ENDIF
[2528]	278	!
[4292]	279	IF( ln_dynadv_vec ) THEN
	280	! Before scale factor at (u/v)-points
	281	! -----------------------------------
	282	CALL dom_vvl_interpol( fse3t_b(:,:,:), fse3u_b(:,:,:), 'U' )
	283	CALL dom_vvl_interpol( fse3t_b(:,:,:), fse3v_b(:,:,:), 'V' )
	284	! Leap-Frog - Asselin filter and swap: applied on velocity
	285	! -----------------------------------
	286	DO jk = 1, jpkm1
	287	DO jj = 1, jpj
[2528]	288	DO ji = 1, jpi
[4292]	289	zuf = un(ji,jj,jk) + atfp * ( ub(ji,jj,jk) - 2._wp * un(ji,jj,jk) + ua(ji,jj,jk) )
	290	zvf = vn(ji,jj,jk) + atfp * ( vb(ji,jj,jk) - 2._wp * vn(ji,jj,jk) + va(ji,jj,jk) )
[2528]	291	!
	292	ub(ji,jj,jk) = zuf ! ub <-- filtered velocity
	293	vb(ji,jj,jk) = zvf
	294	un(ji,jj,jk) = ua(ji,jj,jk) ! un <-- ua
	295	vn(ji,jj,jk) = va(ji,jj,jk)
	296	END DO
	297	END DO
	298	END DO
	299	!
[4292]	300	ELSE
	301	! Temporary filtered scale factor at (u/v)-points (will become before scale factor)
	302	!------------------------------------------------
	303	CALL dom_vvl_interpol( fse3t_b(:,:,:), ze3u_f, 'U' )
	304	CALL dom_vvl_interpol( fse3t_b(:,:,:), ze3v_f, 'V' )
	305	! Leap-Frog - Asselin filter and swap: applied on thickness weighted velocity
	306	! ----------------------------------- ===========================
	307	DO jk = 1, jpkm1
	308	DO jj = 1, jpj
[4312]	309	DO ji = 1, jpi
[2528]	310	zue3a = ua(ji,jj,jk) * fse3u_a(ji,jj,jk)
	311	zve3a = va(ji,jj,jk) * fse3v_a(ji,jj,jk)
	312	zue3n = un(ji,jj,jk) * fse3u_n(ji,jj,jk)
	313	zve3n = vn(ji,jj,jk) * fse3v_n(ji,jj,jk)
	314	zue3b = ub(ji,jj,jk) * fse3u_b(ji,jj,jk)
	315	zve3b = vb(ji,jj,jk) * fse3v_b(ji,jj,jk)
	316	!
[3294]	317	zuf = ( zue3n + atfp * ( zue3b - 2._wp * zue3n + zue3a ) ) / ze3u_f(ji,jj,jk)
	318	zvf = ( zve3n + atfp * ( zve3b - 2._wp * zve3n + zve3a ) ) / ze3v_f(ji,jj,jk)
[2528]	319	!
[3294]	320	ub(ji,jj,jk) = zuf ! ub <-- filtered velocity
[2528]	321	vb(ji,jj,jk) = zvf
[3294]	322	un(ji,jj,jk) = ua(ji,jj,jk) ! un <-- ua
[2528]	323	vn(ji,jj,jk) = va(ji,jj,jk)
	324	END DO
	325	END DO
	326	END DO
[3294]	327	fse3u_b(:,:,1:jpkm1) = ze3u_f(:,:,1:jpkm1) ! e3u_b <-- filtered scale factor
	328	fse3v_b(:,:,1:jpkm1) = ze3v_f(:,:,1:jpkm1)
[2528]	329	ENDIF
	330	!
[3]	331	ENDIF
[2528]	332	!
[4292]	333	IF (lk_dynspg_ts.AND.ln_bt_fw) THEN
[4312]	334	! Revert "before" velocities to time split estimate
	335	! Doing it here also means that asselin filter contribution is removed
[4990]	336	zue(:,:) = fse3u_b(:,:,1) * ub(:,:,1) * umask(:,:,1)
	337	zve(:,:) = fse3v_b(:,:,1) * vb(:,:,1) * vmask(:,:,1)
	338	DO jk = 2, jpkm1
	339	zue(:,:) = zue(:,:) + fse3u_b(:,:,jk) * ub(:,:,jk) * umask(:,:,jk)
	340	zve(:,:) = zve(:,:) + fse3v_b(:,:,jk) * vb(:,:,jk) * vmask(:,:,jk)
[4370]	341	END DO
	342	DO jk = 1, jpkm1
[4990]	343	ub(:,:,jk) = ub(:,:,jk) - (zue(:,:) * hur(:,:) - un_b(:,:)) * umask(:,:,jk)
	344	vb(:,:,jk) = vb(:,:,jk) - (zve(:,:) * hvr(:,:) - vn_b(:,:)) * vmask(:,:,jk)
[4292]	345	END DO
	346	ENDIF
	347	!
	348	ENDIF ! neuler =/0
[4354]	349	!
	350	! Set "now" and "before" barotropic velocities for next time step:
	351	! JC: Would be more clever to swap variables than to make a full vertical
	352	! integration
	353	!
[4370]	354	!
	355	IF (lk_vvl) THEN
	356	hu_b(:,:) = 0.
	357	hv_b(:,:) = 0.
	358	DO jk = 1, jpkm1
	359	hu_b(:,:) = hu_b(:,:) + fse3u_b(:,:,jk) * umask(:,:,jk)
	360	hv_b(:,:) = hv_b(:,:) + fse3v_b(:,:,jk) * vmask(:,:,jk)
[4354]	361	END DO
[5200]	362	hur_b(:,:) = ssumask(:,:) / ( hu_b(:,:) + 1._wp - ssumask(:,:) )
	363	hvr_b(:,:) = ssvmask(:,:) / ( hv_b(:,:) + 1._wp - ssvmask(:,:) )
[4354]	364	ENDIF
	365	!
	366	un_b(:,:) = 0._wp ; vn_b(:,:) = 0._wp
	367	ub_b(:,:) = 0._wp ; vb_b(:,:) = 0._wp
	368	!
	369	DO jk = 1, jpkm1
	370	DO jj = 1, jpj
	371	DO ji = 1, jpi
[4370]	372	un_b(ji,jj) = un_b(ji,jj) + fse3u_a(ji,jj,jk) * un(ji,jj,jk) * umask(ji,jj,jk)
	373	vn_b(ji,jj) = vn_b(ji,jj) + fse3v_a(ji,jj,jk) * vn(ji,jj,jk) * vmask(ji,jj,jk)
[4354]	374	!
[4370]	375	ub_b(ji,jj) = ub_b(ji,jj) + fse3u_b(ji,jj,jk) * ub(ji,jj,jk) * umask(ji,jj,jk)
	376	vb_b(ji,jj) = vb_b(ji,jj) + fse3v_b(ji,jj,jk) * vb(ji,jj,jk) * vmask(ji,jj,jk)
[4354]	377	END DO
	378	END DO
	379	END DO
	380	!
	381	!
[4370]	382	un_b(:,:) = un_b(:,:) * hur_a(:,:)
	383	vn_b(:,:) = vn_b(:,:) * hvr_a(:,:)
	384	ub_b(:,:) = ub_b(:,:) * hur_b(:,:)
	385	vb_b(:,:) = vb_b(:,:) * hvr_b(:,:)
[4354]	386	!
	387	!
[4990]	388
	389	IF( l_trddyn ) THEN ! 3D output: asselin filter trends on momentum
	390	zua(:,:,:) = ( ub(:,:,:) - zua(:,:,:) ) * z1_2dt
	391	zva(:,:,:) = ( vb(:,:,:) - zva(:,:,:) ) * z1_2dt
	392	CALL trd_dyn( zua, zva, jpdyn_atf, kt )
	393	ENDIF
	394	!
[1438]	395	IF(ln_ctl) CALL prt_ctl( tab3d_1=un, clinfo1=' nxt - Un: ', mask1=umask, &
	396	& tab3d_2=vn, clinfo2=' Vn: ' , mask2=vmask )
	397	!
[4990]	398	CALL wrk_dealloc( jpi,jpj,jpk, ze3u_f, ze3v_f, zua, zva )
	399	IF( lk_dynspg_ts ) CALL wrk_dealloc( jpi,jpj, zue, zve )
[2715]	400	!
[3294]	401	IF( nn_timing == 1 ) CALL timing_stop('dyn_nxt')
	402	!
[3]	403	END SUBROUTINE dyn_nxt
	404
[1502]	405	!!=========================================================================
[3]	406	END MODULE dynnxt

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

Download in other formats: