MODULE trdvor !!====================================================================== !! *** MODULE trdvor *** !! Ocean diagnostics: momentum trends !!===================================================================== !! History : 1.0 ! 2006-01 (L. Brunier, A-M. Treguier) Original code !! 2.0 ! 2008-04 (C. Talandier) New trends organization !! 3.5 ! 2012-02 (G. Madec) regroup beta.V computation with pvo trend !!---------------------------------------------------------------------- !!---------------------------------------------------------------------- !! trd_vor : momentum trends averaged over the depth !! trd_vor_zint : vorticity vertical integration !! trd_vor_init : initialization step !!---------------------------------------------------------------------- USE oce ! ocean dynamics and tracers variables USE dom_oce ! ocean space and time domain variables USE trd_oce ! trends: ocean variables USE zdf_oce ! ocean vertical physics USE sbc_oce ! surface boundary condition: ocean USE phycst ! Define parameters for the routines USE ldfdyn ! ocean active tracers: lateral physics USE dianam ! build the name of file (routine) USE zdfmxl ! mixed layer depth ! USE in_out_manager ! I/O manager USE iom ! I/O USE lbclnk ! ocean lateral boundary conditions (or mpp link) USE lib_mpp ! MPP library IMPLICIT NONE PRIVATE INTERFACE trd_vor_zint MODULE PROCEDURE trd_vor_zint_2d, trd_vor_zint_3d END INTERFACE PUBLIC trd_vor ! routine called by trddyn.F90 PUBLIC trd_vor_init ! routine called by opa.F90 PUBLIC trd_vor_alloc ! routine called by nemogcm.F90 INTEGER :: nh_t, nmoydpvor, nidvor, nhoridvor, ndimvor1, icount ! needs for IOIPSL output INTEGER, SAVE, ALLOCATABLE, DIMENSION(:) :: ndexvor1 ! needed for IOIPSL output INTEGER :: ndebug ! (0/1) set it to 1 in case of problem to have more print INTEGER, SAVE :: n_hf_lastcalc ! last timestep for which r1_hf_n was calculated. REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: r1_hf_n ! reciprocal of water column height at F-points REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: vor_avr ! average REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: vor_avrb ! before vorticity (kt-1) REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: vor_avrbb ! vorticity at begining of the nwrite-1 timestep averaging period REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: vor_avrbn ! after vorticity at time step after the REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: rotot ! begining of the NWRITE-1 timesteps REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: vor_avrtot ! REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:) :: vor_avrres ! REAL(wp), SAVE, ALLOCATABLE, DIMENSION(:,:,:,:) :: vortrd ! curl of trends CHARACTER(len=12) :: cvort !! * Substitutions # include "vectopt_loop_substitute.h90" !!---------------------------------------------------------------------- !! NEMO/OCE 4.0 , NEMO Consortium (2018) !! $Id$ !! Software governed by the CeCILL licence (./LICENSE) !!---------------------------------------------------------------------- CONTAINS INTEGER FUNCTION trd_vor_alloc() !!---------------------------------------------------------------------------- !! *** ROUTINE trd_vor_alloc *** !!---------------------------------------------------------------------------- ALLOCATE( vor_avr (jpi,jpj) , vor_avrb(jpi,jpj) , vor_avrbb (jpi,jpj) , & & vor_avrbn (jpi,jpj) , rotot (jpi,jpj) , vor_avrtot(jpi,jpj) , & & vor_avrres(jpi,jpj) , vortrd (jpi,jpj,jpltot_vor,jpltype_vor) , & & ndexvor1 (jpi*jpj) , r1_hf_n (jpi,jpj) , STAT= trd_vor_alloc ) ! IF( lk_mpp ) CALL mpp_sum ( trd_vor_alloc ) IF( trd_vor_alloc /= 0 ) CALL ctl_warn('trd_vor_alloc: failed to allocate arrays') END FUNCTION trd_vor_alloc SUBROUTINE trd_vor( putrd, pvtrd, ktrd, kt ) !!---------------------------------------------------------------------- !! *** ROUTINE trd_vor *** !! !! ** Purpose : computation of cumulated trends over analysis period !! and make outputs (NetCDF format) !!---------------------------------------------------------------------- REAL(wp), DIMENSION(:,:,:), INTENT(inout) :: putrd, pvtrd ! U and V trends INTEGER , INTENT(in ) :: ktrd ! trend index INTEGER , INTENT(in ) :: kt ! time step ! INTEGER :: ji, jj, jk ! dummy loop indices REAL(wp), DIMENSION(jpi,jpj) :: ztswu, ztswv ! 2D workspace !!---------------------------------------------------------------------- IF( n_hf_lastcalc .lt. kt ) THEN ! calculate reciprocal water column depth at F points if not already done this timestep. r1_hf_n(:,:) = 0.0 DO jk = 1,jpk r1_hf_n(:,:) = r1_hf_n(:,:) + e3f_n(:,:,jk) * fmask(:,:,jk) END DO r1_hf_n(:,:) = fmask(:,:,1) / ( r1_hf_n(:,:) + 1._wp - fmask(:,:,1) ) n_hf_lastcalc = kt ENDIF SELECT CASE( ktrd ) CASE( jpdyn_hpg ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_prg ) ! Hydrostatique Pressure Gradient CASE( jpdyn_keg ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_keg ) ! KE Gradient CASE( jpdyn_rvo ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_rvo ) ! Relative Vorticity CASE( jpdyn_pvo ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_pvo ) ! Planetary Vorticity Term CASE( jpdyn_ldf ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_ldf ) ! Horizontal Diffusion CASE( jpdyn_zad ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_zad ) ! Vertical Advection CASE( jpdyn_spg ) ; CALL trd_vor_zint( putrd, pvtrd, jpvor_spg ) ! Surface Pressure Grad. CASE( jpdyn_zdf ) ! Vertical Diffusion ztswu(:,:) = 0.e0 ; ztswv(:,:) = 0.e0 DO jj = 2, jpjm1 ! wind stress trends DO ji = fs_2, fs_jpim1 ! vector opt. ztswu(ji,jj) = 0.5 * ( utau_b(ji,jj) + utau(ji,jj) ) / ( e3u_n(ji,jj,1) * rau0 ) ztswv(ji,jj) = 0.5 * ( vtau_b(ji,jj) + vtau(ji,jj) ) / ( e3v_n(ji,jj,1) * rau0 ) END DO END DO ! CALL trd_vor_zint( putrd, pvtrd, jpvor_zdf ) ! zdf trend including surf./bot. stresses CALL trd_vor_zint( ztswu, ztswv, jpvor_swf ) ! surface wind stress CASE( jpdyn_bfr ) CALL trd_vor_zint( putrd, pvtrd, jpvor_bfr ) ! Bottom stress ! CASE( jpdyn_atf ) ! last trends: perform the output of 2D vorticity trends CALL trd_vor_iom( kt ) END SELECT ! END SUBROUTINE trd_vor SUBROUTINE trd_vor_zint_2d( putrdvor, pvtrdvor, ktrd ) !!---------------------------------------------------------------------------- !! *** ROUTINE trd_vor_zint *** !! !! ** Purpose : computation of vertically integrated vorticity budgets !! from ocean surface down to control surface (NetCDF output) !! !! ** Method/usage : integration done over nwrite-1 time steps !! !! ** Action : trends : !! vortrd (,, 1) = Pressure Gradient Trend !! vortrd (,, 2) = KE Gradient Trend !! vortrd (,, 3) = Relative Vorticity Trend !! vortrd (,, 4) = Coriolis Term Trend !! vortrd (,, 5) = Horizontal Diffusion Trend !! vortrd (,, 6) = Vertical Advection Trend !! vortrd (,, 7) = Vertical Diffusion Trend !! vortrd (,, 8) = Surface Pressure Grad. Trend !! vortrd (,, 9) = Beta V !! vortrd (,,10) = forcing term !! vortrd (,,11) = bottom friction term !! rotot(,) : total cumulative trends over nwrite-1 time steps !! vor_avrtot(,) : first membre of vrticity equation !! vor_avrres(,) : residual = dh/dt entrainment !! !! trends output in netCDF format using ioipsl !!---------------------------------------------------------------------- INTEGER , INTENT(in ) :: ktrd ! ocean trend index REAL(wp), DIMENSION(jpi,jpj), INTENT(inout) :: putrdvor ! u vorticity trend REAL(wp), DIMENSION(jpi,jpj), INTENT(inout) :: pvtrdvor ! v vorticity trend ! INTEGER :: ji, jj ! dummy loop indices INTEGER :: ikbu, ikbv ! local integers REAL(wp), DIMENSION(jpi,jpj) :: zudpvor, zvdpvor ! total cmulative trends !!---------------------------------------------------------------------- ! zudpvor(:,:) = 0._wp ; zvdpvor(:,:) = 0._wp ! Initialisation CALL lbc_lnk_multi( putrdvor, 'U', -1. , pvtrdvor, 'V', -1. ) ! lateral boundary condition ! ===================================== ! I vertical integration of 2D trends ! ===================================== SELECT CASE( ktrd ) ! CASE( jpvor_bfr ) ! bottom friction DO jj = 2, jpjm1 DO ji = fs_2, fs_jpim1 ikbu = mbkv(ji,jj) ikbv = mbkv(ji,jj) zudpvor(ji,jj) = putrdvor(ji,jj) * e3u_n(ji,jj,ikbu) * e1u(ji,jj) * umask(ji,jj,ikbu) zvdpvor(ji,jj) = pvtrdvor(ji,jj) * e3v_n(ji,jj,ikbv) * e2v(ji,jj) * vmask(ji,jj,ikbv) END DO END DO ! CASE( jpvor_swf ) ! wind stress zudpvor(:,:) = putrdvor(:,:) * e3u_n(:,:,1) * e1u(:,:) * umask(:,:,1) zvdpvor(:,:) = pvtrdvor(:,:) * e3v_n(:,:,1) * e2v(:,:) * vmask(:,:,1) ! END SELECT ! Curl(vertical integral)/H diagnostics: ! Curl: DO ji = 1, jpim1 DO jj = 1, jpjm1 vortrd(ji,jj,ktrd,jptype_vor_int) = ( zvdpvor(ji+1,jj) - zvdpvor(ji,jj) & & - ( zudpvor(ji,jj+1) - zudpvor(ji,jj) ) ) / ( e1f(ji,jj) * e2f(ji,jj) ) END DO END DO ! Average of the Curl and Surface mask: vortrd(:,:,ktrd,jptype_vor_int) = vortrd(:,:,ktrd,jptype_vor_int) * r1_hf_n(:,:) * fmask(:,:,1) ! Average except for Beta.V zudpvor(:,:) = zudpvor(:,:) * r1_hu_n(:,:) zvdpvor(:,:) = zvdpvor(:,:) * r1_hv_n(:,:) ! Curl DO ji = 1, jpim1 DO jj = 1, jpjm1 vortrd(ji,jj,ktrd,jptype_vor_avg) = ( zvdpvor(ji+1,jj) - zvdpvor(ji,jj) & & - ( zudpvor(ji,jj+1) - zudpvor(ji,jj) ) ) / ( e1f(ji,jj) * e2f(ji,jj) ) END DO END DO vortrd(:,:,ktrd,jptype_vor_avg) = vortrd(:,:,ktrd,jptype_vor_avg) * fmask(:,:,1) ! Surface mask IF( ndebug /= 0 ) THEN IF(lwp) WRITE(numout,*) ' debuging trd_vor_zint: I done' CALL FLUSH(numout) ENDIF ! END SUBROUTINE trd_vor_zint_2d SUBROUTINE trd_vor_zint_3d( putrdvor, pvtrdvor, ktrd ) !!---------------------------------------------------------------------------- !! *** ROUTINE trd_vor_zint *** !! !! ** Purpose : computation of vertically integrated vorticity budgets !! from ocean surface down to control surface (NetCDF output) !! !! ** Method/usage : integration done over nwrite-1 time steps !! !! ** Action : trends : !! vortrd (,,1,) = Pressure Gradient Trend !! vortrd (,,2,) = KE Gradient Trend !! vortrd (,,3,) = Relative Vorticity Trend !! vortrd (,,4,) = Coriolis Term Trend !! vortrd (,,5,) = Horizontal Diffusion Trend !! vortrd (,,6,) = Vertical Advection Trend !! vortrd (,,7,) = Vertical Diffusion Trend !! vortrd (,,8,) = Surface Pressure Grad. Trend !! vortrd (,,9,) = forcing term !! vortrd (,,10,) = bottom friction term !! rotot(,) : total cumulative trends over nwrite-1 time steps !! vor_avrtot(,) : first membre of vrticity equation !! vor_avrres(,) : residual = dh/dt entrainment !! !! trends output in netCDF format using ioipsl !!---------------------------------------------------------------------- ! INTEGER , INTENT(in ) :: ktrd ! ocean trend index REAL(wp), DIMENSION(jpi,jpj,jpk), INTENT(inout) :: putrdvor ! u vorticity trend REAL(wp), DIMENSION(jpi,jpj,jpk), INTENT(inout) :: pvtrdvor ! v vorticity trend ! INTEGER :: ji, jj, jk ! dummy loop indices REAL(wp), DIMENSION(jpi,jpj) :: zudpvor, zvdpvor ! total cmulative trends !!---------------------------------------------------------------------- ! Initialization zudpvor(:,:) = 0._wp zvdpvor(:,:) = 0._wp ! ! lateral boundary condition on input momentum trends CALL lbc_lnk_multi( putrdvor, 'U', -1. , pvtrdvor, 'V', -1. ) ! ===================================== ! I vertical integration of 3D trends ! ===================================== ! putrdvor and pvtrdvor terms DO jk = 1,jpk zudpvor(:,:) = zudpvor(:,:) + putrdvor(:,:,jk) * e3u_n(:,:,jk) * e1u(:,:) * umask(:,:,jk) zvdpvor(:,:) = zvdpvor(:,:) + pvtrdvor(:,:,jk) * e3v_n(:,:,jk) * e2v(:,:) * vmask(:,:,jk) END DO ! Curl(vertical integral)/H diagnostics: ! Curl: DO ji = 1, jpim1 DO jj = 1, jpjm1 vortrd(ji,jj,ktrd,jptype_vor_int) = ( zvdpvor(ji+1,jj) - zvdpvor(ji,jj) & & - ( zudpvor(ji,jj+1) - zudpvor(ji,jj) ) ) / ( e1f(ji,jj) * e2f(ji,jj) ) END DO END DO ! Average of the Curl and Surface mask: vortrd(:,:,ktrd,jptype_vor_int) = vortrd(:,:,ktrd,jptype_vor_int) * r1_hf_n(:,:) * fmask(:,:,1) ! ! Curl(vertical mean) diagnostics: ! Average: zudpvor(:,:) = zudpvor(:,:) * r1_hu_n(:,:) zvdpvor(:,:) = zvdpvor(:,:) * r1_hv_n(:,:) ! ! Curl: DO ji=1,jpim1 DO jj=1,jpjm1 vortrd(ji,jj,ktrd,jptype_vor_avg) = ( zvdpvor(ji+1,jj) - zvdpvor(ji,jj) & & - ( zudpvor(ji,jj+1) - zudpvor(ji,jj) ) ) / ( e1f(ji,jj) * e2f(ji,jj) ) END DO END DO ! Surface mask: vortrd(:,:,ktrd,jptype_vor_avg) = vortrd(:,:,ktrd,jptype_vor_avg) * fmask(:,:,1) IF( ndebug /= 0 ) THEN IF(lwp) WRITE(numout,*) ' debuging trd_vor_zint: I done' CALL FLUSH(numout) ENDIF ! END SUBROUTINE trd_vor_zint_3d SUBROUTINE trd_vor_iom( kt ) !!---------------------------------------------------------------------- !! *** ROUTINE trd_vor *** !! !! ** Purpose : computation of cumulated trends over analysis period !! and make outputs (NetCDF format) !!---------------------------------------------------------------------- INTEGER , INTENT(in ) :: kt ! time step ! INTEGER :: ji, jj, jk, jl ! dummy loop indices INTEGER :: it, itmod ! local integers REAL(wp) :: zmean ! local scalars REAL(wp), DIMENSION(jpi,jpj) :: zun, zvn !!---------------------------------------------------------------------- ! ================= ! I. Initialization ! ================= !!$ ! I.1 set before values of vertically average u and v !!$ ! --------------------------------------------------- !!$ !!$ IF( kt > nit000 ) vor_avrb(:,:) = vor_avr(:,:) !!$ !!$ ! I.2 vertically integrated vorticity !!$ ! ---------------------------------- !!$ !!$ vor_avr (:,:) = 0._wp !!$ zun (:,:) = 0._wp !!$ zvn (:,:) = 0._wp !!$ vor_avrtot(:,:) = 0._wp !!$ vor_avrres(:,:) = 0._wp !!$ !!$ ! Vertically averaged velocity !!$ DO jk = 1, jpk - 1 !!$ zun(:,:) = zun(:,:) + e1u(:,:) * un(:,:,jk) * e3u_n(:,:,jk) !!$ zvn(:,:) = zvn(:,:) + e2v(:,:) * vn(:,:,jk) * e3v_n(:,:,jk) !!$ END DO !!$ !!$ zun(:,:) = zun(:,:) * r1_hu_n(:,:) !!$ zvn(:,:) = zvn(:,:) * r1_hv_n(:,:) !!$ !!$ ! Curl !!$ DO ji = 1, jpim1 !!$ DO jj = 1, jpjm1 !!$ vor_avr(ji,jj) = ( ( zvn(ji+1,jj) - zvn(ji,jj) ) & !!$ & - ( zun(ji,jj+1) - zun(ji,jj) ) ) / ( e1f(ji,jj) * e2f(ji,jj) ) * fmask(ji,jj,1) !!$ END DO !!$ END DO !!$ !!$ ! ================================= !!$ ! II. Cumulated trends !!$ ! ================================= !!$ !!$ ! II.1 set `before' mixed layer values for kt = nit000+1 !!$ ! ------------------------------------------------------ !!$ IF( kt == nit000+1 ) THEN !!$ vor_avrbb(:,:) = vor_avrb(:,:) !!$ vor_avrbn(:,:) = vor_avr (:,:) !!$ ENDIF !!$ !!$ ! II.2 cumulated trends over analysis period (kt=2 to nwrite) !!$ ! ---------------------- !!$ ! trends cumulated over nwrite-2 time steps !!$ !!$ IF( kt >= nit000+2 ) THEN !!$ nmoydpvor = nmoydpvor + 1 !!$ DO jl = 1, jpltot_vor !!$ IF( jl /= 9 ) THEN !!$ rotot(:,:) = rotot(:,:) + vortrd(:,:,jl) !!$ ENDIF !!$ END DO !!$ ENDIF !!$ !!$ ! ============================================= !!$ ! III. Output in netCDF + residual computation !!$ ! ============================================= !!$ !!$ ! define time axis !!$ it = kt !!$ itmod = kt - nit000 + 1 !!$ !!$ IF( MOD( it, nn_trd ) == 0 ) THEN !!$ !!$ ! III.1 compute total trend !!$ ! ------------------------ !!$ zmean = 1._wp / ( REAL( nmoydpvor, wp ) * 2._wp * rdt ) !!$ vor_avrtot(:,:) = ( vor_avr(:,:) - vor_avrbn(:,:) + vor_avrb(:,:) - vor_avrbb(:,:) ) * zmean !!$ !!$ !!$ ! III.2 compute residual !!$ ! --------------------- !!$ zmean = 1._wp / REAL( nmoydpvor, wp ) !!$ vor_avrres(:,:) = vor_avrtot(:,:) - rotot(:,:) / zmean !!$ !!$ ! Boundary conditions !!$ CALL lbc_lnk_multi( vor_avrtot, 'F', 1. , vor_avrres, 'F', 1. ) !!$ !!$ !!$ ! III.3 time evolution array swap !!$ ! ------------------------------ !!$ vor_avrbb(:,:) = vor_avrb(:,:) !!$ vor_avrbn(:,:) = vor_avr (:,:) !!$ ! !!$ nmoydpvor = 0 !!$ ! !!$ ENDIF ! III.4 write trends to output ! --------------------------- IF( kt >= nit000+1 ) THEN IF( iom_use("vort_prg_avg") ) CALL iom_put("vort_prg_avg",vortrd(:,:,jpvor_prg,jptype_vor_avg)) IF( iom_use("vort_keg_avg") ) CALL iom_put("vort_keg_avg",vortrd(:,:,jpvor_keg,jptype_vor_avg)) IF( iom_use("vort_rvo_avg") ) CALL iom_put("vort_rvo_avg",vortrd(:,:,jpvor_rvo,jptype_vor_avg)) IF( iom_use("vort_pvo_avg") ) CALL iom_put("vort_pvo_avg",vortrd(:,:,jpvor_pvo,jptype_vor_avg)) IF( iom_use("vort_ldf_avg") ) CALL iom_put("vort_ldf_avg",vortrd(:,:,jpvor_ldf,jptype_vor_avg)) IF( iom_use("vort_zad_avg") ) CALL iom_put("vort_zad_avg",vortrd(:,:,jpvor_zad,jptype_vor_avg)) IF( iom_use("vort_zdf_avg") ) CALL iom_put("vort_zdf_avg",vortrd(:,:,jpvor_zdf,jptype_vor_avg)) IF( iom_use("vort_spg_avg") ) CALL iom_put("vort_spg_avg",vortrd(:,:,jpvor_spg,jptype_vor_avg)) IF( iom_use("vort_swf_avg") ) CALL iom_put("vort_swf_avg",vortrd(:,:,jpvor_swf,jptype_vor_avg)) IF( iom_use("vort_bfr_avg") ) CALL iom_put("vort_bfr_avg",vortrd(:,:,jpvor_bfr,jptype_vor_avg)) IF( iom_use("vort_prg_int") ) CALL iom_put("vort_prg_int",vortrd(:,:,jpvor_prg,jptype_vor_int)) IF( iom_use("vort_keg_int") ) CALL iom_put("vort_keg_int",vortrd(:,:,jpvor_keg,jptype_vor_int)) IF( iom_use("vort_rvo_int") ) CALL iom_put("vort_rvo_int",vortrd(:,:,jpvor_rvo,jptype_vor_int)) IF( iom_use("vort_pvo_int") ) CALL iom_put("vort_pvo_int",vortrd(:,:,jpvor_pvo,jptype_vor_int)) IF( iom_use("vort_ldf_int") ) CALL iom_put("vort_ldf_int",vortrd(:,:,jpvor_ldf,jptype_vor_int)) IF( iom_use("vort_zad_int") ) CALL iom_put("vort_zad_int",vortrd(:,:,jpvor_zad,jptype_vor_int)) IF( iom_use("vort_zdf_int") ) CALL iom_put("vort_zdf_int",vortrd(:,:,jpvor_zdf,jptype_vor_int)) IF( iom_use("vort_spg_int") ) CALL iom_put("vort_spg_int",vortrd(:,:,jpvor_spg,jptype_vor_int)) IF( iom_use("vort_swf_int") ) CALL iom_put("vort_swf_int",vortrd(:,:,jpvor_prg,jptype_vor_int)) IF( iom_use("vort_bfr_int") ) CALL iom_put("vort_bfr_int",vortrd(:,:,jpvor_prg,jptype_vor_int)) ! ENDIF ! !!$ IF( MOD( it, nn_trd ) == 0 ) rotot(:,:)=0 ! END SUBROUTINE trd_vor_iom SUBROUTINE trd_vor_init !!---------------------------------------------------------------------- !! *** ROUTINE trd_vor_init *** !! !! ** Purpose : computation of vertically integrated T and S budgets !! from ocean surface down to control surface (NetCDF output) !!---------------------------------------------------------------------- ! =================== ! I. initialization ! =================== cvort='averaged-vor' ! Open specifier ndebug = 0 ! set it to 1 in case of problem to have more Print IF(lwp) THEN WRITE(numout,*) ' ' WRITE(numout,*) ' trd_vor_init: vorticity trends' WRITE(numout,*) ' ~~~~~~~~~~~~' WRITE(numout,*) ' ' WRITE(numout,*) ' ##########################################################################' WRITE(numout,*) ' CAUTION: The interpretation of the vorticity trends is' WRITE(numout,*) ' not obvious, please contact Anne-Marie TREGUIER at: treguier@ifremer.fr ' WRITE(numout,*) ' ##########################################################################' WRITE(numout,*) ' ' ENDIF IF( trd_vor_alloc() /= 0 ) CALL ctl_stop( 'STOP', 'trd_vor_init : unable to allocate trdvor arrays' ) n_hf_lastcalc = 0 vortrd(:,:,:,:) = 0.0 ! cumulated trends array init nmoydpvor = 0 rotot(:,:)=0 vor_avrtot(:,:)=0 vor_avrres(:,:)=0 IF( ndebug /= 0 ) THEN WRITE(numout,*) ' debuging trd_vor_init: I. done' CALL FLUSH(numout) ENDIF ! END SUBROUTINE trd_vor_init !!====================================================================== END MODULE trdvor