From 62ce784b8534f0521785639fad46d241075a77d8 Mon Sep 17 00:00:00 2001
From: Juan Escobar <escj@aero.obs-mip.fr>
Date: Tue, 7 Jul 2020 11:41:16 +0200
Subject: [PATCH] Juan 07/07/2020 : PGI BUG partially present , for CTURB =
"TKEL" replace allocatable -> pointer,contiguous ; allocate ->
MNH_ALLOCATE_ZT*D ; Some ARRAY SYNTAXE , with implicit copy inrelevenant ->
DO CONCURRENT
---
src/MNH/advection_metsv.f90 | 272 +++++++++++++++-------
src/MNH/emoist.f90 | 121 ++++++----
src/MNH/etheta.f90 | 52 +++--
src/MNH/gradient_u.f90 | 103 ++++++---
src/MNH/gradient_v.f90 | 123 ++++++----
src/MNH/gradient_w.f90 | 82 ++++---
src/MNH/mode_mnh_zwork.f90 | 349 ++++++++++++++++++++++++++---
src/MNH/mode_prandtl.f90 | 81 +++++--
src/MNH/ppm_met.f90 | 2 +-
src/MNH/prandtl.f90 | 373 ++++++++++++++++++++-----------
src/MNH/tke_eps_sources.f90 | 66 ++++--
src/MNH/tridiag_thermo.f90 | 238 ++++++++++++--------
src/MNH/tridiag_tke.f90 | 117 ++++++----
src/MNH/tridiag_w.f90 | 216 +++++++++++-------
src/MNH/tridiag_wind.f90 | 125 +++++++----
src/MNH/turb.f90 | 293 +++++++++++++++++-------
src/MNH/turb_hor_dyn_corr.f90 | 254 ++++++++++++++-------
src/MNH/turb_hor_splt.f90 | 102 +++++++--
src/MNH/turb_hor_sv_flux.f90 | 59 +++--
src/MNH/turb_hor_thermo_corr.f90 | 69 ++++--
src/MNH/turb_hor_thermo_flux.f90 | 166 ++++++++++----
src/MNH/turb_hor_tke.f90 | 101 +++++++--
src/MNH/turb_hor_uv.f90 | 203 +++++++++++------
src/MNH/turb_hor_uw.f90 | 129 +++++++----
src/MNH/turb_hor_vw.f90 | 111 ++++++---
src/MNH/turb_ver.f90 | 100 ++++++---
src/MNH/turb_ver_dyn_flux.f90 | 176 +++++++++++----
src/MNH/turb_ver_thermo_corr.f90 | 150 +++++++++----
src/MNH/turb_ver_thermo_flux.f90 | 119 +++++++---
29 files changed, 3086 insertions(+), 1266 deletions(-)
diff --git a/src/MNH/advection_metsv.f90 b/src/MNH/advection_metsv.f90
index abcc83011..1cc768b4e 100644
--- a/src/MNH/advection_metsv.f90
+++ b/src/MNH/advection_metsv.f90
@@ -179,6 +179,9 @@ USE MODI_PPM_SCALAR
#ifdef MNH_OPENACC
USE MODE_DEVICE
USE MODE_MNH_ZWORK, ONLY : ZT3D, MNH_GET_ZT3D , MNH_REL_ZT3D
+USE MODE_MNH_ZWORK, ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D, &
+ MNH_ALLOCATE_ZT4D , MNH_REL_ZT4D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
#endif
#ifdef MNH_BITREP
USE MODI_BITREP
@@ -232,45 +235,52 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PRTKES_ADV ! Advection TKE source te
!* 0.2 declarations of local variables
!
!
-REAL, DIMENSION(:,:,:),allocatable :: ZRUCPPM
-REAL, DIMENSION(:,:,:),allocatable :: ZRVCPPM
-REAL, DIMENSION(:,:,:),allocatable :: ZRWCPPM
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRUCPPM
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRVCPPM
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRWCPPM
! contravariant
! components
! of momentum
-REAL, DIMENSION(:,:,:),allocatable :: ZCFLU
-REAL, DIMENSION(:,:,:),allocatable :: ZCFLV
-REAL, DIMENSION(:,:,:),allocatable :: ZCFLW
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZCFLU
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZCFLV
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZCFLW
! ! CFL numbers on each direction
-REAL, DIMENSION(:,:,:),allocatable :: ZCFL
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZCFL
! ! CFL number
+INTEGER :: IZRUCPPM,IZRVCPPM,IZRWCPPM,IZCFLU,IZCFLV,IZCFLW,IZCFL
!
REAL :: ZCFLU_MAX, ZCFLV_MAX, ZCFLW_MAX, ZCFL_MAX ! maximum CFL numbers
!
-REAL, DIMENSION(:,:,:),allocatable :: ZTH
-REAL, DIMENSION(:,:,:),allocatable :: ZTKE
-REAL, DIMENSION(:,:,:),allocatable :: ZRTHS_OTHER
-REAL, DIMENSION(:,:,:),allocatable :: ZRTKES_OTHER
-REAL, DIMENSION(:,:,:),allocatable :: ZRTHS_PPM
-REAL, DIMENSION(:,:,:),allocatable :: ZRTKES_PPM
-REAL, DIMENSION(:,:,:,:),allocatable :: ZR
-REAL, DIMENSION(:,:,:,:),allocatable :: ZSV
-REAL, DIMENSION(:,:,:,:),allocatable :: ZSNWC
-REAL, DIMENSION(:,:,:,:),allocatable :: ZSNWC_INIT
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRSNWCS
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZTH
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZTKE
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRTHS_OTHER
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRTKES_OTHER
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRTHS_PPM
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRTKES_PPM
+INTEGER :: IZTH,IZTKE,IZRTHS_OTHER,IZRTKES_OTHER,IZRTHS_PPM,IZRTKES_PPM
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZR
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZSV
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZSNWC
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZSNWC_INIT
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRSNWCS
+INTEGER :: IZR,IZSV,IZSNWC,IZSNWC_INIT,IZRSNWCS
! Guess at the sub time step
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRRS_OTHER
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRSVS_OTHER
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRSNWCS_OTHER
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRRS_OTHER
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRSVS_OTHER
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRSNWCS_OTHER
+INTEGER :: IZRRS_OTHER,IZRSVS_OTHER,IZRSNWCS_OTHER
! Tendencies since the beginning of the time step
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRRS_PPM
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRSVS_PPM
-REAL, DIMENSION(:,:,:,:),allocatable :: ZRSNWCS_PPM
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRRS_PPM
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRSVS_PPM
+REAL, DIMENSION(:,:,:,:),pointer , contiguous :: ZRSNWCS_PPM
+INTEGER :: IZRRS_PPM,IZRSVS_PPM,IZRSNWCS_PPM
! Guess at the end of the sub time step
-REAL, DIMENSION(:,:,:),allocatable :: ZRHOX1,ZRHOX2
-REAL, DIMENSION(:,:,:),allocatable :: ZRHOY1,ZRHOY2
-REAL, DIMENSION(:,:,:),allocatable :: ZRHOZ1,ZRHOZ2
-REAL, DIMENSION(:,:,:),allocatable :: ZT,ZEXN,ZLV,ZLS,ZCPH
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRHOX1,ZRHOX2
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRHOY1,ZRHOY2
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZRHOZ1,ZRHOZ2
+REAL, DIMENSION(:,:,:),pointer , contiguous :: ZT,ZEXN,ZLV,ZLS,ZCPH
+INTEGER :: IZRHOX1,IZRHOX2,IZRHOY1,IZRHOY2,IZRHOZ1,IZRHOZ2 &
+ ,IZT,IZEXN,IZLV,IZLS,IZCPH
! Temporary advected rhodj for PPM routines
!
@@ -291,6 +301,9 @@ INTEGER :: IIB, IIE, IJB, IJE,IKB,IKE
INTEGER :: IZ1, IZ2
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JK
!-------------------------------------------------------------------------------
!$acc data present( PUT, PVT, PWT, PTHT, PTKET, PRHODJ, PPABST, PRT, PSVT, PTHVREF, &
!$acc & PDXX, PDYY, PDZZ, PDZX, PDZY, PRTHS, PRTKES, PRRS, PRSVS, PRTHS_CLD, PRRS_CLD, PRSVS_CLD, PRTKES_ADV )
@@ -322,43 +335,87 @@ IF (MPPDB_INITIALIZED) THEN
CALL MPPDB_CHECK(PRSVS,"ADVECTION_METSV beg:PRSVS")
END IF
-allocate( ZRUCPPM ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRVCPPM ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRWCPPM ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZCFLU ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZCFLV ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZCFLW ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZCFL ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZTH ( SIZE(PTHT, 1), SIZE(PTHT, 2), SIZE(PTHT, 3) ) )
-allocate( ZTKE ( SIZE(PTKET,1), SIZE(PTKET,2), SIZE(PTKET,3) ) )
-allocate( ZRTHS_OTHER ( SIZE(PTHT, 1), SIZE(PTHT, 2), SIZE(PTHT, 3) ) )
-allocate( ZRTKES_OTHER ( SIZE(PTKET,1), SIZE(PTKET,2), SIZE(PTKET,3) ) )
-allocate( ZRTHS_PPM ( SIZE(PTHT, 1), SIZE(PTHT, 2), SIZE(PTHT, 3) ) )
-allocate( ZRTKES_PPM ( SIZE(PTKET,1), SIZE(PTKET,2), SIZE(PTKET,3) ) )
-allocate( ZR ( SIZE(PRT, 1), SIZE(PRT, 2), SIZE(PRT, 3), SIZE(PRT, 4) ) )
-allocate( ZSV ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), SIZE(PSVT,4) ) )
-allocate( ZSNWC ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), NBLOWSNOW_2D ) )
-allocate( ZSNWC_INIT ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), NBLOWSNOW_2D ) )
-allocate( ZRSNWCS ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), NBLOWSNOW_2D ) )
-allocate( ZRRS_OTHER ( SIZE(PRT, 1), SIZE(PRT, 2), SIZE(PRT, 3), SIZE(PRT, 4) ) )
-allocate( ZRSVS_OTHER ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), SIZE(PSVT,4) ) )
-allocate( ZRSNWCS_OTHER( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), NBLOWSNOW_2D ) )
-allocate( ZRRS_PPM ( SIZE(PRT, 1), SIZE(PRT, 2), SIZE(PRT, 3), SIZE(PRT, 4) ) )
-allocate( ZRSVS_PPM ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), SIZE(PSVT,4) ) )
-allocate( ZRSNWCS_PPM ( SIZE(PSVT, 1), SIZE(PSVT, 2), SIZE(PSVT, 3), NBLOWSNOW_2D ) )
-allocate( ZRHOX1 ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRHOX2 ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRHOY1 ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRHOY2 ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRHOZ1 ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZRHOZ2 ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZT ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZEXN ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZLV ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZLS ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
-allocate( ZCPH ( SIZE(PUT, 1), SIZE(PUT, 2), SIZE(PUT, 3) ) )
+JIU = size(PUT, 1 )
+JJU = size(PUT, 2 )
+JKU = size(PUT, 3 )
+
+
+#ifndef MNH_OPENACC
+allocate( ZRUCPPM ( JIU,JJU,JKU ) )
+allocate( ZRVCPPM ( JIU,JJU,JKU ) )
+allocate( ZRWCPPM ( JIU,JJU,JKU ) )
+allocate( ZCFLU ( JIU,JJU,JKU ) )
+allocate( ZCFLV ( JIU,JJU,JKU ) )
+allocate( ZCFLW ( JIU,JJU,JKU ) )
+allocate( ZCFL ( JIU,JJU,JKU ) )
+allocate( ZTH ( JIU,JJU,JKU ) )
+allocate( ZTKE ( JIU,JJU,SIZE(PTKET,3) )
+allocate( ZRTHS_OTHER ( JIU,JJU,JKU ) )
+allocate( ZRTKES_OTHER ( JIU,JJU,SIZE(PTKET,3) )
+allocate( ZRTHS_PPM ( JIU,JJU,JKU ) )
+allocate( ZRTKES_PPM ( JIU,JJU,SIZE(PTKET,3) )
+allocate( ZR ( JIU,JJU,JKU, SIZE(PRT, 4) ) )
+allocate( ZSV ( JIU,JJU,JKU, SIZE(PSVT,4) ) )
+allocate( ZSNWC ( JIU,JJU,JKU, NBLOWSNOW_2D ) )
+allocate( ZSNWC_INIT ( JIU,JJU,JKU, NBLOWSNOW_2D ) )
+allocate( ZRSNWCS ( JIU,JJU,JKU, NBLOWSNOW_2D ) )
+allocate( ZRRS_OTHER ( JIU,JJU,JKU, SIZE(PRT, 4) ) )
+allocate( ZRSVS_OTHER ( JIU,JJU,JKU, SIZE(PSVT,4) ) )
+allocate( ZRSNWCS_OTHER( JIU,JJU,JKU, NBLOWSNOW_2D ) )
+allocate( ZRRS_PPM ( JIU,JJU,JKU, SIZE(PRT, 4) ) )
+allocate( ZRSVS_PPM ( JIU,JJU,JKU, SIZE(PSVT,4) ) )
+allocate( ZRSNWCS_PPM ( JIU,JJU,JKU, NBLOWSNOW_2D ) )
+allocate( ZRHOX1 ( JIU,JJU,JKU ) )
+allocate( ZRHOX2 ( JIU,JJU,JKU ) )
+allocate( ZRHOY1 ( JIU,JJU,JKU ) )
+allocate( ZRHOY2 ( JIU,JJU,JKU ) )
+allocate( ZRHOZ1 ( JIU,JJU,JKU ) )
+allocate( ZRHOZ2 ( JIU,JJU,JKU ) )
+allocate( ZT ( JIU,JJU,JKU ) )
+allocate( ZEXN ( JIU,JJU,JKU ) )
+allocate( ZLV ( JIU,JJU,JKU ) )
+allocate( ZLS ( JIU,JJU,JKU ) )
+allocate( ZCPH ( JIU,JJU,JKU ) )
+#else
+CALL MNH_CHECK_IN_ZT3D("ADVECTION_METSV")
+IZRUCPPM = MNH_ALLOCATE_ZT3D( ZRUCPPM , JIU,JJU,JKU )
+IZRVCPPM = MNH_ALLOCATE_ZT3D( ZRVCPPM , JIU,JJU,JKU )
+IZRWCPPM = MNH_ALLOCATE_ZT3D( ZRWCPPM , JIU,JJU,JKU )
+IZCFLU = MNH_ALLOCATE_ZT3D( ZCFLU , JIU,JJU,JKU )
+IZCFLV = MNH_ALLOCATE_ZT3D( ZCFLV , JIU,JJU,JKU )
+IZCFLW = MNH_ALLOCATE_ZT3D( ZCFLW , JIU,JJU,JKU )
+IZCFL = MNH_ALLOCATE_ZT3D( ZCFL , JIU,JJU,JKU )
+IZTH = MNH_ALLOCATE_ZT3D( ZTH , JIU,JJU,JKU )
+IZTKE = MNH_ALLOCATE_ZT3D( ZTKE , JIU,JJU,SIZE(PTKET,3) )
+IZRTHS_OTHER = MNH_ALLOCATE_ZT3D( ZRTHS_OTHER , JIU,JJU,JKU )
+IZRTKES_OTHER = MNH_ALLOCATE_ZT3D( ZRTKES_OTHER , JIU,JJU,SIZE(PTKET,3) )
+IZRTHS_PPM = MNH_ALLOCATE_ZT3D( ZRTHS_PPM , JIU,JJU,JKU )
+IZRTKES_PPM = MNH_ALLOCATE_ZT3D( ZRTKES_PPM , JIU,JJU,SIZE(PTKET,3) )
+IZR = MNH_ALLOCATE_ZT4D( ZR , JIU,JJU,JKU, SIZE(PRT, 4) )
+IZSV = MNH_ALLOCATE_ZT4D( ZSV , JIU,JJU,JKU, SIZE(PSVT,4) )
+IZSNWC = MNH_ALLOCATE_ZT4D( ZSNWC , JIU,JJU,JKU, NBLOWSNOW_2D )
+IZSNWC_INIT = MNH_ALLOCATE_ZT4D( ZSNWC_INIT , JIU,JJU,JKU, NBLOWSNOW_2D )
+IZRSNWCS = MNH_ALLOCATE_ZT4D( ZRSNWCS , JIU,JJU,JKU, NBLOWSNOW_2D )
+IZRRS_OTHER = MNH_ALLOCATE_ZT4D( ZRRS_OTHER , JIU,JJU,JKU, SIZE(PRT, 4) )
+IZRSVS_OTHER = MNH_ALLOCATE_ZT4D( ZRSVS_OTHER , JIU,JJU,JKU, SIZE(PSVT,4) )
+IZRSNWCS_OTHER = MNH_ALLOCATE_ZT4D( ZRSNWCS_OTHER, JIU,JJU,JKU, NBLOWSNOW_2D )
+IZRRS_PPM = MNH_ALLOCATE_ZT4D( ZRRS_PPM , JIU,JJU,JKU, SIZE(PRT, 4) )
+IZRSVS_PPM = MNH_ALLOCATE_ZT4D( ZRSVS_PPM , JIU,JJU,JKU, SIZE(PSVT,4) )
+IZRSNWCS_PPM = MNH_ALLOCATE_ZT4D( ZRSNWCS_PPM , JIU,JJU,JKU, NBLOWSNOW_2D )
+IZRHOX1 = MNH_ALLOCATE_ZT3D( ZRHOX1 , JIU,JJU,JKU )
+IZRHOX2 = MNH_ALLOCATE_ZT3D( ZRHOX2 , JIU,JJU,JKU )
+IZRHOY1 = MNH_ALLOCATE_ZT3D( ZRHOY1 , JIU,JJU,JKU )
+IZRHOY2 = MNH_ALLOCATE_ZT3D( ZRHOY2 , JIU,JJU,JKU )
+IZRHOZ1 = MNH_ALLOCATE_ZT3D( ZRHOZ1 , JIU,JJU,JKU )
+IZRHOZ2 = MNH_ALLOCATE_ZT3D( ZRHOZ2 , JIU,JJU,JKU )
+IZT = MNH_ALLOCATE_ZT3D( ZT , JIU,JJU,JKU )
+IZEXN = MNH_ALLOCATE_ZT3D( ZEXN , JIU,JJU,JKU )
+IZLV = MNH_ALLOCATE_ZT3D( ZLV , JIU,JJU,JKU )
+IZLS = MNH_ALLOCATE_ZT3D( ZLS , JIU,JJU,JKU )
+IZCPH = MNH_ALLOCATE_ZT3D( ZCPH , JIU,JJU,JKU )
+#endif
-!$acc data create( ZRUCPPM, ZRVCPPM, ZRWCPPM, ZCFLU, ZCFLV, ZCFLW, ZCFL, ZTH, &
+!$acc data present( ZRUCPPM, ZRVCPPM, ZRWCPPM, ZCFLU, ZCFLV, ZCFLW, ZCFL, ZTH, &
!$acc & ZTKE, ZRTHS_OTHER, ZRTKES_OTHER, ZRTHS_PPM, ZRTKES_PPM, &
!$acc & ZR, ZSV, ZSNWC, ZSNWC_INIT, ZRSNWCS, ZRRS_OTHER, ZRSVS_OTHER, ZRSNWCS_OTHER, &
!$acc & ZRRS_PPM, ZRSVS_PPM, ZRSNWCS_PPM, ZRHOX1, ZRHOX2, ZRHOY1, ZRHOY2, ZRHOZ1, ZRHOZ2, &
@@ -449,26 +506,37 @@ END IF
!* 2.2 computes CFL numbers
!
!PW: not necessary: data already on device due to contrav_device !$acc update device(ZRUCPPM,ZRVCPPM,ZRWCPPM)
-!$acc kernels
+! acc kernels
IF (.NOT. L1D) THEN
+ !$acc kernels
ZCFLU(:,:,:) = 0.0 ; ZCFLV(:,:,:) = 0.0 ; ZCFLW(:,:,:) = 0.0
ZCFLU(IIB:IIE,IJB:IJE,:) = ABS(ZRUCPPM(IIB:IIE,IJB:IJE,:) * PTSTEP)
ZCFLV(IIB:IIE,IJB:IJE,:) = ABS(ZRVCPPM(IIB:IIE,IJB:IJE,:) * PTSTEP)
ZCFLW(IIB:IIE,IJB:IJE,:) = ABS(ZRWCPPM(IIB:IIE,IJB:IJE,:) * PTSTEP)
+ !$acc end kernels
#ifndef MNH_BITREP
IF (.NOT. L2D) THEN
- ZCFL(:,:,:) = SQRT(ZCFLU(:,:,:)**2+ZCFLV(:,:,:)**2+ZCFLW(:,:,:)**2)
+ !$acc kernels
+ ZCFL(:,:,:) = SQRT(ZCFLU(:,:,:)**2+ZCFLV(:,:,:)**2+ZCFLW(:,:,:)**2)
+ !$acc end kernels
ELSE
- ZCFL(:,:,:) = SQRT(ZCFLU(:,:,:)**2+ZCFLW(:,:,:)**2)
+ !$acc kernels
+ ZCFL(:,:,:) = SQRT(ZCFLU(:,:,:)**2+ZCFLW(:,:,:)**2)
+ !$acc end kernels
END IF
#else
IF (.NOT. L2D) THEN
- ZCFL(:,:,:) = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLV(:,:,:))+BR_P2(ZCFLW(:,:,:)))
+ !$acc kernels
+ ZCFL(:,:,:) = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLV(:,:,:))+BR_P2(ZCFLW(:,:,:)))
+ !$acc end kernels
ELSE
- ZCFL(:,:,:) = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLW(:,:,:)))
+ !$acc kernels
+ ZCFL(:,:,:) = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLW(:,:,:)))
+ !$acc end kernels
END IF
-#endif
+#endif
ELSE
+ !$acc kernels
ZCFLU(:,:,:) = 0.0 ; ZCFLV(:,:,:) = 0.0 ; ZCFLW(:,:,:) = 0.0
ZCFLW(IIB:IIE,IJB:IJE,:) = ABS(ZRWCPPM(IIB:IIE,IJB:IJE,:) * PTSTEP)
#ifndef MNH_BITREP
@@ -476,8 +544,9 @@ ELSE
#else
ZCFL(:,:,:) = SQRT(BR_P2(ZCFLW(:,:,:)))
#endif
+ !$acc end kernels
END IF
-!$acc end kernels
+! acc end kernels
!
!* prints in the file the 3D Courant numbers (one should flag this)
!
@@ -704,11 +773,13 @@ CALL PPM_RHODJ(HLBCX,HLBCY, ZRUCPPM, ZRVCPPM, ZRWCPPM, &
!* values of the fields at the beginning of the time splitting loop
!$acc kernels
ZTH(:,:,:) = PTHT(:,:,:)
-ZTKE(:,:,:) = PTKET(:,:,:)
IF (KRR /=0 ) ZR(:,:,:,:) = PRT(:,:,:,:)
IF (KSV /=0 ) ZSV(:,:,:,:) = PSVT(:,:,:,:)
!
-IF (GTKE) PRTKES_ADV(:,:,:) = 0.
+IF (GTKE) THEN
+ PRTKES_ADV(:,:,:) = 0.
+ ZTKE(:,:,:) = PTKET(:,:,:)
+END IF
!$acc end kernels
!
IF(LBLOWSNOW) THEN
@@ -749,29 +820,41 @@ DO JSPL=1,KSPLIT
!
! Tendencies of PPM
!
-!$acc kernels
+! acc kernels
+ !$acc kernels
PRTHS(:,:,:) = PRTHS (:,:,:) + ZRTHS_PPM (:,:,:) / KSPLIT
IF (GTKE) PRTKES_ADV(:,:,:) = PRTKES_ADV(:,:,:) + ZRTKES_PPM(:,:,:) / KSPLIT
IF (KRR /=0) PRRS (:,:,:,:) = PRRS (:,:,:,:) + ZRRS_PPM (:,:,:,:) / KSPLIT
IF (KSV /=0 ) PRSVS (:,:,:,:) = PRSVS (:,:,:,:) + ZRSVS_PPM (:,:,:,:) / KSPLIT
+ !$acc end kernels
!
IF (JSPL<KSPLIT) THEN
!
! Guesses of the field inside the time splitting loop
!
+ !$acc kernels
ZTH(:,:,:) = ZTH(:,:,:) + ( ZRTHS_PPM(:,:,:) + ZRTHS_OTHER(:,:,:) + PRTHS_CLD(:,:,:)) * &
- ZTSTEP_PPM / PRHODJ(:,:,:)
- IF (GTKE) ZTKE(:,:,:) = ZTKE(:,:,:) + ( ZRTKES_PPM(:,:,:) + ZRTKES_OTHER(:,:,:) ) * ZTSTEP_PPM / PRHODJ(:,:,:)
+ ZTSTEP_PPM / PRHODJ(:,:,:)
+ !$acc end kernels
+ IF (GTKE) THEN
+ !$acc kernels
+ ZTKE(:,:,:) = ZTKE(:,:,:) + ( ZRTKES_PPM(:,:,:) + ZRTKES_OTHER(:,:,:) ) * ZTSTEP_PPM / PRHODJ(:,:,:)
+ !$acc end kernels
+ END IF
+ !$acc kernels
+ !$acc loop seq
DO JR = 1, KRR
- ZR(:,:,:,JR) = ZR(:,:,:,JR) + ( ZRRS_PPM(:,:,:,JR) + ZRRS_OTHER(:,:,:,JR) + PRRS_CLD(:,:,:,JR) ) &
- * ZTSTEP_PPM / PRHODJ(:,:,:)
+ ZR(:,:,:,JR) = ZR(:,:,:,JR) + ( ZRRS_PPM(:,:,:,JR) + ZRRS_OTHER(:,:,:,JR) + PRRS_CLD(:,:,:,JR) ) &
+ * ZTSTEP_PPM / PRHODJ(:,:,:)
END DO
+ !$acc loop seq
DO JSV = 1, KSV
- ZSV(:,:,:,JSV) = ZSV(:,:,:,JSV) + ( ZRSVS_PPM(:,:,:,JSV) + ZRSVS_OTHER(:,:,:,JSV) + &
- PRSVS_CLD(:,:,:,JSV) ) * ZTSTEP_PPM / PRHODJ(:,:,:)
+ ZSV(:,:,:,JSV) = ZSV(:,:,:,JSV) + ( ZRSVS_PPM(:,:,:,JSV) + ZRSVS_OTHER(:,:,:,JSV) + &
+ PRSVS_CLD(:,:,:,JSV) ) * ZTSTEP_PPM / PRHODJ(:,:,:)
END DO
+ !$acc end kernels
END IF
-!$acc end kernels
+! acc end kernels
!PW: bug PGI 18.10: not necessary for PRRS,PRSVS but error with decriptor not present
!$acc update self(PRRS,PRSVS)
@@ -967,6 +1050,33 @@ END IF
!$acc end data
+#ifndef MNH_OPENACC
+deallocate ( ZRUCPPM, ZRVCPPM, ZRWCPPM, ZCFLU, ZCFLV, ZCFLW, ZCFL, ZTH, &
+ ZTKE, ZRTHS_OTHER, ZRTKES_OTHER, ZRTHS_PPM, ZRTKES_PPM, &
+ ZR, ZSV, ZSNWC, ZSNWC_INIT, ZRSNWCS, ZRRS_OTHER, ZRSVS_OTHER, ZRSNWCS_OTHER, &
+ ZRRS_PPM, ZRSVS_PPM, ZRSNWCS_PPM, ZRHOX1, ZRHOX2, ZRHOY1, ZRHOY2, ZRHOZ1, ZRHOZ2, &
+ ZT, ZEXN, ZLV, ZLS, ZCPH )
+#else
+CALL MNH_REL_ZT3D ( IZRHOX1, IZRHOX2, IZRHOY1, IZRHOY2, IZRHOZ1, IZRHOZ2, &
+ IZT, IZEXN, IZLV, IZLS, IZCPH )
+
+CALL MNH_REL_ZT4D ( NBLOWSNOW_2D , IZRSNWCS_PPM )
+CALL MNH_REL_ZT4D ( SIZE(PSVT,4) , IZRSVS_PPM )
+CALL MNH_REL_ZT4D ( SIZE(PRT, 4) , IZRRS_PPM )
+CALL MNH_REL_ZT4D ( NBLOWSNOW_2D , IZRSNWCS_OTHER )
+CALL MNH_REL_ZT4D ( SIZE(PSVT,4) , IZRSVS_OTHER )
+CALL MNH_REL_ZT4D ( SIZE(PRT, 4) , IZRRS_OTHER )
+CALL MNH_REL_ZT4D ( NBLOWSNOW_2D , IZRSNWCS )
+CALL MNH_REL_ZT4D ( NBLOWSNOW_2D , IZSNWC_INIT )
+CALL MNH_REL_ZT4D ( NBLOWSNOW_2D , IZSNWC )
+CALL MNH_REL_ZT4D ( SIZE(PSVT,4) , IZSV )
+CALL MNH_REL_ZT4D ( SIZE(PRT, 4) , IZR )
+
+CALL MNH_REL_ZT3D ( IZRUCPPM, IZRVCPPM, IZRWCPPM, IZCFLU, IZCFLV, IZCFLW, IZCFL, IZTH, &
+ IZTKE, IZRTHS_OTHER, IZRTKES_OTHER, IZRTHS_PPM, IZRTKES_PPM )
+CALL MNH_CHECK_OUT_ZT3D("ADVECTION_METSV")
+#endif
+
!$acc end data
END SUBROUTINE ADVECTION_METSV
diff --git a/src/MNH/emoist.f90 b/src/MNH/emoist.f90
index 891977a24..6486ce73f 100644
--- a/src/MNH/emoist.f90
+++ b/src/MNH/emoist.f90
@@ -41,7 +41,6 @@ END SUBROUTINE EMOIST
END INTERFACE
!
END MODULE MODI_EMOIST
-!
! ############################################################################
#ifndef MNH_OPENACC
FUNCTION EMOIST(KRR,KRRI,PTHLM,PRM,PLOCPEXNM,PAMOIST,PSRCM) RESULT(PEMOIST)
@@ -101,6 +100,10 @@ USE MODD_CST
use mode_mppdb
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK
+#endif
+
IMPLICIT NONE
!
!* 0.1 declarations of arguments and result
@@ -125,10 +128,13 @@ REAL,DIMENSION(:,:,:), INTENT(OUT):: PEMOIST ! result
!
!* 0.2 declarations of local variables
!
-REAL,DIMENSION(:,:,:), allocatable :: ZA, ZRW
+REAL,DIMENSION(:,:,:), pointer,contiguous :: ZA, ZRW
+INTEGER :: IZA,IZRW
! ZA = coeft A, ZRW = total mixing ratio rw
REAL :: ZDELTA ! = Rv/Rd - 1
INTEGER :: JRR ! moist loop counter
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!
!---------------------------------------------------------------------------
@@ -143,74 +149,95 @@ if ( mppdb_initialized ) then
call Mppdb_check( psrcm, "Emoist beg:psrcm" )
end if
-allocate( za ( size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zrw ( size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size( pthlm, 1 )
+JJU = size( pthlm, 2 )
+JKU = size( pthlm, 3 )
-!$acc data create( za, zrw )
+#ifndef MNH_OPENACC
+allocate( za (JIU,JJU,JKU) )
+allocate( zrw (JIU,JJU,JKU ) )
+#else
+IZA = MNH_ALLOCATE_ZT3D( za , JIU,JJU,JKU )
+IZRW = MNH_ALLOCATE_ZT3D( zrw , JIU,JJU,JKU )
+#endif
+
+!$acc data present( za, zrw )
!
!* 1. COMPUTE EMOIST
! --------------
!
!
-!$acc kernels
+!acc kernels
IF ( KRR == 0 ) THEN ! dry case
- PEMOIST(:,:,:) = 0.
+!$acc kernels
+ PEMOIST(1:JIU,1:JJU,1:JKU) = 0.
+!$acc end kernels
ELSE IF ( KRR == 1 ) THEN ! only vapor
+!$acc kernels
ZDELTA = (XRV/XRD) - 1.
- PEMOIST(:,:,:) = ZDELTA*PTHLM(:,:,:)
+ PEMOIST(1:JIU,1:JJU,1:JKU) = ZDELTA*PTHLM(1:JIU,1:JJU,1:JKU)
+!$acc end kernels
ELSE ! liquid water & ice present
+!$acc kernels
ZDELTA = (XRV/XRD) - 1.
- ZRW(:,:,:) = PRM(:,:,:,1)
-!
- IF ( KRRI>0) THEN ! rc and ri case
- ZRW(:,:,:) = ZRW(:,:,:) + PRM(:,:,:,3)
- DO JRR=5,KRR
- ZRW(:,:,:) = ZRW(:,:,:) + PRM(:,:,:,JRR)
- ENDDO
- ZA(:,:,:) = 1. + ( & ! Compute A
- (1.+ZDELTA) * (PRM(:,:,:,1) - PRM(:,:,:,2) - PRM(:,:,:,4)) &
- -ZRW(:,:,:) &
- ) / (1. + ZRW(:,:,:))
+ ZRW(1:JIU,1:JJU,1:JKU) = PRM(1:JIU,1:JJU,1:JKU,1)
+!$acc end kernels
+!
+ IF ( KRRI>0) THEN ! rc and ri case
+!$acc kernels
+ ZRW(1:JIU,1:JJU,1:JKU) = ZRW(1:JIU,1:JJU,1:JKU) + PRM(1:JIU,1:JJU,1:JKU,3)
+ DO JRR=5,KRR
+ ZRW(1:JIU,1:JJU,1:JKU) = ZRW(1:JIU,1:JJU,1:JKU) + PRM(1:JIU,1:JJU,1:JKU,JRR)
+ ENDDO
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = 1. + ( & ! Compute A
+ (1.+ZDELTA) * (PRM(JI,JJ,JK,1) - PRM(JI,JJ,JK,2) - PRM(JI,JJ,JK,4)) &
+ -ZRW(JI,JJ,JK) &
+ ) / (1. + ZRW(JI,JJ,JK))
+ END DO !CONCURRENT
!
! Emoist = ZB + ZC * Amoist
! ZB is computed from line 1 to line 2
! ZC is computed from line 3 to line 5
! Amoist* 2 * SRC is computed at line 6
!
- PEMOIST(:,:,:) = ZDELTA * (PTHLM(:,:,:) + PLOCPEXNM(:,:,:)*( &
- PRM(:,:,:,2)+PRM(:,:,:,4)))&
- / (1. + ZRW(:,:,:)) &
- +( PLOCPEXNM(:,:,:) * ZA(:,:,:) &
- -(1.+ZDELTA) * (PTHLM(:,:,:) + PLOCPEXNM(:,:,:)*( &
- PRM(:,:,:,2)+PRM(:,:,:,4)))&
- / (1. + ZRW(:,:,:)) &
- ) * PAMOIST(:,:,:) * 2. * PSRCM(:,:,:)
- ELSE
+ PEMOIST(1:JIU,1:JJU,1:JKU) = ZDELTA * (PTHLM(1:JIU,1:JJU,1:JKU) + PLOCPEXNM(1:JIU,1:JJU,1:JKU)*( &
+ PRM(1:JIU,1:JJU,1:JKU,2)+PRM(1:JIU,1:JJU,1:JKU,4)))&
+ / (1. + ZRW(1:JIU,1:JJU,1:JKU)) &
+ +( PLOCPEXNM(1:JIU,1:JJU,1:JKU) * ZA(1:JIU,1:JJU,1:JKU) &
+ -(1.+ZDELTA) * (PTHLM(1:JIU,1:JJU,1:JKU) + PLOCPEXNM(1:JIU,1:JJU,1:JKU)*( &
+ PRM(1:JIU,1:JJU,1:JKU,2)+PRM(1:JIU,1:JJU,1:JKU,4)))&
+ / (1. + ZRW(1:JIU,1:JJU,1:JKU)) &
+ ) * PAMOIST(1:JIU,1:JJU,1:JKU) * 2. * PSRCM(1:JIU,1:JJU,1:JKU)
+!$acc end kernels
+ ELSE
+!$acc kernels
DO JRR=3,KRR
- ZRW(:,:,:) = ZRW(:,:,:) + PRM(:,:,:,JRR)
- ENDDO
- ZA(:,:,:) = 1. + ( & ! Compute ZA
- (1.+ZDELTA) * (PRM(:,:,:,1) - PRM(:,:,:,2)) &
- -ZRW(:,:,:) &
- ) / (1. + ZRW(:,:,:))
+ ZRW(1:JIU,1:JJU,1:JKU) = ZRW(1:JIU,1:JJU,1:JKU) + PRM(1:JIU,1:JJU,1:JKU,JRR)
+ ENDDO
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = 1. + ( & ! Compute ZA
+ (1.+ZDELTA) * (PRM(JI,JJ,JK,1) - PRM(JI,JJ,JK,2)) &
+ -ZRW(JI,JJ,JK) &
+ ) / (1. + ZRW(JI,JJ,JK))
+ END DO !CONCURRENT
!
! Emoist = ZB + ZC * Amoist
! ZB is computed from line 1 to line 2
! ZC is computed from line 3 to line 5
! Amoist* 2 * SRC is computed at line 6
!
- PEMOIST(:,:,:) = ZDELTA * (PTHLM(:,:,:) + PLOCPEXNM(:,:,:)*PRM(:,:,:,2)) &
- / (1. + ZRW(:,:,:)) &
- +( PLOCPEXNM(:,:,:) * ZA(:,:,:) &
- -(1.+ZDELTA) * (PTHLM(:,:,:) + PLOCPEXNM(:,:,:)*PRM(:,:,:,2)) &
- / (1. + ZRW(:,:,:)) &
- ) * PAMOIST(:,:,:) * 2. * PSRCM(:,:,:)
+ PEMOIST(1:JIU,1:JJU,1:JKU) = ZDELTA * (PTHLM(1:JIU,1:JJU,1:JKU) + PLOCPEXNM(1:JIU,1:JJU,1:JKU)*PRM(1:JIU,1:JJU,1:JKU,2)) &
+ / (1. + ZRW(1:JIU,1:JJU,1:JKU)) &
+ +( PLOCPEXNM(1:JIU,1:JJU,1:JKU) * ZA(1:JIU,1:JJU,1:JKU) &
+ -(1.+ZDELTA) * (PTHLM(1:JIU,1:JJU,1:JKU) + PLOCPEXNM(1:JIU,1:JJU,1:JKU)*PRM(1:JIU,1:JJU,1:JKU,2)) &
+ / (1. + ZRW(1:JIU,1:JJU,1:JKU)) &
+ ) * PAMOIST(1:JIU,1:JJU,1:JKU) * 2. * PSRCM(1:JIU,1:JJU,1:JKU)
+!$acc end kernels
END IF
END IF
-!$acc end kernels
-
-deallocate( za, zrw )
+! acc end kernels
if ( mppdb_initialized ) then
!Check all out arrays
@@ -219,6 +246,12 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( za, zrw )
+#else
+CALL MNH_REL_ZT3D( iza, izrw )
+#endif
+
!$acc end data
!---------------------------------------------------------------------------
@@ -228,3 +261,5 @@ END FUNCTION EMOIST
#else
END SUBROUTINE EMOIST
#endif
+
+END MODULE MODI_EMOIST
diff --git a/src/MNH/etheta.f90 b/src/MNH/etheta.f90
index 53c6580c5..b5f92ac02 100644
--- a/src/MNH/etheta.f90
+++ b/src/MNH/etheta.f90
@@ -103,6 +103,10 @@ USE MODD_CST
use mode_mppdb
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D, &
+ MNH_ALLOCATE_ZT4D , MNH_REL_ZT4D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
+
IMPLICIT NONE
!
!* 0.1 declarations of arguments and result
@@ -130,8 +134,9 @@ REAL, DIMENSION(:,:,:), INTENT(OUT):: PETHETA ! result
!
!* 0.2 declarations of local variables
!
-REAL,DIMENSION(:,:,:), allocatable :: ZA, ZRW
+REAL,DIMENSION(:,:,:), pointer , contiguous :: ZA, ZRW
! ZA = coeft A, ZRW = total mixing ratio rw
+INTEGER :: IZA, IZRW
REAL :: ZDELTA ! = Rv/Rd - 1
INTEGER :: JRR ! moist loop counter
!
@@ -148,27 +153,39 @@ if ( mppdb_initialized ) then
call Mppdb_check( psrcm, "Etheta beg:psrcm" )
end if
+#ifndef MNH_OPENACC
allocate( za ( size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
allocate( zrw ( size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+#else
+iza = MNH_ALLOCATE_ZT3D( za , size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) )
+izrw = MNH_ALLOCATE_ZT3D( zrw , size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) )
+#endif
-!$acc data create( za, zrw )
+!$acc data present( za, zrw )
!
!* 1. COMPUTE ETHETA
! --------------
!
!
-!$acc kernels
-IF ( KRR == 0 ) THEN ! dry case
- PETHETA(:,:,:) = 1.
+! acc kernels
+IF ( KRR == 0 ) THEN ! dry case
+ !$acc kernels
+ PETHETA(:,:,:) = 1.
+ !$acc end kernels
ELSE IF ( KRR == 1 ) THEN ! only vapor
- ZDELTA = (XRV/XRD) - 1.
- PETHETA(:,:,:) = 1. + ZDELTA*PRM(:,:,:,1)
+ !$acc kernels
+ ZDELTA = (XRV/XRD) - 1.
+ PETHETA(:,:,:) = 1. + ZDELTA*PRM(:,:,:,1)
+ !$acc end kernels
ELSE ! liquid water & ice present
- ZDELTA = (XRV/XRD) - 1.
- ZRW(:,:,:) = PRM(:,:,:,1)
+ !$acc kernels
+ ZDELTA = (XRV/XRD) - 1.
+ ZRW(:,:,:) = PRM(:,:,:,1)
+ !$acc end kernels
!
IF ( KRRI>0 ) THEN ! rc and ri case
+ !$acc kernels
ZRW(:,:,:) = ZRW(:,:,:) + PRM(:,:,:,3)
DO JRR=5,KRR
ZRW(:,:,:) = ZRW(:,:,:) + PRM(:,:,:,JRR)
@@ -188,7 +205,9 @@ ELSE ! liquid water & ice present
PRM(:,:,:,2)+PRM(:,:,:,4)))&
/ (1. + ZRW(:,:,:)) &
) * PATHETA(:,:,:) * 2. * PSRCM(:,:,:)
- ELSE
+ !$acc end kernels
+ ELSE
+ !$acc kernels
DO JRR=3,KRR
ZRW(:,:,:) = ZRW(:,:,:) + PRM(:,:,:,JRR)
ENDDO
@@ -206,11 +225,10 @@ ELSE ! liquid water & ice present
-(1.+ZDELTA) * (PTHLM(:,:,:) + PLOCPEXNM(:,:,:)*PRM(:,:,:,2)) &
/ (1. + ZRW(:,:,:)) &
) * PATHETA(:,:,:) * 2. * PSRCM(:,:,:)
- END IF
+ !$acc end kernels
+ END IF
END IF
-!$acc end kernels
-
-deallocate( za, zrw )
+! acc end kernels
if ( mppdb_initialized ) then
!Check all out arrays
@@ -219,6 +237,12 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate (za, zrw)
+#else
+CALL MNH_REL_ZT3D(iza, izrw)
+#endif
+
!$acc end data
!---------------------------------------------------------------------------
diff --git a/src/MNH/gradient_u.f90 b/src/MNH/gradient_u.f90
index 0dde760c7..fa743bbd8 100644
--- a/src/MNH/gradient_u.f90
+++ b/src/MNH/gradient_u.f90
@@ -31,7 +31,7 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDXX ! metric coefficient dxx
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZX ! metric coefficient dzx
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGX_U_M_DEVICE ! result mass point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGX_U_M_DEVICE ! result mass point
!
END SUBROUTINE GX_U_M_DEVICE
#endif
@@ -58,7 +58,7 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDYY ! metric coefficient dyy
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZY ! metric coefficient dzy
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGY_U_UV_DEVICE ! result UV point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGY_U_UV_DEVICE ! result UV point
!
END SUBROUTINE GY_U_UV_DEVICE
#endif
@@ -81,7 +81,7 @@ INTEGER, INTENT(IN) :: KL ! +1 if grid goes from ground to
REAL, DIMENSION(:,:,:), INTENT(IN) :: PA ! variable at the U point
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGZ_U_UW_DEVICE ! result UW point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGZ_U_UW_DEVICE ! result UW point
!
END SUBROUTINE GZ_U_UW_DEVICE
#endif
@@ -201,6 +201,8 @@ END FUNCTION GX_U_M
USE MODI_SHUMAN_DEVICE
USE MODD_CONF
!
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
+!
IMPLICIT NONE
!
!
@@ -213,24 +215,28 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDXX ! metric coefficient dxx
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZX ! metric coefficient dzx
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGX_U_M_DEVICE ! result mass point
-!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
-!
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGX_U_M_DEVICE ! result mass point
!
!* 0.2 declaration of local variables
!
-! NONE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE
!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!----------------------------------------------------------------------------
!$acc data present( PA, PDXX, PDZZ, PDZX, PGX_U_M_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
+
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
-!$acc data create( ztmp1_device, ztmp2_device, ztmp3_device )
+!$acc data present( ztmp1_device, ztmp2_device, ztmp3_device )
!
!* 1. DEFINITION of GX_U_M_DEVICE
@@ -238,12 +244,16 @@ allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
IF (.NOT. LFLAT) THEN
CALL DXF_DEVICE(PA,ZTMP1_DEVICE)
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP2_DEVICE)
- !$acc kernels
- ZTMP3_DEVICE(:,:,:) = PDZX(:,:,:) * ZTMP2_DEVICE(:,:,:)
+ !$acc kernels loop independent collapse(3)
+ DO JK=1,JKU ; DO JJ=1,JJU ; DO JI=1,JIU
+ ZTMP3_DEVICE(JI,JJ,JK) = PDZX(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+ END DO ; END DO ; END DO
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KL,ZTMP3_DEVICE,ZTMP2_DEVICE)
CALL MXF_DEVICE(PDXX,ZTMP3_DEVICE)
@@ -260,6 +270,8 @@ END IF
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device,iztmp3_device)
+
!$acc end data
!----------------------------------------------------------------------------
@@ -375,6 +387,8 @@ END FUNCTION GY_U_UV
USE MODI_SHUMAN_DEVICE
USE MODD_CONF
!
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
+!
IMPLICIT NONE
!
!
@@ -387,24 +401,30 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDYY ! metric coefficient dyy
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZY ! metric coefficient dzy
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGY_U_UV_DEVICE ! result UV point
-!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGY_U_UV_DEVICE ! result UV point
!
!
!* 0.2 declaration of local variables
!
-! NONE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!
!----------------------------------------------------------------------------
!$acc data present( PA, PDYY, PDZZ, PDZY, PGY_U_UV_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
+
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
-!$acc data create( ztmp1_device, ztmp2_device, ztmp3_device )
+!$acc data present( ztmp1_device, ztmp2_device, ztmp3_device )
!
!* 1. DEFINITION of GY_U_UV_DEVICE
@@ -414,18 +434,24 @@ IF (.NOT. LFLAT) THEN
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP1_DEVICE)
CALL MXM_DEVICE(PDZZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK)/ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MYM_DEVICE(ZTMP3_DEVICE,ZTMP1_DEVICE)
CALL MXM_DEVICE(PDZY,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KL, ZTMP3_DEVICE,ZTMP2_DEVICE )
CALL DYM_DEVICE(PA,ZTMP1_DEVICE)
CALL MXM_DEVICE(PDYY,ZTMP3_DEVICE)
!$acc kernels
- PGY_U_UV_DEVICE(:,:,:)= ( ZTMP1_DEVICE(:,:,:) - ZTMP2_DEVICE(:,:,:) ) / ZTMP3_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PGY_U_UV_DEVICE(JI,JJ,JK)= ( ZTMP1_DEVICE(JI,JJ,JK) - ZTMP2_DEVICE(JI,JJ,JK) ) / ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
ELSE
CALL DYM_DEVICE(PA,ZTMP1_DEVICE)
@@ -437,6 +463,8 @@ END IF
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device,iztmp3_device)
+
!$acc end data
!----------------------------------------------------------------------------
@@ -535,6 +563,8 @@ END FUNCTION GZ_U_UW
!
!
USE MODI_SHUMAN_DEVICE
+USE MODI_SHUMAN
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -546,23 +576,26 @@ INTEGER, INTENT(IN) :: KL ! +1 if grid goes from ground to
REAL, DIMENSION(:,:,:), INTENT(IN) :: PA ! variable at the U point
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGZ_U_UW_DEVICE ! result UW point
-!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
-!
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGZ_U_UW_DEVICE ! result UW point
!
!* 0.2 declaration of local variables
!
-! NONE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE
!
+INTEGER :: JIU,JJU,JKU
!----------------------------------------------------------------------------
!$acc data present( PA, PDZZ, PGZ_U_UW_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
-!$acc data create( ztmp1_device, ztmp2_device )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+
+!$acc data present( ztmp1_device, ztmp2_device )
!
!* 1. DEFINITION of GZ_U_UW_DEVICE
@@ -576,6 +609,8 @@ PGZ_U_UW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device)
+
!$acc end data
!----------------------------------------------------------------------------
diff --git a/src/MNH/gradient_v.f90 b/src/MNH/gradient_v.f90
index 18730e274..0f7192cd8 100644
--- a/src/MNH/gradient_v.f90
+++ b/src/MNH/gradient_v.f90
@@ -32,7 +32,7 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDYY ! metric coefficient dyy
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZY ! metric coefficient dzy
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGY_V_M_DEVICE ! result mass point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGY_V_M_DEVICE ! result mass point
!
END SUBROUTINE GY_V_M_DEVICE
#endif
@@ -60,7 +60,7 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDXX ! metric coefficient dxx
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZX ! metric coefficient dzx
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGX_V_UV_DEVICE ! result UV point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGX_V_UV_DEVICE ! result UV point
!
END SUBROUTINE GX_V_UV_DEVICE
#endif
@@ -84,7 +84,7 @@ INTEGER, INTENT(IN) :: KL ! +1 if grid goes from ground to
REAL, DIMENSION(:,:,:), INTENT(IN) :: PA ! variable at the V point
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGZ_V_VW_DEVICE ! result VW point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGZ_V_VW_DEVICE ! result VW point
!
END SUBROUTINE GZ_V_VW_DEVICE
#endif
@@ -94,8 +94,6 @@ END INTERFACE
!
END MODULE MODI_GRADIENT_V
!
-!
-!
! #######################################################
FUNCTION GY_V_M(PA,PDYY,PDZZ,PDZY) RESULT(PGY_V_M)
! #######################################################
@@ -201,6 +199,7 @@ END FUNCTION GY_V_M
!
USE MODI_SHUMAN_DEVICE
USE MODD_CONF
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -214,9 +213,13 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDYY ! metric coefficient dyy
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZY ! metric coefficient dzy
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGY_V_M_DEVICE ! result mass point
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGY_V_M_DEVICE ! result mass point
!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!
!* 0.2 declaration of local variables
!
@@ -226,11 +229,15 @@ REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE
!$acc data present( PA, PDYY, PDZZ, PDZY, PGY_V_M_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
+
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
-!$acc data create( ztmp1_device, ztmp2_device, ztmp3_device )
+!$acc data present( ztmp1_device, ztmp2_device, ztmp3_device )
!
!* 1. DEFINITION of GY_V_M_DEVICE
@@ -239,13 +246,17 @@ allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
IF (.NOT. LFLAT) THEN
CALL DYF_DEVICE(PA,ZTMP1_DEVICE)
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP2_DEVICE)
-!$acc kernels
- ZTMP3_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = PDZY(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE,ZTMP2_DEVICE)
-!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)/PDZZ(:,:,:)
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)/PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KL,ZTMP3_DEVICE,ZTMP2_DEVICE)
CALL MYF_DEVICE(PDYY,ZTMP3_DEVICE)
!$acc kernels
@@ -261,6 +272,8 @@ END IF
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device,iztmp3_device)
+
!$acc end data
!----------------------------------------------------------------------------
@@ -374,6 +387,7 @@ END FUNCTION GX_V_UV
!
USE MODI_SHUMAN_DEVICE
USE MODD_CONF
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -387,48 +401,58 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDXX ! metric coefficient dxx
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZX ! metric coefficient dzx
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGX_V_UV_DEVICE ! result UV point
-!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
-!
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGX_V_UV_DEVICE ! result UV point
!
!* 0.2 declaration of local variables
!
-! NONE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!
!----------------------------------------------------------------------------
!$acc data present( PA, PDXX, PDZZ, PDZX, PGX_V_UV_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp4_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
+
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
-!$acc data create( ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device )
+!$acc data present( ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device )
!
!* 1. DEFINITION of GX_V_UV_DEVICE
! ---------------------
!
IF (.NOT. LFLAT) THEN
-
CALL DXM_DEVICE(PA,ZTMP1_DEVICE)
CALL MYM_DEVICE(PDZZ,ZTMP2_DEVICE)
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP3_DEVICE)
-!$acc kernels
- ZTMP4_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MXM_DEVICE(ZTMP4_DEVICE,ZTMP2_DEVICE)
CALL MYM_DEVICE(PDZX,ZTMP3_DEVICE)
-!$acc kernels
- ZTMP4_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) *ZTMP3_DEVICE(:,:,:)
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK) *ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KL,ZTMP4_DEVICE,ZTMP2_DEVICE)
CALL MYM_DEVICE(PDXX,ZTMP3_DEVICE)
-!$acc kernels
- PGX_V_UV_DEVICE(:,:,:)= ( ZTMP1_DEVICE(:,:,:) - ZTMP2_DEVICE(:,:,:) ) / ZTMP3_DEVICE(:,:,:)
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PGX_V_UV_DEVICE(JI,JJ,JK)= ( ZTMP1_DEVICE(JI,JJ,JK) - ZTMP2_DEVICE(JI,JJ,JK) ) / ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
ELSE
CALL DXM_DEVICE(PA,ZTMP1_DEVICE)
CALL MYM_DEVICE(PDXX,ZTMP2_DEVICE)
@@ -439,6 +463,8 @@ END IF
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device,iztmp3_device,iztmp4_device)
+
!$acc end data
!----------------------------------------------------------------------------
@@ -538,6 +564,8 @@ END FUNCTION GZ_V_VW
!
!
USE MODI_SHUMAN_DEVICE
+USE MODI_SHUMAN
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -549,22 +577,26 @@ INTEGER, INTENT(IN) :: KL ! +1 if grid goes from ground to
REAL, DIMENSION(:,:,:), INTENT(IN) :: PA ! variable at the V point
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGZ_V_VW_DEVICE ! result VW point
-!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGZ_V_VW_DEVICE ! result VW point
!
!* 0.2 declaration of local variables
!
-! NONE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE
!
+INTEGER :: JIU,JJU,JKU
!----------------------------------------------------------------------------
!$acc data present( PA, PDZZ, PGZ_V_VW_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
-!$acc data create( ztmp1_device, ztmp2_device )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+
+!$acc data present( ztmp1_device, ztmp2_device )
!
!* 1. DEFINITION of GZ_V_VW_DEVICE
@@ -578,9 +610,12 @@ PGZ_V_VW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device)
+
!$acc end data
!----------------------------------------------------------------------------
!
END SUBROUTINE GZ_V_VW_DEVICE
#endif
+
diff --git a/src/MNH/gradient_w.f90 b/src/MNH/gradient_w.f90
index 83ecb6721..3133bd835 100644
--- a/src/MNH/gradient_w.f90
+++ b/src/MNH/gradient_w.f90
@@ -28,7 +28,7 @@ INTEGER, INTENT(IN) :: KL ! +1 if grid goes from ground to
REAL, DIMENSION(:,:,:), INTENT(IN) :: PA ! variable at the W point
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGZ_W_M_DEVICE ! result mass point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGZ_W_M_DEVICE ! result mass point
!
END SUBROUTINE GZ_W_M_DEVICE
#endif
@@ -56,7 +56,7 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDXX ! metric coefficient dxx
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZX ! metric coefficient dzx
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGX_W_UW_DEVICE ! result UW point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGX_W_UW_DEVICE ! result UW point
!
END SUBROUTINE GX_W_UW_DEVICE
#endif
@@ -84,7 +84,7 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDYY ! metric coefficient dyy
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZY ! metric coefficient dzy
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGY_W_VW_DEVICE ! result VW point
+REAL, DIMENSION(:,:,:), INTENT(OUT) :: PGY_W_VW_DEVICE ! result VW point
!
END SUBROUTINE GY_W_VW_DEVICE
#endif
@@ -93,9 +93,7 @@ END SUBROUTINE GY_W_VW_DEVICE
END INTERFACE
!
END MODULE MODI_GRADIENT_W
-!
-!
-!
+!
! #######################################################
FUNCTION GZ_W_M(PA,PDZZ) RESULT(PGZ_W_M)
! #######################################################
@@ -181,6 +179,8 @@ END FUNCTION GZ_W_M
!
!
USE MODI_SHUMAN_DEVICE
+USE MODI_SHUMAN
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -192,20 +192,26 @@ INTEGER, INTENT(IN) :: KL ! +1 if grid goes from ground to
REAL, DIMENSION(:,:,:), INTENT(IN) :: PA ! variable at the W point
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGZ_W_M_DEVICE ! result mass point
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGZ_W_M_DEVICE ! result mass point
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE
!
+INTEGER :: JIU,JJU,JKU
!----------------------------------------------------------------------------
!$acc data present( PA, PDZZ, PGZ_W_M_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
+
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
-!$acc data create( ztmp1_device, ztmp2_device )
+!$acc data present( ztmp1_device, ztmp2_device )
!
!* 1. DEFINITION of GZ_W_M_DEVICE
@@ -219,6 +225,8 @@ PGZ_W_M_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:)
!$acc end data
+CALL MNH_REL_ZT3D(iztmp1_device,iztmp2_device)
+
!$acc end data
!----------------------------------------------------------------------------
@@ -323,6 +331,7 @@ END FUNCTION GX_W_UW
!
USE MODI_SHUMAN_DEVICE
USE MODD_CONF
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -336,23 +345,29 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDXX ! metric coefficient dxx
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZX ! metric coefficient dzx
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGX_W_UW_DEVICE ! result UW point
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGX_W_UW_DEVICE ! result UW point
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, ZTMP5_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, ZTMP5_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE,IZTMP4_DEVICE,IZTMP5_DEVICE
!
+INTEGER :: JIU,JJU,JKU
!----------------------------------------------------------------------------
!$acc data present( PA, PDXX, PDZZ, PDZX, PGX_W_UW_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp4_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp5_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
-!$acc data create( ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, ztmp5_device )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
+iztmp5_device = MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU )
+
+!$acc data present( ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, ztmp5_device )
!
!* 1. DEFINITION of GX_W_UW_DEVICE
@@ -383,6 +398,8 @@ END IF
!$acc end data
+CALL MNH_REL_ZT3D( iztmp1_device, iztmp2_device, iztmp3_device, iztmp4_device, iztmp5_device )
+
!$acc end data
!----------------------------------------------------------------------------
@@ -487,6 +504,7 @@ END FUNCTION GY_W_VW
!
USE MODI_SHUMAN_DEVICE
USE MODD_CONF
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
!
IMPLICIT NONE
!
@@ -500,23 +518,30 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PDYY ! metric coefficient dyy
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZZ ! metric coefficient dzz
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDZY ! metric coefficient dzy
!
-REAL, DIMENSION(SIZE(PA,1),SIZE(PA,2),SIZE(PA,3)), INTENT(OUT) :: PGY_W_VW_DEVICE ! result VW point
+REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PGY_W_VW_DEVICE ! result VW point
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, ZTMP5_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, ZTMP5_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE,IZTMP4_DEVICE,IZTMP5_DEVICE
+!
+INTEGER :: JIU,JJU,JKU
!
!----------------------------------------------------------------------------
!$acc data present( PA, PDYY, PDZZ, PDZY, PGY_W_VW_DEVICE )
-allocate( ztmp1_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp3_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp4_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
-allocate( ztmp5_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
+JIU = size(pa, 1 )
+JJU = size(pa, 2 )
+JKU = size(pa, 3 )
-!$acc data create( ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, ztmp5_device )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
+iztmp5_device = MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU )
+
+!$acc data present( ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, ztmp5_device )
!
!* 1. DEFINITION of GY_W_VW_DEVICE
@@ -547,9 +572,12 @@ END IF
!$acc end data
+CALL MNH_REL_ZT3D( iztmp1_device, iztmp2_device, iztmp3_device, iztmp4_device, iztmp5_device )
+
!$acc end data
!----------------------------------------------------------------------------
!
END SUBROUTINE GY_W_VW_DEVICE
#endif
+
diff --git a/src/MNH/mode_mnh_zwork.f90 b/src/MNH/mode_mnh_zwork.f90
index e94ced87e..bd5fbf28a 100644
--- a/src/MNH/mode_mnh_zwork.f90
+++ b/src/MNH/mode_mnh_zwork.f90
@@ -30,18 +30,30 @@ MODULE MODE_MNH_ZWORK
REAL, SAVE, ALLOCATABLE , DIMENSION(:,:,:) :: ZUNIT3D
- INTEGER, parameter :: JPMAX_T3D = 40
+ INTEGER, parameter :: JPMAX_T3D = 100
INTEGER , ALLOCATABLE, DIMENSION (:) :: NT3D_POOL
- INTEGER :: NT3D_TOP , NT3D_TOP_MAX = 0
+ INTEGER :: NT3D_TOP , NT3D_TOP_MAX = 0
+ INTEGER :: NT3D_TOP_CURRENT(JPMAX_T3D+1) , NT3D_TOP_CURRENT_INDEX = 0
!REAL , ALLOCATABLE, DIMENSION(:,:,:,:) , TARGET :: ZT3D_A1,ZT3D_A2,ZT3D_A3,ZT3D_A4
!REAL , POINTER , DIMENSION(:,:,:,:) :: ZT3D
- REAL,SAVE , ALLOCATABLE, DIMENSION(:,:,:,:) :: ZT3D
+ REAL,SAVE , ALLOCATABLE, TARGET , DIMENSION(:,:,:,:) :: ZT3D
+
+ REAL,SAVE , ALLOCATABLE, TARGET , DIMENSION(:,:) :: ZT2D_OSIZE
+ REAL,SAVE , ALLOCATABLE, TARGET , DIMENSION(:,:,:) :: ZT3D_OSIZE
+ REAL,SAVE , ALLOCATABLE, TARGET , DIMENSION(:,:,:,:) :: ZT4D_OSIZE
+
+
TYPE TMODEL
REAL , POINTER, DIMENSION(:,:,:,:) :: X
END TYPE TMODEL
TYPE(TMODEL) , DIMENSION(10) :: MODEL
+ INTEGER, parameter :: JPMAX_T3D_G = 4
+ INTEGER , ALLOCATABLE, DIMENSION (:) :: NT3D_POOL_G
+ INTEGER :: NT3D_TOP_G , NT3D_TOP_G_MAX = 0
+ LOGICAL,SAVE , ALLOCATABLE, TARGET , DIMENSION(:,:,:,:) :: GT3D
+
CONTAINS
SUBROUTINE MNH_ALLOC_ZWORK(IMODEL)
@@ -93,18 +105,38 @@ CONTAINS
ALLOCATE (ZUNIT3D(IIU,IJU,IKU))
!$acc enter data create(ZUNIT3D)
+!----- Real pool
+
!ALLOCATE (ZT3D_A1(IIU,IJU,IKU,JPMAX_T3D))
!MODEL(1)%X => ZT3D_A1
!ZT3D => MODEL(1)%X
ALLOCATE (ZT3D(IIU,IJU,IKU,JPMAX_T3D))
!$acc enter data create(ZT3D)
+ ALLOCATE (ZT2D_OSIZE(IIU,0))
+ ALLOCATE (ZT3D_OSIZE(IIU,IJU,0))
+ ALLOCATE (ZT4D_OSIZE(IIU,IJU,IKU,0))
+ !$acc enter data create(ZT2D_OSIZE,ZT3D_OSIZE,ZT4D_OSIZE)
+
ALLOCATE (NT3D_POOL(JPMAX_T3D))
NT3D_TOP = 0
DO JI = 1, JPMAX_T3D
NT3D_POOL(JI) = JI
END DO
+!------ Logical pool
+
+ ALLOCATE (GT3D(IIU,IJU,IKU,JPMAX_T3D_G))
+ !$acc enter data create(GT3D)
+
+ ALLOCATE (NT3D_POOL_G(JPMAX_T3D))
+ NT3D_TOP_G = 0
+ DO JI = 1, JPMAX_T3D
+ NT3D_POOL_G(JI) = JI
+ END DO
+
+!------ Default values
+
!$acc kernels
ZPSRC_HALO2_WEST = XUNDEF
@@ -135,10 +167,7 @@ CONTAINS
ELSE
NT3D_TOP = NT3D_TOP + 1
KTEMP = NT3D_POOL(NT3D_TOP)
- IF ( NT3D_POOL(NT3D_TOP) == -1 ) THEN
- call Print_msg( NVERB_FATAL, 'GEN', 'MNH_GET_ZT3D_N0', 'slice already reserved' )
- END IF
- NT3D_POOL(NT3D_TOP) = -1
+ NT3D_POOL(NT3D_TOP) = - KTEMP
IF ( NT3D_TOP > NT3D_TOP_MAX ) THEN
NT3D_TOP_MAX = NT3D_TOP
WRITE( *, '( " MNH_GET_ZT3D: NT3D_TOP_MAX=",I4," KTEMP=",I4 )' ) NT3D_TOP_MAX,KTEMP
@@ -176,7 +205,6 @@ CONTAINS
IF (PRESENT(KTEMP17)) CALL MNH_GET_ZT3D_N0(KTEMP17)
IF (PRESENT(KTEMP18)) CALL MNH_GET_ZT3D_N0(KTEMP18)
-
END SUBROUTINE MNH_GET_ZT3D
SUBROUTINE MNH_GET_ZT4D(KSIZE,KBEG,KEND)
@@ -195,10 +223,10 @@ CONTAINS
KEND = NT3D_TOP + KSIZE
NT3D_TOP = NT3D_TOP + KSIZE
DO JI = KBEG, KEND
- IF (NT3D_POOL(JI) == -1) THEN
+ IF (NT3D_POOL(JI) <= 0 ) THEN
call Print_msg( NVERB_FATAL, 'GEN', 'MNH_GET_ZT4D', 'trying to use area already reserved' )
END IF
- NT3D_POOL(JI) = -1
+ NT3D_POOL(JI) = -JI
END DO
IF ( NT3D_TOP > NT3D_TOP_MAX ) THEN
NT3D_TOP_MAX = NT3D_TOP
@@ -215,50 +243,59 @@ CONTAINS
INTEGER :: KTEMP
+ IF ( KTEMP .EQ. 0 ) THEN
+ ! Special case Zero size array do nothing
+ RETURN
+ ELSE
+
IF ( ( NT3D_TOP > JPMAX_T3D ) .OR. ( NT3D_TOP < 1 ) ) THEN
call Print_msg( NVERB_FATAL, 'GEN', 'MNH_REL_ZT3D_N0', 'invalid value for NT3D_TOP' )
ELSE
NT3D_POOL(KTEMP) = KTEMP
IF (KTEMP == NT3D_TOP) THEN
NT3D_TOP = NT3D_TOP - 1
- DO WHILE (NT3D_TOP > 0 )
- if ( NT3D_POOL(NT3D_TOP) == -1 ) exit
- NT3D_TOP = NT3D_TOP - 1
- END DO
+ ELSE
+ WRITE( *, '( "MNH_REL_ZT3D: releasing ZT3D (",2I8,")" )' ) KTEMP, NT3D_TOP
+ call Print_msg( NVERB_FATAL, 'GEN', 'MNH_REL_ZT3D_N0', 'invalid value for KTEMP <> NT3D_TOP' )
END IF
ENDIF
!WRITE( *, '( "MNH_REL_ZT3D: releasing ZT3D (",I4,")" )' ) KTEMP
+ ENDIF
END SUBROUTINE MNH_REL_ZT3D_N0
SUBROUTINE MNH_REL_ZT3D(KTEMP1,KTEMP2,KTEMP3,KTEMP4,KTEMP5,KTEMP6,KTEMP7,KTEMP8,KTEMP9, &
- KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18)
+ KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18, &
+ KTEMP19,KTEMP20)
IMPLICIT NONE
INTEGER :: KTEMP1
INTEGER,OPTIONAL :: KTEMP2,KTEMP3,KTEMP4,KTEMP5,KTEMP6,KTEMP7,KTEMP8,KTEMP9
INTEGER,OPTIONAL :: KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18
+ INTEGER,OPTIONAL :: KTEMP19,KTEMP20
- CALL MNH_REL_ZT3D_N0(KTEMP1)
- IF (PRESENT(KTEMP2)) CALL MNH_REL_ZT3D_N0(KTEMP2)
- IF (PRESENT(KTEMP3)) CALL MNH_REL_ZT3D_N0(KTEMP3)
- IF (PRESENT(KTEMP4)) CALL MNH_REL_ZT3D_N0(KTEMP4)
- IF (PRESENT(KTEMP5)) CALL MNH_REL_ZT3D_N0(KTEMP5)
- IF (PRESENT(KTEMP6)) CALL MNH_REL_ZT3D_N0(KTEMP6)
- IF (PRESENT(KTEMP7)) CALL MNH_REL_ZT3D_N0(KTEMP7)
- IF (PRESENT(KTEMP8)) CALL MNH_REL_ZT3D_N0(KTEMP8)
- IF (PRESENT(KTEMP9)) CALL MNH_REL_ZT3D_N0(KTEMP9)
- IF (PRESENT(KTEMP10)) CALL MNH_REL_ZT3D_N0(KTEMP10)
- IF (PRESENT(KTEMP11)) CALL MNH_REL_ZT3D_N0(KTEMP11)
- IF (PRESENT(KTEMP12)) CALL MNH_REL_ZT3D_N0(KTEMP12)
- IF (PRESENT(KTEMP13)) CALL MNH_REL_ZT3D_N0(KTEMP13)
- IF (PRESENT(KTEMP14)) CALL MNH_REL_ZT3D_N0(KTEMP14)
- IF (PRESENT(KTEMP15)) CALL MNH_REL_ZT3D_N0(KTEMP15)
- IF (PRESENT(KTEMP16)) CALL MNH_REL_ZT3D_N0(KTEMP16)
- IF (PRESENT(KTEMP17)) CALL MNH_REL_ZT3D_N0(KTEMP17)
+ IF (PRESENT(KTEMP20)) CALL MNH_REL_ZT3D_N0(KTEMP20)
+ IF (PRESENT(KTEMP19)) CALL MNH_REL_ZT3D_N0(KTEMP19)
IF (PRESENT(KTEMP18)) CALL MNH_REL_ZT3D_N0(KTEMP18)
-
+ IF (PRESENT(KTEMP17)) CALL MNH_REL_ZT3D_N0(KTEMP17)
+ IF (PRESENT(KTEMP16)) CALL MNH_REL_ZT3D_N0(KTEMP16)
+ IF (PRESENT(KTEMP15)) CALL MNH_REL_ZT3D_N0(KTEMP15)
+ IF (PRESENT(KTEMP14)) CALL MNH_REL_ZT3D_N0(KTEMP14)
+ IF (PRESENT(KTEMP13)) CALL MNH_REL_ZT3D_N0(KTEMP13)
+ IF (PRESENT(KTEMP12)) CALL MNH_REL_ZT3D_N0(KTEMP12)
+ IF (PRESENT(KTEMP11)) CALL MNH_REL_ZT3D_N0(KTEMP11)
+ IF (PRESENT(KTEMP10)) CALL MNH_REL_ZT3D_N0(KTEMP10)
+ IF (PRESENT(KTEMP9)) CALL MNH_REL_ZT3D_N0(KTEMP9)
+ IF (PRESENT(KTEMP8)) CALL MNH_REL_ZT3D_N0(KTEMP8)
+ IF (PRESENT(KTEMP7)) CALL MNH_REL_ZT3D_N0(KTEMP7)
+ IF (PRESENT(KTEMP6)) CALL MNH_REL_ZT3D_N0(KTEMP6)
+ IF (PRESENT(KTEMP5)) CALL MNH_REL_ZT3D_N0(KTEMP5)
+ IF (PRESENT(KTEMP4)) CALL MNH_REL_ZT3D_N0(KTEMP4)
+ IF (PRESENT(KTEMP3)) CALL MNH_REL_ZT3D_N0(KTEMP3)
+ IF (PRESENT(KTEMP2)) CALL MNH_REL_ZT3D_N0(KTEMP2)
+ CALL MNH_REL_ZT3D_N0(KTEMP1)
+
END SUBROUTINE MNH_REL_ZT3D
SUBROUTINE MNH_REL_ZT4D(KSIZE,KBEG)
@@ -271,8 +308,11 @@ CONTAINS
character(len=16) :: ytxt1, ytxt2
INTEGER :: JI
+ IF ( KSIZE .EQ. 0 ) THEN
+ ! special case of O zero 4D array => ZT4D_OSIZE
+ RETURN
+ END IF
IF ( KBEG + KSIZE -1 /= NT3D_TOP ) THEN
-!PW TODO: implement holes management
write( ytxt1, '( I4, "-", I4 )' ) kbeg, kbeg + ksize - 1
write( ytxt2, '( I4 )' ) NT3D_TOP
call Print_msg( NVERB_ERROR, 'GEN', 'MNH_REL_ZT4D', 'trying to free area (' // trim( ytxt1 ) // &
@@ -283,17 +323,252 @@ CONTAINS
END IF
DO JI = KBEG, KBEG+KSIZE-1
- IF (NT3D_POOL(JI) /= -1) THEN
- call Print_msg( NVERB_ERROR, 'GEN', 'MNH_REL_ZT4D', 'trying to free area not reserved' )
+ IF (NT3D_POOL(JI) /= - JI ) THEN
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_REL_ZT4D', 'trying to free area not reserved' )
+ ELSE
+ NT3D_POOL(JI) = JI
END IF
- NT3D_POOL(JI) = JI
END DO
NT3D_TOP = NT3D_TOP - KSIZE
!WRITE( *, '( "MNH_REL_ZT4D: releasing ZT3D (",I4,I4,")" )' ) KBEG,KBEG+KSIZE-1
END SUBROUTINE MNH_REL_ZT4D
+ FUNCTION MNH_ALLOCATE_ZT3D(PTAB,KI,KJ,KK) RESULT (KINDEX)
+
+ REAL, POINTER, CONTIGUOUS , DIMENSION(:,:,:), INTENT(INOUT) :: PTAB
+ INTEGER , INTENT(IN) :: KI,KJ,KK
+ INTEGER :: KINDEX
+
+ !local
+
+ IF ( (KI .EQ. IIU) .AND. (KJ .EQ. IJU) ) THEN
+ CALL MNH_GET_ZT3D_N0(KINDEX)
+ IF (KK .LE. IKU) THEN
+ PTAB => ZT3D(:,:,1:KK,KINDEX)
+ ELSE IF (KK .EQ.0 ) THEN
+ PTAB => ZT3D_OSIZE
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_ZT3D', ' Size mismatsh ' )
+ END IF
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_ZT3D', ' Size mismatsh ' )
+ END IF
+
+ END FUNCTION MNH_ALLOCATE_ZT3D
+
+ FUNCTION MNH_ALLOCATE_ZT4D(PTAB,KI,KJ,KK,KL) RESULT (KINDEX_BEG)
+
+ REAL, POINTER, CONTIGUOUS , DIMENSION(:,:,:,:), INTENT(INOUT) :: PTAB
+ INTEGER , INTENT(IN) :: KI,KJ,KK,KL
+ INTEGER :: KINDEX_BEG
+
+ !local
+
+ INTEGER :: KINDEX_END
+
+ IF ( (KI .EQ. IIU) .AND. (KJ .EQ. IJU) .AND. (KK .EQ. IKU) ) THEN
+ IF ( KL .GE. 1 ) THEN
+ CALL MNH_GET_ZT4D(KL,KINDEX_BEG,KINDEX_END)
+ PTAB => ZT3D(:,:,:,KINDEX_BEG:KINDEX_END)
+ ELSE
+ PTAB => ZT4D_OSIZE
+ KINDEX_BEG = 0
+ END IF
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_ZT4D', ' Size mismatsh ' )
+ END IF
+
+ END FUNCTION MNH_ALLOCATE_ZT4D
+
+ FUNCTION MNH_ALLOCATE_ZT2D(PTAB,KI,KJ) RESULT (KINDEX)
+
+ REAL, POINTER, CONTIGUOUS , DIMENSION(:,:), INTENT(INOUT) :: PTAB
+ INTEGER , INTENT(IN) :: KI,KJ
+ INTEGER :: KINDEX
+
+ !local
+
+ IF (KI .EQ. IIU) THEN
+ CALL MNH_GET_ZT3D_N0(KINDEX)
+ IF (KJ .EQ. IJU) THEN
+ PTAB => ZT3D(:,:,1,KINDEX)
+ ELSE IF (KJ .EQ. 0) THEN
+ PTAB => ZT2D_OSIZE
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_ZT2D', ' Size mismatsh ' )
+ END IF
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_ZT2D', ' Size mismatsh ' )
+ END IF
+
+ END FUNCTION MNH_ALLOCATE_ZT2D
+
+ FUNCTION MNH_ALLOCATE_ZT3DP(PTAB,KI,KJ,KKB,KKE) RESULT (KINDEX)
+
+ REAL, POINTER, CONTIGUOUS , DIMENSION(:,:,:), INTENT(INOUT) :: PTAB
+ INTEGER , INTENT(IN) :: KI,KJ,KKB,KKE
+ INTEGER :: KINDEX
+
+ !local
+
+ IF ( (KI .EQ. IIU) .AND. (KJ .EQ. IJU) .AND. (KKB .LE. IKU) .AND. (KKE .LE. IKU) ) THEN
+ CALL MNH_GET_ZT3D_N0(KINDEX)
+ PTAB(1:,1:,KKB:) => ZT3D(:,:,KKB:KKE,KINDEX)
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_ZT3DP', ' Size mismatsh ' )
+ END IF
+
+ END FUNCTION MNH_ALLOCATE_ZT3DP
+
+!-------- Logical Pool Managment
+
+ SUBROUTINE MNH_GET_GT3D_N0(KTEMP)
+
+ IMPLICIT NONE
+
+ INTEGER :: KTEMP
+
+ IF (NT3D_TOP_G == JPMAX_T3D_G ) THEN
+ call Print_msg( NVERB_FATAL, 'GEN', 'MNH_GET_GT3D_N0', 'NT3D_TOP_G_G too big (increaze JPMAX_T3D_G)' )
+ ELSE
+ NT3D_TOP_G = NT3D_TOP_G + 1
+ KTEMP = NT3D_POOL_G(NT3D_TOP_G)
+ NT3D_POOL_G(NT3D_TOP_G) = - KTEMP
+ IF ( NT3D_TOP_G > NT3D_TOP_G_MAX ) THEN
+ NT3D_TOP_G_MAX = NT3D_TOP_G
+ WRITE( *, '( " MNH_GET_GT3D: NT3D_TOP_G_MAX=",I4," KTEMP=",I4 )' ) NT3D_TOP_G_MAX,KTEMP
+ END IF
+ ENDIF
+ !WRITE( *, '( "MNH_GET_GT3D: reserving GT3D (",I4,")" )' ) KTEMP
+
+ END SUBROUTINE MNH_GET_GT3D_N0
+
+ SUBROUTINE MNH_GET_GT3D(KTEMP1,KTEMP2,KTEMP3,KTEMP4,KTEMP5,KTEMP6,KTEMP7,KTEMP8,KTEMP9, &
+ KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18)
+
+ IMPLICIT NONE
+
+ INTEGER :: KTEMP1
+ INTEGER,OPTIONAL :: KTEMP2,KTEMP3,KTEMP4,KTEMP5,KTEMP6,KTEMP7,KTEMP8,KTEMP9
+ INTEGER,OPTIONAL :: KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18
+
+ CALL MNH_GET_GT3D_N0(KTEMP1)
+ IF (PRESENT(KTEMP2)) CALL MNH_GET_GT3D_N0(KTEMP2)
+ IF (PRESENT(KTEMP3)) CALL MNH_GET_GT3D_N0(KTEMP3)
+ IF (PRESENT(KTEMP4)) CALL MNH_GET_GT3D_N0(KTEMP4)
+ IF (PRESENT(KTEMP5)) CALL MNH_GET_GT3D_N0(KTEMP5)
+ IF (PRESENT(KTEMP6)) CALL MNH_GET_GT3D_N0(KTEMP6)
+ IF (PRESENT(KTEMP7)) CALL MNH_GET_GT3D_N0(KTEMP7)
+ IF (PRESENT(KTEMP8)) CALL MNH_GET_GT3D_N0(KTEMP8)
+ IF (PRESENT(KTEMP9)) CALL MNH_GET_GT3D_N0(KTEMP9)
+ IF (PRESENT(KTEMP10)) CALL MNH_GET_GT3D_N0(KTEMP10)
+ IF (PRESENT(KTEMP11)) CALL MNH_GET_GT3D_N0(KTEMP11)
+ IF (PRESENT(KTEMP12)) CALL MNH_GET_GT3D_N0(KTEMP12)
+ IF (PRESENT(KTEMP13)) CALL MNH_GET_GT3D_N0(KTEMP13)
+ IF (PRESENT(KTEMP14)) CALL MNH_GET_GT3D_N0(KTEMP14)
+ IF (PRESENT(KTEMP15)) CALL MNH_GET_GT3D_N0(KTEMP15)
+ IF (PRESENT(KTEMP16)) CALL MNH_GET_GT3D_N0(KTEMP16)
+ IF (PRESENT(KTEMP17)) CALL MNH_GET_GT3D_N0(KTEMP17)
+ IF (PRESENT(KTEMP18)) CALL MNH_GET_GT3D_N0(KTEMP18)
+
+ END SUBROUTINE MNH_GET_GT3D
+
+ SUBROUTINE MNH_REL_GT3D_N0(KTEMP)
+
+ IMPLICIT NONE
+
+ INTEGER :: KTEMP
+
+ IF ( ( NT3D_TOP_G > JPMAX_T3D_G ) .OR. ( NT3D_TOP_G < 1 ) ) THEN
+ call Print_msg( NVERB_FATAL, 'GEN', 'MNH_REL_GT3D_N0', 'invalid value for NT3D_TOP_G' )
+ ELSE
+ NT3D_POOL_G(KTEMP) = KTEMP
+ IF (KTEMP == NT3D_TOP_G) THEN
+ NT3D_TOP_G = NT3D_TOP_G - 1
+ ELSE
+ WRITE( *, '( "MNH_REL_GT3D: releasing GT3D (",2I8,")" )' ) KTEMP, NT3D_TOP_G
+ call Print_msg( NVERB_FATAL, 'GEN', 'MNH_REL_GT3D_N0', 'invalid value for KTEMP <> NT3D_TOP_G' )
+ END IF
+ ENDIF
+ !WRITE( *, '( "MNH_REL_GT3D: releasing GT3D (",I4,")" )' ) KTEMP
+
+ END SUBROUTINE MNH_REL_GT3D_N0
+
+ SUBROUTINE MNH_REL_GT3D(KTEMP1,KTEMP2,KTEMP3,KTEMP4,KTEMP5,KTEMP6,KTEMP7,KTEMP8,KTEMP9, &
+ KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18, &
+ KTEMP19,KTEMP20)
+
+ IMPLICIT NONE
+
+ INTEGER :: KTEMP1
+ INTEGER,OPTIONAL :: KTEMP2,KTEMP3,KTEMP4,KTEMP5,KTEMP6,KTEMP7,KTEMP8,KTEMP9
+ INTEGER,OPTIONAL :: KTEMP10,KTEMP11,KTEMP12,KTEMP13,KTEMP14,KTEMP15,KTEMP16,KTEMP17,KTEMP18
+ INTEGER,OPTIONAL :: KTEMP19,KTEMP20
+
+ IF (PRESENT(KTEMP20)) CALL MNH_REL_GT3D_N0(KTEMP20)
+ IF (PRESENT(KTEMP19)) CALL MNH_REL_GT3D_N0(KTEMP19)
+ IF (PRESENT(KTEMP18)) CALL MNH_REL_GT3D_N0(KTEMP18)
+ IF (PRESENT(KTEMP17)) CALL MNH_REL_GT3D_N0(KTEMP17)
+ IF (PRESENT(KTEMP16)) CALL MNH_REL_GT3D_N0(KTEMP16)
+ IF (PRESENT(KTEMP15)) CALL MNH_REL_GT3D_N0(KTEMP15)
+ IF (PRESENT(KTEMP14)) CALL MNH_REL_GT3D_N0(KTEMP14)
+ IF (PRESENT(KTEMP13)) CALL MNH_REL_GT3D_N0(KTEMP13)
+ IF (PRESENT(KTEMP12)) CALL MNH_REL_GT3D_N0(KTEMP12)
+ IF (PRESENT(KTEMP11)) CALL MNH_REL_GT3D_N0(KTEMP11)
+ IF (PRESENT(KTEMP10)) CALL MNH_REL_GT3D_N0(KTEMP10)
+ IF (PRESENT(KTEMP9)) CALL MNH_REL_GT3D_N0(KTEMP9)
+ IF (PRESENT(KTEMP8)) CALL MNH_REL_GT3D_N0(KTEMP8)
+ IF (PRESENT(KTEMP7)) CALL MNH_REL_GT3D_N0(KTEMP7)
+ IF (PRESENT(KTEMP6)) CALL MNH_REL_GT3D_N0(KTEMP6)
+ IF (PRESENT(KTEMP5)) CALL MNH_REL_GT3D_N0(KTEMP5)
+ IF (PRESENT(KTEMP4)) CALL MNH_REL_GT3D_N0(KTEMP4)
+ IF (PRESENT(KTEMP3)) CALL MNH_REL_GT3D_N0(KTEMP3)
+ IF (PRESENT(KTEMP2)) CALL MNH_REL_GT3D_N0(KTEMP2)
+ CALL MNH_REL_GT3D_N0(KTEMP1)
+
+ END SUBROUTINE MNH_REL_GT3D
+
+ FUNCTION MNH_ALLOCATE_GT3D(PTAB,KI,KJ,KK) RESULT (KINDEX)
+
+ LOGICAL, POINTER, CONTIGUOUS , DIMENSION(:,:,:), INTENT(INOUT) :: PTAB
+ INTEGER , INTENT(IN) :: KI,KJ,KK
+ INTEGER :: KINDEX
+
+ !local
+
+ IF ( (KI .EQ. IIU) .AND. (KJ .EQ. IJU) .AND. (KK .EQ. IKU) ) THEN
+ CALL MNH_GET_GT3D_N0(KINDEX)
+ PTAB => GT3D(:,:,:,KINDEX)
+ ELSE
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_ALLOCATE_GT3D', ' Size mismatsh ' )
+ END IF
+
+ END FUNCTION MNH_ALLOCATE_GT3D
+
+ SUBROUTINE MNH_CHECK_IN_ZT3D(HSUB)
+ IMPLICIT NONE
+
+ CHARACTER(LEN=*) :: HSUB
+
+ print*,"MNH_CHECK_IN_ZT3D => " , NT3D_TOP_CURRENT_INDEX+1 , HSUB
+ NT3D_TOP_CURRENT_INDEX = NT3D_TOP_CURRENT_INDEX + 1
+ NT3D_TOP_CURRENT(NT3D_TOP_CURRENT_INDEX) = NT3D_TOP
+ END SUBROUTINE MNH_CHECK_IN_ZT3D
+
+ SUBROUTINE MNH_CHECK_OUT_ZT3D(HSUB)
+ IMPLICIT NONE
+ CHARACTER(LEN=*) :: HSUB
+
+ print*,"MNH_CHECK_OUT_ZT3D <= " , NT3D_TOP_CURRENT_INDEX , HSUB
+ IF ( NT3D_TOP_CURRENT(NT3D_TOP_CURRENT_INDEX) .NE. NT3D_TOP ) THEN
+ WRITE( *, '( "MNH_CHECK_OUT_ZT3D : NT3D_TOP_CURRENT .NE. NT3D_TOP (",2I8,")" )' ) NT3D_TOP_CURRENT , NT3D_TOP
+ call Print_msg( NVERB_ERROR, 'GEN', 'MNH_CHECK_OUT_ZT3D', ' CHECK IN/OUT MISTASK ' )
+ ELSE
+ NT3D_TOP_CURRENT_INDEX = NT3D_TOP_CURRENT_INDEX - 1
+ END IF
+ END SUBROUTINE MNH_CHECK_OUT_ZT3D
END MODULE MODE_MNH_ZWORK
#endif
diff --git a/src/MNH/mode_prandtl.f90 b/src/MNH/mode_prandtl.f90
index 04f03f419..5ac5ddc57 100644
--- a/src/MNH/mode_prandtl.f90
+++ b/src/MNH/mode_prandtl.f90
@@ -15,6 +15,7 @@ USE MODD_PARAMETERS, ONLY : JPVEXT_TURB
#ifdef MNH_OPENACC
use mode_msg
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_GT3D , MNH_REL_GT3D
#endif
#ifdef MNH_BITREP
@@ -37,9 +38,18 @@ REAL, DIMENSION(:,:,:), INTENT(IN) :: PF_LIM ! Value of F when Phi3 is
! ! larger than Phi_lim
REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PF ! function F to smooth
!
+#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PF,1),SIZE(PF,2),SIZE(PF,3)) :: ZCOEF
+#else
+REAL, DIMENSION(:,:,:), pointer,contiguous :: ZCOEF
+INTEGER :: IZCOEF
+#endif
-!$acc data present( PPHI3, PF_LIM, PF ) create( ZCOEF )
+#ifdef MNH_OPENACC
+ IZCOEF = MNH_ALLOCATE_ZT3D( ZCOEF , SIZE(PF,1),SIZE(PF,2),SIZE(PF,3) )
+#endif
+
+!$acc data present( PPHI3, PF_LIM, PF ) present( ZCOEF )
!* adds a artificial correction to smooth the function near the discontinuity
! point at Phi3 = Phi_lim
@@ -56,6 +66,10 @@ PF(:,:,:) = ZCOEF(:,:,:) * PF &
!$acc end data
+#ifdef MNH_OPENACC
+CALL MNH_REL_ZT3D(IZCOEF)
+#endif
+
END SUBROUTINE SMOOTH_TURB_FUNCT
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
@@ -77,19 +91,33 @@ SUBROUTINE PHI3(PREDTH1,PREDR1,PRED2TH3,PRED2R3,PRED2THR3,HTURBDIM,OUSERV,PPHI3)
#endif
!
INTEGER :: IKB, IKE
- LOGICAL,DIMENSION(:,:,:), allocatable :: PHI3LOGIC
- REAL, DIMENSION(:,:,:), allocatable :: ZW1, ZW2
+ LOGICAL,DIMENSION(:,:,:), pointer , contiguous :: GPHI3LOGIC
+ REAL, DIMENSION(:,:,:), pointer , contiguous :: ZW1, ZW2
+ INTEGER :: IGPHI3LOGIC,IZW1, IZW2
+ INTEGER :: JIU,JJU,JKU
+ INTEGER :: JI,JJ,JK
+
!$acc data present( PREDTH1, PREDR1, PRED2TH3, PRED2R3, PRED2THR3, PPHI3 )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
+JIU = size( predth1, 1 )
+JJU = size( predth1, 2 )
+JKU = size( predth1, 3 )
+
+#ifndef MNH_OPENACC
allocate( zw1 ( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
allocate( zw2 ( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
-allocate( phi3logic( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
+allocate( gphi3logic( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
+#else
+izw1 = MNH_ALLOCATE_ZT3D( zw1 , JIU,JJU,JKU )
+izw2 = MNH_ALLOCATE_ZT3D( zw2 , JIU,JJU,JKU )
+igphi3logic = MNH_ALLOCATE_GT3D( gphi3logic, JIU,JJU,JKU )
+#endif
-!$acc data create( zw1, zw2, phi3logic )
+!$acc data present( zw1, zw2, gphi3logic )
!$acc kernels
IF (HTURBDIM=='3DIM') THEN
@@ -124,8 +152,8 @@ IF (HTURBDIM=='3DIM') THEN
!WARNING: BUG PGI (tested up to PGI 16.10): necessary to use a logical mask
!because the compiler does not manage correctly the .OR. in the WHERE
!WHERE( PPHI3 <= 0. .OR. PPHI3 > XPHI_LIM )
- PHI3LOGIC = (PPHI3 <= 0. .OR. PPHI3 > XPHI_LIM)
- WHERE( PHI3LOGIC )
+ GPHI3LOGIC = (PPHI3 <= 0. .OR. PPHI3 > XPHI_LIM)
+ WHERE( GPHI3LOGIC )
PPHI3 = XPHI_LIM
END WHERE
@@ -144,6 +172,13 @@ PPHI3(:,:,IKE+1)=PPHI3(:,:,IKE)
!$acc end data
+#ifndef MNH_OPENACC
+deallocate ( zw1,zw2,gphi3logic)
+#else
+CALL MNH_REL_ZT3D(IZW1,IZW2)
+CALL MNH_REL_GT3D(IGPHI3LOGIC)
+#endif
+
!$acc end data
#ifndef MNH_OPENACC
@@ -172,13 +207,18 @@ SUBROUTINE PSI_SV(PREDTH1,PREDR1,PREDS1,PRED2THS,PRED2RS,PPHI3,PPSI3,PPSI_SV)
!
INTEGER :: IKB, IKE
INTEGER :: JSV
- LOGICAL, DIMENSION(:,:,:), allocatable :: PSILOGIC
+ LOGICAL, DIMENSION(:,:,:), pointer , contiguous :: GPSILOGIC
+ INTEGER :: IGPSILOGIC
!$acc data present( PREDTH1, PREDR1, PREDS1, PRED2THS, PRED2RS, PPHI3, PPSI3, PPSI_SV )
-allocate( psilogic( size( pred2ths, 1 ), size( pred2ths, 2 ), size( pred2ths, 3 ) ) )
+#ifndef MNH_OPENACC
+allocate( gpsilogic( size( pred2ths, 1 ), size( pred2ths, 2 ), size( pred2ths, 3 ) ) )
+#else
+igpsilogic = MNH_ALLOCATE_GT3D( gpsilogic , size( pred2ths, 1 ), size( pred2ths, 2 ), size( pred2ths, 3 ) )
+#endif
-!$acc data create( psilogic )
+!$acc data present( gpsilogic )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
@@ -196,8 +236,8 @@ DO JSV=1,SIZE(PPSI_SV,4)
!because the compiler does not manage correctly the .AND. in the WHERE
!Failure during execution
!WHERE ( (PPSI_SV(:,:,:,JSV) <=0.).AND. (PREDTH1+PREDR1) <= 0. )
- PSILOGIC = ((PPSI_SV(:,:,:,JSV) <=0.).AND. (PREDTH1+PREDR1) <= 0. )
- WHERE ( PSILOGIC )
+ GPSILOGIC = ((PPSI_SV(:,:,:,JSV) <=0.).AND. (PREDTH1+PREDR1) <= 0. )
+ WHERE ( GPSILOGIC )
PPSI_SV(:,:,:,JSV)=XPHI_LIM
END WHERE
PPSI_SV(:,:,:,JSV) = MAX( 1.E-4, MIN(XPHI_LIM,PPSI_SV(:,:,:,JSV)) )
@@ -209,6 +249,12 @@ END DO
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( gpsilogic )
+#else
+CALL MNH_REL_GT3D(IGPSILOGIC)
+#endif
+
!$acc end data
#ifndef MNH_OPENACC
@@ -399,16 +445,17 @@ SUBROUTINE D_PHI3DTDZ2_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,PDTDZ,HTU
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
- REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
+ REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE
+ INTEGER :: IZTMP1_DEVICE
#endif
!$acc data present( PPHI3, PREDTH1, PREDR1, PRED2TH3, PRED2THR3, PDTDZ, PD_PHI3DTDZ2_O_DDTDZ )
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device, size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) )
#endif
-!$acc data create( ztmp1_device )
+!$acc data present( ztmp1_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
@@ -469,6 +516,10 @@ PD_PHI3DTDZ2_O_DDTDZ(:,:,IKE+1)=PD_PHI3DTDZ2_O_DDTDZ(:,:,IKE)
!$acc end data
+#ifdef MNH_OPENACC
+CALL MNH_REL_ZT3D( iztmp1_device )
+#endif
+
!$acc end data
#ifndef MNH_OPENACC
diff --git a/src/MNH/ppm_met.f90 b/src/MNH/ppm_met.f90
index f9f2d3e6c..76cebf49b 100644
--- a/src/MNH/ppm_met.f90
+++ b/src/MNH/ppm_met.f90
@@ -170,7 +170,7 @@ END IF
!* 1. COMPUTES THE DOMAIN DIMENSIONS
! ------------------------------
!
-GTKEALLOC = SIZE(PTKET,1) /= 0
+GTKEALLOC = SIZE(PTKET) /= 0
!
!-------------------------------------------------------------------------------
!
diff --git a/src/MNH/prandtl.f90 b/src/MNH/prandtl.f90
index 89a3542ca..0b0815ba5 100644
--- a/src/MNH/prandtl.f90
+++ b/src/MNH/prandtl.f90
@@ -75,8 +75,6 @@ END INTERFACE
!
END MODULE MODI_PRANDTL
!
-!
-!
! ###########################################################
SUBROUTINE PRANDTL(KKA,KKU,KKL,KRR,KRRI,OCLOSE_OUT,OTURB_DIAG,&
HTURBDIM, &
@@ -220,6 +218,11 @@ USE MODI_SHUMAN
USE MODI_SHUMAN_DEVICE
#endif
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
+#endif
+!
IMPLICIT NONE
!
!
@@ -274,7 +277,11 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PEMOIST ! coefficient E_moist
!
! 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZW1, ZW2 ! work arrays
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZW1
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZW2 ! work arrays
+#ifdef MNH_OPENACC
+INTEGER :: IZW1, IZW2
+#endif
!
INTEGER :: IKB ! vertical index value for the first inner mass point
INTEGER :: IKE ! vertical index value for the last inner mass point
@@ -285,13 +292,17 @@ INTEGER :: JLOOP
REAL :: ZMINVAL
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP2_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP3_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP4_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP5_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP5_DEVICE
+INTEGER :: IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE,IZTMP4_DEVICE,IZTMP5_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PDXX, PDYY, PDZZ, PDZX, PDZY, &
@@ -320,18 +331,28 @@ if ( mppdb_initialized ) then
call Mppdb_check( psrcm, "Prandtl beg:psrcm" )
end if
-allocate( zw1(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zw2(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size( pthlm, 1 )
+JJU = size( pthlm, 2 )
+JKU = size( pthlm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zw1(JIU,JJU,JKU ) )
+allocate( zw2(JIU,JJU,JKU ) )
+#else
+CALL MNH_CHECK_IN_ZT3D("PRANDTL")
+izw1 = MNH_ALLOCATE_ZT3D( zw1, JIU,JJU,JKU )
+izw2 = MNH_ALLOCATE_ZT3D( zw2, JIU,JJU,JKU )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp5_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device, JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device, JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device, JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device, JIU,JJU,JKU )
+iztmp5_device = MNH_ALLOCATE_ZT3D( ztmp5_device, JIU,JJU,JKU )
#endif
-!$acc data create( zw1, zw2, ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, ztmp5_device )
+!$acc data present( zw1, zw2, ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, ztmp5_device )
!
!* 1. DEFAULT VALUES, 1D REDELSPERGER NUMBERS
@@ -362,7 +383,8 @@ PEMOIST(:,:,KKA) = 2.*PEMOIST(:,:,IKB) - PEMOIST(:,:,IKB+KKL)
! 1.3 1D Redelsperger numbers
!
#ifndef MNH_OPENACC
-PBLL_O_E(:,:,:) = MZM( XG / PTHVREF(:,:,:) * PLM(:,:,:) * PLEPS(:,:,:) / PTKEM(:,:,:) )
+PBLL_O_E(:,:,:) = MZM( XG / PTHVREF(:,:,:) * PLM(:,:,:) * PLEPS(:,:,:) &
+ / PTKEM(:,:,:) )
IF (KRR /= 0) THEN ! moist case
PREDTH1(:,:,:)= XCTV*PBLL_O_E(:,:,:) * PETHETA(:,:,:) * &
& GZ_M_W(KKA,KKU,KKL,PTHLM,PDZZ)
@@ -374,23 +396,24 @@ ELSE ! dry case
END IF
#else
!$acc kernels
-ZTMP1_DEVICE(:,:,:) = XG / PTHVREF(:,:,:) * PLM(:,:,:) * PLEPS(:,:,:) / PTKEM(:,:,:)
+ZTMP1_DEVICE(:,:,:) = XG / PTHVREF(:,:,:) * PLM(:,:,:) * PLEPS(:,:,:) &
+ / PTKEM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,PBLL_O_E)
IF (KRR /= 0) THEN ! moist case
CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PTHLM,PDZZ,ZTMP1_DEVICE)
-!$acc kernels async
- PREDTH1(:,:,:)= XCTV*PBLL_O_E(:,:,:) * PETHETA(:,:,:) * ZTMP1_DEVICE
+!$acc kernels ! async
+ PREDTH1(:,:,:)= XCTV*PBLL_O_E(:,:,:) * PETHETA(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDZZ,ZTMP2_DEVICE)
-!$acc kernels async
- PREDR1(:,:,:) = XCTV*PBLL_O_E(:,:,:) * PEMOIST(:,:,:) * ZTMP2_DEVICE
+!$acc kernels ! async
+ PREDR1(:,:,:) = XCTV*PBLL_O_E(:,:,:) * PEMOIST(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
-!$acc wait
+! acc wait
ELSE ! dry case
CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PTHLM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
- PREDTH1(:,:,:)= XCTV*PBLL_O_E(:,:,:) * ZTMP1_DEVICE
+ PREDTH1(:,:,:) = XCTV*PBLL_O_E(:,:,:) * ZTMP1_DEVICE(:,:,:)
PREDR1(:,:,:) = 0.
!$acc end kernels
END IF
@@ -399,46 +422,63 @@ END IF
! 3. Limits on 1D Redelperger numbers
! --------------------------------
!
-!$acc kernels
ZMINVAL = (1.-1./XPHI_LIM)
!
-ZW1 = 1.
-ZW2 = 1.
-!
-WHERE (PREDTH1+PREDR1<-ZMINVAL)
- ZW1 = (-ZMINVAL) / (PREDTH1+PREDR1)
+!$acc kernels
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZW1(JI,JJ,JK) = 1.
+ ZW2(JI,JJ,JK) = 1.
+END DO
+
+WHERE (PREDTH1(:,:,:)+PREDR1(:,:,:) < -ZMINVAL)
+ ZW1(:,:,:) = (-ZMINVAL) / (PREDTH1(:,:,:)+PREDR1(:,:,:))
END WHERE
-!
-WHERE (PREDTH1<-ZMINVAL)
- ZW2 = (-ZMINVAL) / (PREDTH1)
+
+WHERE (PREDTH1(:,:,:) < -ZMINVAL)
+ ZW2(:,:,:) = (-ZMINVAL) / (PREDTH1(:,:,:))
END WHERE
-ZW2 = MIN(ZW1,ZW2)
-!
-ZW1 = 1.
-WHERE (PREDR1<-ZMINVAL)
- ZW1 = (-ZMINVAL) / (PREDR1)
+
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZW2(JI,JJ,JK) = MIN( ZW1(JI,JJ,JK),ZW2(JI,JJ,JK) )
+END DO
+
+ZW1(:,:,:) = 1.
+WHERE (PREDR1(:,:,:)<-ZMINVAL)
+ ZW1(:,:,:) = (-ZMINVAL) / (PREDR1(:,:,:))
END WHERE
-ZW1 = MIN(ZW2,ZW1)
+
+!!$ZW1(:,:,:) = MIN(ZW2(:,:,:),ZW1(:,:,:))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZW1(JI,JJ,JK) = MIN( ZW2(JI,JJ,JK),ZW1(JI,JJ,JK) )
+END DO
!
+!$acc end kernels
!
! 3. Modification of Mixing length and dissipative length
! ----------------------------------------------------
!
-PBLL_O_E(:,:,:) = PBLL_O_E(:,:,:) * ZW1(:,:,:)
-PREDTH1 (:,:,:) = PREDTH1 (:,:,:) * ZW1(:,:,:)
-PREDR1 (:,:,:) = PREDR1 (:,:,:) * ZW1(:,:,:)
+!$acc kernels
+!
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PBLL_O_E(JI,JJ,JK) = PBLL_O_E(JI,JJ,JK) * ZW1(JI,JJ,JK)
+ PREDTH1 (JI,JJ,JK) = PREDTH1 (JI,JJ,JK) * ZW1(JI,JJ,JK)
+ PREDR1 (JI,JJ,JK) = PREDR1 (JI,JJ,JK) * ZW1(JI,JJ,JK)
+END DO !CONCURRENT
!
! 4. Threshold for very small (in absolute value) Redelperger numbers
! ----------------------------------------------------------------
!
-ZW2=SIGN(1.,PREDTH1(:,:,:))
+ZW2(:,:,:)=SIGN(1.,PREDTH1(:,:,:))
PREDTH1(:,:,:)= ZW2(:,:,:) * MAX(XMNH_TINY_12, ZW2(:,:,:)*PREDTH1(:,:,:))
+!$acc end kernels
!
IF (KRR /= 0) THEN ! dry case
- ZW2=SIGN(1.,PREDR1(:,:,:))
+!$acc kernels
+ ZW2(:,:,:)=SIGN(1.,PREDR1(:,:,:))
PREDR1(:,:,:)= ZW2(:,:,:) * MAX(XMNH_TINY_12, ZW2(:,:,:)*PREDR1(:,:,:))
+ !$acc end kernels
END IF
-!$acc end kernels
+
!
!---------------------------------------------------------------------------
!
@@ -452,14 +492,14 @@ END DO
DO JSV=1,ISV
CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PSVM(:,:,:,JSV),PDZZ,ZTMP1_DEVICE)
!$acc kernels
- PREDS1(:,:,:,JSV)=XCTV*PBLL_O_E(:,:,:)*ZTMP1_DEVICE
+ PREDS1(:,:,:,JSV)=XCTV*PBLL_O_E(:,:,:)*ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END DO
#endif
!
!$acc kernels
DO JSV=1,ISV
- ZW2=SIGN(1.,PREDS1(:,:,:,JSV))
+ ZW2(:,:,:)=SIGN(1.,PREDS1(:,:,:,JSV))
PREDS1(:,:,:,JSV)= ZW2(:,:,:) * MAX(XMNH_TINY_12, ZW2(:,:,:)*PREDS1(:,:,:,JSV))
END DO
!$acc end kernels
@@ -471,7 +511,7 @@ END DO
!
IF(HTURBDIM=='1DIM') THEN ! 1D case
!
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2
#else
@@ -479,7 +519,7 @@ IF(HTURBDIM=='1DIM') THEN ! 1D case
#endif
!$acc end kernels
!
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
PRED2R3(:,:,:) = PREDR1(:,:,:) **2
#else
@@ -487,10 +527,10 @@ IF(HTURBDIM=='1DIM') THEN ! 1D case
#endif
!$acc end kernels
!
-!$acc kernels async
+!$acc kernels ! async
PRED2THR3(:,:,:) = PREDTH1(:,:,:) * PREDR1(:,:,:)
!$acc end kernels
-!$acc wait
+! acc wait
!
ELSE IF (L2D) THEN ! 3D case in a 2D model
!
@@ -508,17 +548,23 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PTHLM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = ZTMP1_DEVICE**2
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)**2
#else
- ZTMP1_DEVICE = BR_P2(ZTMP1_DEVICE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = BR_P2(ZTMP1_DEVICE(JI,JJ,JK))
+END DO !CONCURRENT
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE )
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
- PRED2TH3(:,:,:)= PREDTH1(:,:,:)**2+(XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) )**2 * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 &
+ + (XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) )**2 &
+ * ZTMP2_DEVICE(:,:,:)
#else
- PRED2TH3(:,:,:)= BR_P2(PREDTH1(:,:,:))+BR_P2(XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) ) * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) &
+ + BR_P2(XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) ) &
+ * ZTMP2_DEVICE(:,:,:)
#endif
PRED2TH3(:,:,IKB)=PRED2TH3(:,:,IKB+KKL)
!$acc end kernels
@@ -526,28 +572,36 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
!
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- PRED2R3(:,:,:)= PREDR1(:,:,:)**2 + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 * &
- MZM( GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)**2 )
+ PRED2R3(:,:,:) = PREDR1(:,:,:)**2 &
+ + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 &
+ * MZM( GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)**2 )
#else
- PRED2R3(:,:,:)= BR_P2(PREDR1(:,:,:)) + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) * &
- MZM( BR_P2(GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)) )
+ PRED2R3(:,:,:) = BR_P2(PREDR1(:,:,:)) &
+ + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) &
+ * MZM( BR_P2(GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)) )
#endif
PRED2R3(:,:,IKB)=PRED2R3(:,:,IKB+KKL)
#else
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = ZTMP1_DEVICE**2
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)**2
#else
- ZTMP1_DEVICE = BR_P2(ZTMP1_DEVICE)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = BR_P2(ZTMP1_DEVICE(JI,JJ,JK))
+ END DO !CONCURRENT
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE )
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
- PRED2R3(:,:,:)= PREDR1(:,:,:)**2 + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 * ZTMP2_DEVICE
+ PRED2R3(:,:,:) = PREDR1(:,:,:)**2 &
+ + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 &
+ * ZTMP2_DEVICE(:,:,:)
#else
- PRED2R3(:,:,:)= BR_P2(PREDR1(:,:,:)) + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) * ZTMP2_DEVICE
+ PRED2R3(:,:,:) = BR_P2(PREDR1(:,:,:)) &
+ + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) &
+ * ZTMP2_DEVICE(:,:,:)
#endif
PRED2R3(:,:,IKB)=PRED2R3(:,:,IKB+KKL)
!$acc end kernels
@@ -555,9 +609,11 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
!
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + XCTV**2*PBLL_O_E(:,:,:)**2 * &
+ PRED2THR3(:,:,:) = PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + XCTV**2*PBLL_O_E(:,:,:)**2 * &
#else
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
+ PRED2THR3(:,:,:) = PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
#endif
PEMOIST(:,:,:) * PETHETA(:,:,:) * &
MZM( GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)* &
@@ -567,19 +623,26 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PTHLM ,PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + XCTV**2*PBLL_O_E(:,:,:)**2 * &
+ PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + XCTV**2*PBLL_O_E(:,:,:)**2 &
+ * PEMOIST(:,:,:) * PETHETA(:,:,:) &
+ * ZTMP2_DEVICE(:,:,:)
#else
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
-#endif
- PEMOIST(:,:,:) * PETHETA(:,:,:) * ZTMP2_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRED2THR3(JI,JJ,JK)= PREDR1(JI,JJ,JK) * PREDTH1(JI,JJ,JK) + BR_P2(XCTV)*BR_P2(PBLL_O_E(JI,JJ,JK)) * &
+ PEMOIST(JI,JJ,JK) * PETHETA(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+END DO
+#endif
PRED2THR3(:,:,IKB)=PRED2THR3(:,:,IKB+KKL)
!$acc end kernels
-!$acc wait
+! acc wait
#endif
!
ELSE ! dry 3D case in a 2D model
@@ -599,17 +662,21 @@ call Print_msg( NVERB_WARNING, 'GEN', 'PRANDTL', 'OpenACC: L2D=.T. and KRR=0 not
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PTHLM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = ZTMP1_DEVICE**2
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)**2
#else
- ZTMP1_DEVICE = BR_P2(ZTMP1_DEVICE)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = BR_P2(ZTMP1_DEVICE(JI,JJ,JK))
+ END DO !CONCURRENT
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 + XCTV**2*PBLL_O_E(:,:,:)**2 * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 + XCTV**2*PBLL_O_E(:,:,:)**2 * &
+ ZTMP2_DEVICE(:,:,:)
#else
- PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
+ ZTMP2_DEVICE(:,:,:)
#endif
!PW: merge kernels + remove async to prevent compiler crash...(bug PGI 19.10)
! !$acc end kernels
@@ -634,13 +701,15 @@ ELSE ! 3D case in a 3D model
IF (KRR /= 0) THEN ! moist 3D case
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- PRED2TH3(:,:,:)= PREDTH1(:,:,:)**2 + ( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) )**2 * &
- MZM( GX_M_M(PTHLM,PDXX,PDZZ,PDZX)**2 &
- + GY_M_M(PTHLM,PDYY,PDZZ,PDZY)**2 )
+ PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 &
+ + ( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) )**2 &
+ * MZM( GX_M_M(PTHLM,PDXX,PDZZ,PDZX)**2 &
+ + GY_M_M(PTHLM,PDYY,PDZZ,PDZY)**2 )
#else
- PRED2TH3(:,:,:)= BR_P2(PREDTH1(:,:,:)) + BR_P2( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) ) * &
- MZM( BR_P2(GX_M_M(PTHLM,PDXX,PDZZ,PDZX)) &
- + BR_P2(GY_M_M(PTHLM,PDYY,PDZZ,PDZY)) )
+ PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) &
+ + BR_P2( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) ) &
+ * MZM( BR_P2(GX_M_M(PTHLM,PDXX,PDZZ,PDZX)) &
+ + BR_P2(GY_M_M(PTHLM,PDYY,PDZZ,PDZY)) )
#endif
PRED2TH3(:,:,IKB)=PRED2TH3(:,:,IKB+KKL)
#else
@@ -648,17 +717,23 @@ ELSE ! 3D case in a 3D model
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PTHLM,PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = ZTMP1_DEVICE**2 + ZTMP2_DEVICE**2
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)**2 + ZTMP2_DEVICE(:,:,:)**2
#else
- ZTMP1_DEVICE = BR_P2(ZTMP1_DEVICE) + BR_P2(ZTMP2_DEVICE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = BR_P2(ZTMP1_DEVICE(JI,JJ,JK)) + BR_P2(ZTMP2_DEVICE(JI,JJ,JK))
+END DO
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- PRED2TH3(:,:,:)= PREDTH1(:,:,:)**2 + ( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) )**2 * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 &
+ + ( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) )**2 &
+ * ZTMP2_DEVICE(:,:,:)
#else
- PRED2TH3(:,:,:)= BR_P2(PREDTH1(:,:,:)) + BR_P2( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) ) * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) &
+ + BR_P2( XCTV*PBLL_O_E(:,:,:)*PETHETA(:,:,:) ) &
+ * ZTMP2_DEVICE(:,:,:)
#endif
PRED2TH3(:,:,IKB)=PRED2TH3(:,:,IKB+KKL)
!$acc end kernels
@@ -666,13 +741,15 @@ ELSE ! 3D case in a 3D model
!
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- PRED2R3(:,:,:)= PREDR1(:,:,:)**2 + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 * &
- MZM( GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)**2 + &
- GY_M_M(PRM(:,:,:,1),PDYY,PDZZ,PDZY)**2 )
+ PRED2R3(:,:,:) = PREDR1(:,:,:)**2 &
+ + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 &
+ * MZM( GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)**2 &
+ + GY_M_M(PRM(:,:,:,1),PDYY,PDZZ,PDZY)**2 )
#else
- PRED2R3(:,:,:)= BR_P2(PREDR1(:,:,:)) + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) * &
- MZM( BR_P2(GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)) + &
- BR_P2(GY_M_M(PRM(:,:,:,1),PDYY,PDZZ,PDZY)) )
+ PRED2R3(:,:,:) = BR_P2(PREDR1(:,:,:)) &
+ + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) &
+ * MZM( BR_P2(GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)) &
+ +BR_P2(GY_M_M(PRM(:,:,:,1),PDYY,PDZZ,PDZY)) )
#endif
PRED2R3(:,:,IKB)=PRED2R3(:,:,IKB+KKL)
#else
@@ -680,31 +757,39 @@ ELSE ! 3D case in a 3D model
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = ZTMP1_DEVICE**2 + ZTMP2_DEVICE**2
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)**2 + ZTMP2_DEVICE(:,:,:)**2
#else
- ZTMP1_DEVICE = BR_P2(ZTMP1_DEVICE) + BR_P2(ZTMP2_DEVICE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = BR_P2(ZTMP1_DEVICE(JI,JJ,JK)) + BR_P2(ZTMP2_DEVICE(JI,JJ,JK))
+END DO
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- PRED2R3(:,:,:)= PREDR1(:,:,:)**2 + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 * ZTMP2_DEVICE
+ PRED2R3(:,:,:) = PREDR1(:,:,:)**2 &
+ + (XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:))**2 &
+ * ZTMP2_DEVICE(:,:,:)
#else
- PRED2R3(:,:,:)= BR_P2(PREDR1(:,:,:)) + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) * ZTMP2_DEVICE
+ PRED2R3(:,:,:) = BR_P2(PREDR1(:,:,:)) &
+ + BR_P2(XCTV*PBLL_O_E(:,:,:)*PEMOIST(:,:,:)) &
+ * ZTMP2_DEVICE(:,:,:)
#endif
!$acc end kernels
-!$acc kernels async
+!$acc kernels ! async
PRED2R3(:,:,IKB)=PRED2R3(:,:,IKB+KKL)
!$acc end kernels
#endif
!
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + XCTV**2*PBLL_O_E(:,:,:)**2 * &
+ PRED2THR3(:,:,:) = PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + XCTV**2*PBLL_O_E(:,:,:)**2 * &
#else
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
+ PRED2THR3(:,:,:) = PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
#endif
- PEMOIST(:,:,:) * PETHETA(:,:,:) * &
+ PEMOIST(:,:,:) * PETHETA(:,:,:) * &
MZM( GX_M_M(PRM(:,:,:,1),PDXX,PDZZ,PDZX)* &
GX_M_M(PTHLM,PDXX,PDZZ,PDZX)+ &
GY_M_M(PRM(:,:,:,1),PDYY,PDZZ,PDZY)* &
@@ -716,21 +801,26 @@ ELSE ! 3D case in a 3D model
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP3_DEVICE)
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PTHLM ,PDYY,PDZZ,PDZY,ZTMP4_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE+ZTMP3_DEVICE*ZTMP4_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)+ &
+ ZTMP3_DEVICE(JI,JJ,JK)*ZTMP4_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + XCTV**2*PBLL_O_E(:,:,:)**2 * &
+ PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + XCTV**2*PBLL_O_E(:,:,:)**2 * &
#else
- PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
+ PRED2THR3(:,:,:)= PREDR1(:,:,:) * PREDTH1(:,:,:) &
+ + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * &
#endif
- PEMOIST(:,:,:) * PETHETA(:,:,:) * ZTMP2_DEVICE
+ PEMOIST(:,:,:) * PETHETA(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
-!$acc kernels async
+!$acc kernels ! async
PRED2THR3(:,:,IKB)=PRED2THR3(:,:,IKB+KKL)
!$acc end kernels
-!$acc wait
+! acc wait
#endif
!
ELSE ! dry 3D case in a 3D model
@@ -752,32 +842,36 @@ call Print_msg( NVERB_WARNING, 'GEN', 'PRANDTL', 'OpenACC: L2D=.F. and KRR=0 not
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PTHLM,PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = ZTMP1_DEVICE**2 + ZTMP2_DEVICE**2
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)**2 + ZTMP2_DEVICE(:,:,:)**2
#else
- ZTMP1_DEVICE = BR_P2(ZTMP1_DEVICE) + BR_P2(ZTMP2_DEVICE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = BR_P2(ZTMP1_DEVICE(JI,JJ,JK)) + BR_P2(ZTMP2_DEVICE(JI,JJ,JK))
+END DO
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 + XCTV**2*PBLL_O_E(:,:,:)**2 * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = PREDTH1(:,:,:)**2 + XCTV**2*PBLL_O_E(:,:,:)**2 &
+ * ZTMP2_DEVICE(:,:,:)
#else
- PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) * ZTMP2_DEVICE
+ PRED2TH3(:,:,:) = BR_P2(PREDTH1(:,:,:)) + BR_P2(XCTV)*BR_P2(PBLL_O_E(:,:,:)) &
+ * ZTMP2_DEVICE(:,:,:)
#endif
!$acc end kernels
#endif
-!$acc kernels async
+!$acc kernels ! async
PRED2TH3(:,:,IKB)=PRED2TH3(:,:,IKB+KKL)
!$acc end kernels
!
-!$acc kernels async
+!$acc kernels ! async
PRED2R3(:,:,:) = 0.
!$acc end kernels
!
-!$acc kernels async
+!$acc kernels ! async
PRED2THR3(:,:,:) = 0.
!$acc end kernels
-!$acc wait
+! acc wait
!
END IF
!
@@ -791,16 +885,20 @@ END IF ! end of the if structure on the turbulence dimensionnality
!
IF(HTURBDIM=='1DIM') THEN
! 1D case
-!$acc kernels
DO JSV=1,ISV
+ !$acc kernels
PRED2THS3(:,:,:,JSV) = PREDS1(:,:,:,JSV) * PREDTH1(:,:,:)
+ !$acc end kernels
IF (KRR /= 0) THEN
+ !$acc kernels
PRED2RS3(:,:,:,JSV) = PREDR1(:,:,:) *PREDS1(:,:,:,JSV)
+ !$acc end kernels
ELSE
+ !$acc kernels
PRED2RS3(:,:,:,JSV) = 0.
+ !$acc end kernels
END IF
ENDDO
-!$acc end kernels
!
ELSE IF (L2D) THEN ! 3D case in a 2D model
!
@@ -823,9 +921,9 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
DO JSV=1,ISV
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = (XG / PTHVREF * PLM * PLEPS / PTKEM)**2
+ ZTMP1_DEVICE(:,:,:) = (XG / PTHVREF * PLM * PLEPS / PTKEM)**2
#else
- ZTMP1_DEVICE = BR_P2(XG / PTHVREF * PLM * PLEPS / PTKEM)
+ ZTMP1_DEVICE(:,:,:) = BR_P2(XG / PTHVREF * PLM * PLEPS / PTKEM)
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZW1)
@@ -846,11 +944,11 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PSVM(:,:,:,JSV),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PTHLM ,PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- PRED2THS3(:,:,:,JSV) = PREDTH1(:,:,:) * PREDS1(:,:,:,JSV) + ZW1 * ZTMP2_DEVICE
+ PRED2THS3(:,:,:,JSV) = PREDTH1(:,:,:) * PREDS1(:,:,:,JSV) + ZW1(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -865,12 +963,12 @@ ELSE IF (L2D) THEN ! 3D case in a 2D model
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PSVM(:,:,:,JSV),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL GX_M_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1) ,PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
PRED2RS3(:,:,:,JSV) = PREDR1(:,:,:) * PREDS1(:,:,:,JSV) + &
- ZW1 * PEMOIST * ZTMP2_DEVICE
+ ZW1(:,:,:) * PEMOIST * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
ELSE
@@ -901,22 +999,22 @@ ELSE ! 3D case in a 3D model
DO JSV=1,ISV
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = (XG / PTHVREF * PLM * PLEPS / PTKEM)**2
+ ZTMP1_DEVICE(:,:,:) = (XG / PTHVREF * PLM * PLEPS / PTKEM)**2
#else
- ZTMP1_DEVICE = BR_P2(XG / PTHVREF * PLM * PLEPS / PTKEM)
+ ZTMP1_DEVICE(:,:,:) = BR_P2(XG / PTHVREF * PLM * PLEPS / PTKEM)
#endif
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZW1)
IF (KRR /= 0) THEN
!$acc kernels
- ZW1 = ZW1*PETHETA
+ ZW1(:,:,:) = ZW1(:,:,:)*PETHETA
!$acc end kernels
END IF
#endif
!
#ifndef MNH_OPENACC
PRED2THS3(:,:,:,JSV) = PREDTH1(:,:,:) * PREDS1(:,:,:,JSV) + &
- ZW1* &
+ ZW1(:,:,:)* &
MZM(GX_M_M(PSVM(:,:,:,JSV),PDXX,PDZZ,PDZX)* &
GX_M_M(PTHLM,PDXX,PDZZ,PDZX) &
+GY_M_M(PSVM(:,:,:,JSV),PDYY,PDZZ,PDZY)* &
@@ -928,11 +1026,13 @@ ELSE ! 3D case in a 3D model
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PSVM(:,:,:,JSV),PDYY,PDZZ,PDZY,ZTMP3_DEVICE)
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PTHLM ,PDYY,PDZZ,PDZY,ZTMP4_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE+ZTMP3_DEVICE*ZTMP4_DEVICE
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)+&
+ ZTMP3_DEVICE(:,:,:)*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- PRED2THS3(:,:,:,JSV) = PREDTH1(:,:,:) * PREDS1(:,:,:,JSV) + ZW1 * ZTMP2_DEVICE
+ PRED2THS3(:,:,:,JSV) = PREDTH1(:,:,:) * PREDS1(:,:,:,JSV) + &
+ ZW1(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -951,12 +1051,13 @@ ELSE ! 3D case in a 3D model
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PSVM(:,:,:,JSV),PDYY,PDZZ,PDZY,ZTMP3_DEVICE)
CALL GY_M_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1) ,PDYY,PDZZ,PDZY,ZTMP4_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE+ZTMP3_DEVICE*ZTMP4_DEVICE
+ ZTMP1_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)+&
+ ZTMP3_DEVICE(:,:,:)*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
PRED2RS3(:,:,:,JSV) = PREDR1(:,:,:) * PREDS1(:,:,:,JSV) + &
- ZW1 * PEMOIST * ZTMP2_DEVICE
+ ZW1(:,:,:) * PEMOIST * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
ELSE
@@ -1059,8 +1160,16 @@ end if
!$acc end data
+#ifdef MNH_OPENACC
+CALL MNH_REL_ZT3D(IZW1, IZW2,IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE,IZTMP4_DEVICE,IZTMP5_DEVICE)
+CALL MNH_CHECK_OUT_ZT3D("PRANDTL")
+#else
+DEALLOCATE(ZW1,ZW2)
+#endif
+
!$acc end data
!---------------------------------------------------------------------------
!
END SUBROUTINE PRANDTL
+
diff --git a/src/MNH/tke_eps_sources.f90 b/src/MNH/tke_eps_sources.f90
index 55d7384c2..ae9c4b339 100644
--- a/src/MNH/tke_eps_sources.f90
+++ b/src/MNH/tke_eps_sources.f90
@@ -206,6 +206,9 @@ USE MODI_GET_HALO
#ifdef MNH_BITREP
USE MODI_BITREP
#endif
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
!
IMPLICIT NONE
!
@@ -248,7 +251,7 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PDISS ! Dissipati prod. of TKE
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: &
+REAL, DIMENSION(:,:,:), pointer , contiguous :: &
ZA, & ! under diagonal elements of the tri-diagonal matrix involved
! in the temporal implicit scheme
ZRES, & ! treated variable at t+ deltat when the turbu-
@@ -258,6 +261,7 @@ REAL, DIMENSION(:,:,:), allocatable :: &
ZFLX, & ! horizontal or vertical flux of the treated variable
ZSOURCE, & ! source of evolution for the treated variable
ZKEFF ! effectif diffusion coeff = LT * SQRT( TKE )
+INTEGER :: IZA,IZRES,IZFLX,IZSOURCE,IZKEFF
INTEGER :: IIB,IIE,IJB,IJE,IKB,IKE
! Index values for the Beginning and End
! mass points of the domain
@@ -268,8 +272,12 @@ INTEGER :: IINFO_ll ! return code of parallel routine
TYPE(TFIELDDATA) :: TZFIELD
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
#endif
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!----------------------------------------------------------------------------
!$acc data present( PTKEM, PLM, PLEPS, PDP, PTRH, &
@@ -299,20 +307,32 @@ if ( mppdb_initialized ) then
call Mppdb_check( prthls, "Tke_eps_sources beg:prthls" )
end if
-allocate( za (size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( zres (size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( zflx (size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( zsource(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( zkeff (size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
+JIU = size(ptkem, 1 )
+JJU = size(ptkem, 2 )
+JKU = size(ptkem, 3 )
+
+#ifndef MNH_OPENACC
+allocate( za (JIU,JJU,JKU ) )
+allocate( zres (JIU,JJU,JKU ) )
+allocate( zflx (JIU,JJU,JKU ) )
+allocate( zsource(JIU,JJU,JKU ) )
+allocate( zkeff (JIU,JJU,JKU ) )
+#else
+iza = MNH_ALLOCATE_ZT3D( za ,JIU,JJU,JKU)
+izres = MNH_ALLOCATE_ZT3D( zres ,JIU,JJU,JKU)
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU)
+izsource = MNH_ALLOCATE_ZT3D( zsource,JIU,JJU,JKU)
+izkeff = MNH_ALLOCATE_ZT3D( zkeff ,JIU,JJU,JKU)
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( ztmp2_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( ztmp3_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( ztmp4_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU)
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU)
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU)
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU)
#endif
-!$acc data create( ZA, ZRES, ZFLX, ZSOURCE, ZKEFF, ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE )
+!$acc data present( ZA, ZRES, ZFLX, ZSOURCE, ZKEFF, ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE )
NULLIFY(TZFIELDDISS_ll)
!
@@ -365,9 +385,11 @@ ZFLX(:,:,:) = XCED * SQRT(PTKEM(:,:,:)) / PLEPS(:,:,:)
#else
ZFLX(:,:,:) = XCED * BR_POW(PTKEM(:,:,:),0.5) / PLEPS(:,:,:)
#endif
-ZSOURCE(:,:,:) = PRTKES(:,:,:) / PRHODJ(:,:,:) + PRTKESM(:,:,:) / PRHODJ(:,:,:) &
- - PTKEM(:,:,:) / PTSTEP &
- + PDP(:,:,:) + PTP(:,:,:) + PTR(:,:,:) - PEXPL * ZFLX(:,:,:) * PTKEM(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZSOURCE(JI,JJ,JK) = PRTKES(JI,JJ,JK) / PRHODJ(JI,JJ,JK) + PRTKESM(JI,JJ,JK) / PRHODJ(JI,JJ,JK) &
+ - PTKEM(JI,JJ,JK) / PTSTEP &
+ + PDP(JI,JJ,JK) + PTP(JI,JJ,JK) + PTR(JI,JJ,JK) - PEXPL * ZFLX(JI,JJ,JK) * PTKEM(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
!
!* 2.2 implicit vertical TKE transport
@@ -390,7 +412,9 @@ CALL MZM_DEVICE(PRHODJ,ZTMP2_DEVICE) !Warning: re-used later
#ifndef MNH_BITREP
ZA(:,:,:) = - PTSTEP * XCET * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)**2
#else
-ZA(:,:,:) = - PTSTEP * XCET * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:) / BR_P2(PDZZ(:,:,:))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = - PTSTEP * XCET * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) / BR_P2(PDZZ(JI,JJ,JK))
+END DO !CONCURRENT
#endif
!$acc end kernels
#endif
@@ -403,7 +427,9 @@ CALL TRIDIAG_TKE(KKA,KKU,KKL,PTKEM,ZA,PTSTEP,PEXPL,PIMPL,PRHODJ,&
CALL GET_HALO(ZRES)
#else
!$acc kernels
-ZTMP3_DEVICE(:,:,:) = PTSTEP*ZFLX(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = PTSTEP*ZFLX(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
CALL TRIDIAG_TKE(KKA,KKU,KKL,PTKEM,ZA,PTSTEP,PEXPL,PIMPL,PRHODJ,&
& ZSOURCE,ZTMP3_DEVICE,ZRES)
@@ -639,6 +665,12 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( ZA, ZRES, ZFLX, ZSOURCE, ZKEFF )
+#else
+CALL MNH_REL_ZT3D( IZA, IZRES, IZFLX, IZSOURCE, IZKEFF, IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE )
+#endif
+
!$acc end data
END SUBROUTINE TKE_EPS_SOURCES
diff --git a/src/MNH/tridiag_thermo.f90 b/src/MNH/tridiag_thermo.f90
index ff79d84bb..67d34204a 100644
--- a/src/MNH/tridiag_thermo.f90
+++ b/src/MNH/tridiag_thermo.f90
@@ -6,8 +6,9 @@
! ###################
MODULE MODI_TRIDIAG_THERMO
! ###################
+!
INTERFACE
-!
+!
SUBROUTINE TRIDIAG_THERMO(KKA,KKU,KKL,PVARM,PF,PDFDDTDZ,PTSTEP,PIMPL, &
PDZZ,PRHODJ,PVARP )
!
@@ -30,9 +31,6 @@ END INTERFACE
!
END MODULE MODI_TRIDIAG_THERMO
!
-!
-!
-
! #################################################
SUBROUTINE TRIDIAG_THERMO(KKA,KKU,KKL,PVARM,PF,PDFDDTDZ,PTSTEP,PIMPL, &
PDZZ,PRHODJ,PVARP )
@@ -159,6 +157,11 @@ USE MODI_SHUMAN_DEVICE
USE MODI_BITREP
#endif
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D , MNH_ALLOCATE_ZT2D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
+#endif
+!
IMPLICIT NONE
!
!
@@ -179,12 +182,14 @@ REAL, DIMENSION(:,:,:), INTENT(OUT):: PVARP ! variable at t+1 at mass poi
!
!* 0.2 declarations of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZRHODJ_DFDDTDZ_O_DZ2
-REAL, DIMENSION(:,:,:), allocatable :: ZMZM_RHODJ
-REAL, DIMENSION(:,:,:), allocatable :: ZA, ZB, ZC
-REAL, DIMENSION(:,:,:), allocatable :: ZY ,ZGAM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZRHODJ_DFDDTDZ_O_DZ2
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZMZM_RHODJ
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZA, ZB, ZC
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZY ,ZGAM
! RHS of the equation, 3D work array
-REAL, DIMENSION(:,:), allocatable :: ZBET
+INTEGER :: IZRHODJ_DFDDTDZ_O_DZ2,IZMZM_RHODJ,IZA,IZB,IZC,IZY,IZGAM
+REAL, DIMENSION(:,:), pointer , contiguous :: ZBET
+INTEGER :: IZBET
! 2D work array
INTEGER :: JI,JJ,JK ! loop counter
INTEGER :: IKB,IKE ! inner vertical limits
@@ -193,8 +198,12 @@ INTEGER :: IKTB,IKTE ! start, end of k loops in physical domain
!
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE
+INTEGER :: IZTMP1_DEVICE
#endif
+
+INTEGER :: JIU,JJU,JKU
+
! ---------------------------------------------------------------------------
!$acc data present( PVARM, PF, PDFDDTDZ, PDZZ, PRHODJ, PVARP )
@@ -208,20 +217,36 @@ if ( mppdb_initialized ) then
call Mppdb_check( prhodj, "Tridiag_thermo beg:prhodj" )
end if
-allocate( zrhodj_dfddtdz_o_dz2(size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zmzm_rhodj (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( za (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zb (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zc (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zy (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zgam (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zbet (size( pvarm, 1 ), size( pvarm, 2 ) ) )
+JIU = size( pvarm, 1 )
+JJU = size( pvarm, 2 )
+JKU = size( pvarm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zrhodj_dfddtdz_o_dz2(JIU,JJU,JKU ) )
+allocate( zmzm_rhodj (JIU,JJU,JKU ) )
+allocate( za (JIU,JJU,JKU ) )
+allocate( zb (JIU,JJU,JKU ) )
+allocate( zc (JIU,JJU,JKU ) )
+allocate( zy (JIU,JJU,JKU ) )
+allocate( zgam (JIU,JJU,JKU ) )
+allocate( zbet (JIU,JJU ) )
+#else
+CALL MNH_CHECK_IN_ZT3D("TRIDIAG_THERMO")
+izrhodj_dfddtdz_o_dz2 = MNH_ALLOCATE_ZT3D( zrhodj_dfddtdz_o_dz2,JIU,JJU,JKU )
+izmzm_rhodj = MNH_ALLOCATE_ZT3D( zmzm_rhodj ,JIU,JJU,JKU )
+iza = MNH_ALLOCATE_ZT3D( za ,JIU,JJU,JKU )
+izb = MNH_ALLOCATE_ZT3D( zb ,JIU,JJU,JKU )
+izc = MNH_ALLOCATE_ZT3D( zc ,JIU,JJU,JKU )
+izy = MNH_ALLOCATE_ZT3D( zy ,JIU,JJU,JKU )
+izgam = MNH_ALLOCATE_ZT3D( zgam ,JIU,JJU,JKU )
+izbet = MNH_ALLOCATE_ZT2D( zbet ,JIU,JJU )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
#endif
-!$acc data create( zrhodj_dfddtdz_o_dz2, zmzm_rhodj, za, zb, zc, zy, zgam, zbet, ztmp1_device )
+!$acc data present( zrhodj_dfddtdz_o_dz2, zmzm_rhodj, za, zb, zc, zy, zgam, zbet, ztmp1_device )
!
!* 1. Preliminaries
! -------------
@@ -231,60 +256,67 @@ IKTB=1+JPVEXT_TURB
IKTE=IKT-JPVEXT_TURB
IKB=KKA+JPVEXT_TURB*KKL
IKE=KKU-JPVEXT_TURB*KKL
-
!
#ifndef MNH_OPENACC
ZMZM_RHODJ = MZM(PRHODJ)
#else
CALL MZM_DEVICE(PRHODJ,ZMZM_RHODJ)
#endif
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
ZRHODJ_DFDDTDZ_O_DZ2 = ZMZM_RHODJ*PDFDDTDZ/PDZZ**2
#else
-ZRHODJ_DFDDTDZ_O_DZ2 = ZMZM_RHODJ*PDFDDTDZ/BR_P2(PDZZ)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK) = ZMZM_RHODJ(JI,JJ,JK)*PDFDDTDZ(JI,JJ,JK)/BR_P2(PDZZ(JI,JJ,JK))
+END DO !CONCURRENT
#endif
!$acc end kernels
!
-!$acc kernels async
+!$acc kernels ! async
ZA=0.
ZB=0.
ZC=0.
ZY=0.
!$acc end kernels
-!$acc wait
+! acc wait
!
!
!* 2. COMPUTE THE RIGHT HAND SIDE
! ---------------------------
!
-!$acc kernels async
-ZY(:,:,IKB) = PRHODJ(:,:,IKB)*PVARM(:,:,IKB)/PTSTEP &
- - ZMZM_RHODJ(:,:,IKB+KKL) * PF(:,:,IKB+KKL)/PDZZ(:,:,IKB+KKL) &
- + ZMZM_RHODJ(:,:,IKB ) * PF(:,:,IKB )/PDZZ(:,:,IKB ) &
- + ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKB+KKL) * PIMPL * PVARM(:,:,IKB+KKL) &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKB+KKL) * PIMPL * PVARM(:,:,IKB )
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ZY(JI,JJ,IKB) = PRHODJ(JI,JJ,IKB)*PVARM(JI,JJ,IKB)/PTSTEP &
+ - ZMZM_RHODJ(JI,JJ,IKB+KKL) * PF(JI,JJ,IKB+KKL)/PDZZ(JI,JJ,IKB+KKL) &
+ + ZMZM_RHODJ(JI,JJ,IKB ) * PF(JI,JJ,IKB )/PDZZ(JI,JJ,IKB ) &
+ + ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKB+KKL) * PIMPL * PVARM(JI,JJ,IKB+KKL) &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKB+KKL) * PIMPL * PVARM(JI,JJ,IKB )
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
- ZY(:,:,IKTB+1:IKTE-1) = PRHODJ(:,:,IKTB+1:IKTE-1)*PVARM(:,:,IKTB+1:IKTE-1)/PTSTEP &
- - ZMZM_RHODJ(:,:,IKTB+1+KKL:IKTE-1+KKL) * PF(:,:,IKTB+1+KKL:IKTE-1+KKL)/PDZZ(:,:,IKTB+1+KKL:IKTE-1+KKL) &
- + ZMZM_RHODJ(:,:,IKTB+1:IKTE-1 ) * PF(:,:,IKTB+1:IKTE-1 )/PDZZ(:,:,IKTB+1:IKTE-1 ) &
- + ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1+KKL:IKTE-1+KKL) * PIMPL * PVARM(:,:,IKTB+1+KKL:IKTE-1+KKL) &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1+KKL:IKTE-1+KKL) * PIMPL * PVARM(:,:,IKTB+1:IKTE-1 ) &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1:IKTE-1 ) * PIMPL * PVARM(:,:,IKTB+1:IKTE-1 ) &
- + ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1:IKTE-1 ) * PIMPL * PVARM(:,:,IKTB+1-KKL:IKTE-1-KKL)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=IKTB+1:IKTE-1)
+ ZY(JI,JJ,JK) = PRHODJ(JI,JJ,JK)*PVARM(JI,JJ,JK)/PTSTEP &
+ - ZMZM_RHODJ(JI,JJ,JK+KKL) * PF(JI,JJ,JK+KKL)/PDZZ(JI,JJ,JK+KKL) &
+ + ZMZM_RHODJ(JI,JJ,JK ) * PF(JI,JJ,JK )/PDZZ(JI,JJ,JK ) &
+ + ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK+KKL) * PIMPL * PVARM(JI,JJ,JK+KKL) &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK+KKL) * PIMPL * PVARM(JI,JJ,JK ) &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK ) * PIMPL * PVARM(JI,JJ,JK ) &
+ + ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK ) * PIMPL * PVARM(JI,JJ,JK-KKL)
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
-ZY(:,:,IKE) = PRHODJ(:,:,IKE)*PVARM(:,:,IKE)/PTSTEP &
- - ZMZM_RHODJ(:,:,IKE+KKL) * PF(:,:,IKE+KKL)/PDZZ(:,:,IKE+KKL) &
- + ZMZM_RHODJ(:,:,IKE ) * PF(:,:,IKE )/PDZZ(:,:,IKE ) &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKE ) * PIMPL * PVARM(:,:,IKE ) &
- + ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKE ) * PIMPL * PVARM(:,:,IKE-KKL)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ZY(JI,JJ,IKE) = PRHODJ(JI,JJ,IKE)*PVARM(JI,JJ,IKE)/PTSTEP &
+ - ZMZM_RHODJ(JI,JJ,IKE+KKL) * PF(JI,JJ,IKE+KKL)/PDZZ(JI,JJ,IKE+KKL) &
+ + ZMZM_RHODJ(JI,JJ,IKE ) * PF(JI,JJ,IKE )/PDZZ(JI,JJ,IKE ) &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKE ) * PIMPL * PVARM(JI,JJ,IKE ) &
+ + ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKE ) * PIMPL * PVARM(JI,JJ,IKE-KKL)
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc wait
+! acc wait
!
!* 3. INVERSION OF THE TRIDIAGONAL SYSTEM
! -----------------------------------
@@ -294,77 +326,91 @@ IF ( PIMPL > 1.E-10 ) THEN
!* 3.1 arrays A, B, C
! --------------
!
-!$acc kernels async
- ZB(:,:,IKB) = PRHODJ(:,:,IKB)/PTSTEP &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKB+KKL) * PIMPL
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZB(JI,JJ,IKB) = PRHODJ(JI,JJ,IKB)/PTSTEP &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKB+KKL) * PIMPL
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
- ZC(:,:,IKB) = ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKB+KKL) * PIMPL
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZC(JI,JJ,IKB) = ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKB+KKL) * PIMPL
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
- ZA(:,:,IKTB+1:IKTE-1) = ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1:IKTE-1) * PIMPL
- ZB(:,:,IKTB+1:IKTE-1) = PRHODJ(:,:,IKTB+1:IKTE-1)/PTSTEP &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1+KKL:IKTE-1+KKL) * PIMPL &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1:IKTE-1) * PIMPL
- ZC(:,:,IKTB+1:IKTE-1) = ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKTB+1+KKL:IKTE-1+KKL) * PIMPL
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=IKTB+1:IKTE-1)
+ ZA(JI,JJ,JK) = ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK) * PIMPL
+ ZB(JI,JJ,JK) = PRHODJ(JI,JJ,JK)/PTSTEP &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK+KKL) * PIMPL &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK) * PIMPL
+ ZC(JI,JJ,JK) = ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,JK+KKL) * PIMPL
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
- ZA(:,:,IKE) = ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKE ) * PIMPL
- ZB(:,:,IKE) = PRHODJ(:,:,IKE)/PTSTEP &
- - ZRHODJ_DFDDTDZ_O_DZ2(:,:,IKE ) * PIMPL
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZA(JI,JJ,IKE) = ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKE ) * PIMPL
+ ZB(JI,JJ,IKE) = PRHODJ(JI,JJ,IKE)/PTSTEP &
+ - ZRHODJ_DFDDTDZ_O_DZ2(JI,JJ,IKE ) * PIMPL
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc wait
+! acc wait
!
!
!* 3.2 going up
! --------
!
!$acc kernels
- ZBET(:,:) = ZB(:,:,IKB) ! bet = b(ikb)
- PVARP(:,:,IKB) = ZY(:,:,IKB) / ZBET(:,:)
-
- !
- DO JK = IKB+KKL,IKE-KKL,KKL
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZBET(JI,JJ) = ZB(JI,JJ,IKB) ! bet = b(ikb)
+ PVARP(JI,JJ,IKB) = ZY(JI,JJ,IKB) / ZBET(JI,JJ)
+END DO !CONCURRENT
+!
+!$acc loop seq
+DO JK = IKB+KKL,IKE-KKL,KKL
+ !DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
!$acc loop collapse(2) independent
- DO JJ=1,SIZE(ZGAM,2)
- DO JI=1,SIZE(ZGAM,1)
- ZGAM(JI,JJ,JK) = ZC(JI,JJ,JK-KKL) / ZBET(JI,JJ)
- ! gam(k) = c(k-1) / bet
- ZBET(JI,JJ) = ZB(JI,JJ,JK) - ZA(JI,JJ,JK) * ZGAM(JI,JJ,JK)
- ! bet = b(k) - a(k)* gam(k)
- PVARP(JI,JJ,JK)= ( ZY(JI,JJ,JK) - ZA(JI,JJ,JK) * PVARP(JI,JJ,JK-KKL) ) / ZBET(JI,JJ)
- ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+ DO JJ=1,JJU
+ DO JI=1,JIU
+ ZGAM(JI,JJ,JK) = ZC(JI,JJ,JK-KKL) / ZBET(JI,JJ)
+ ! gam(k) = c(k-1) / bet
+ ZBET(JI,JJ) = ZB(JI,JJ,JK) - ZA(JI,JJ,JK) * ZGAM(JI,JJ,JK)
+ ! bet = b(k) - a(k)* gam(k)
+ PVARP(JI,JJ,JK)= ( ZY(JI,JJ,JK) - ZA(JI,JJ,JK) * PVARP(JI,JJ,JK-KKL) ) / ZBET(JI,JJ)
+ ! res(k) = (y(k) -a(k)*res(k-1))/ bet
END DO
- END DO
- END DO
- ! special treatment for the last level
- DO JJ=1,SIZE(ZGAM,2)
- DO JI=1,SIZE(ZGAM,1)
+ END DO
+ !END DO !CONCURRENT
+END DO
+! special treatment for the last level
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
ZGAM(JI,JJ,IKE) = ZC(JI,JJ,IKE-KKL) / ZBET(JI,JJ)
- ! gam(k) = c(k-1) / bet
+ ! gam(k) = c(k-1) / bet
ZBET(JI,JJ) = ZB(JI,JJ,IKE) - ZA(JI,JJ,IKE) * ZGAM(JI,JJ,IKE)
- ! bet = b(k) - a(k)* gam(k)
+ ! bet = b(k) - a(k)* gam(k)
PVARP(JI,JJ,IKE)= ( ZY(JI,JJ,IKE) - ZA(JI,JJ,IKE) * PVARP(JI,JJ,IKE-KKL) ) / ZBET(JI,JJ)
- ! res(k) = (y(k) -a(k)*res(k-1))/ bet
- END DO
- END DO
+ ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+END DO !CONCURRENT
!
!* 3.3 going down
! ----------
!
- DO JK = IKE-KKL,IKB,-1*KKL
- PVARP(:,:,JK) = PVARP(:,:,JK) - ZGAM(:,:,JK+KKL) * PVARP(:,:,JK+KKL)
- END DO
+DO JK = IKE-KKL,IKB,-1*KKL
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,JK) = PVARP(JI,JJ,JK) - ZGAM(JI,JJ,JK+KKL) * PVARP(JI,JJ,JK+KKL)
+ END DO !CONCURRENT
+END DO
!$acc end kernels
!
ELSE
!
!$acc kernels
- PVARP(:,:,IKTB:IKTE) = ZY(:,:,IKTB:IKTE) * PTSTEP / PRHODJ(:,:,IKTB:IKTE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=IKTB:IKTE)
+ PVARP(JI,JJ,JK) = ZY(JI,JJ,JK) * PTSTEP / PRHODJ(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
!
END IF
@@ -374,8 +420,10 @@ END IF
! ----------------------------------------
!
!$acc kernels
-PVARP(:,:,KKA)=PVARP(:,:,IKB)
-PVARP(:,:,KKU)=PVARP(:,:,IKE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,KKA)=PVARP(JI,JJ,IKB)
+ PVARP(JI,JJ,KKU)=PVARP(JI,JJ,IKE)
+END DO !CONCURRENT
!$acc end kernels
if ( mppdb_initialized ) then
@@ -385,6 +433,14 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate (zrhodj_dfddtdz_o_dz2,zmzm_rhodj,za,zb,zc,zy,zgam,zbet)
+#else
+CALL MNH_REL_ZT3D(IZRHODJ_DFDDTDZ_O_DZ2,IZMZM_RHODJ,IZA,IZB,IZC,IZY,IZGAM,&
+ IZBET,iztmp1_device)
+CALL MNH_CHECK_OUT_ZT3D("TRIDIAG_THERMO")
+#endif
+
!$acc end data
!-------------------------------------------------------------------------------
diff --git a/src/MNH/tridiag_tke.f90 b/src/MNH/tridiag_tke.f90
index 9c9fb5439..ee15d6a7b 100644
--- a/src/MNH/tridiag_tke.f90
+++ b/src/MNH/tridiag_tke.f90
@@ -142,6 +142,11 @@ END MODULE MODI_TRIDIAG_TKE
USE MODD_PARAMETERS
USE MODE_MPPDB
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D , MNH_ALLOCATE_ZT2D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
+#endif
+!
IMPLICIT NONE
!
!
@@ -167,9 +172,11 @@ INTEGER :: JI,JJ,JK ! loop counters
INTEGER :: IKB,IKE ! inner vertical limits
INTEGER :: IKT ! array size in k direction
INTEGER :: IKTB,IKTE ! start, end of k loops in physical domain
-REAL, DIMENSION(:,:,:), allocatable :: ZY ,ZGAM ! RHS of the equation, 3D work array
-REAL, DIMENSION(:,:), allocatable :: ZBET ! 2D work array
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZY ,ZGAM ! RHS of the equation, 3D work array
+REAL, DIMENSION(:,:), pointer , contiguous :: ZBET ! 2D work array
+INTEGER :: IZY ,IZGAM, IZBET
!
+INTEGER :: JIU,JJU,JKU
! ---------------------------------------------------------------------------
!$acc data present( PVARM, PA, PRHODJ, PSOURCE, PDIAG, PVARP )
@@ -183,11 +190,22 @@ if ( mppdb_initialized ) then
call Mppdb_check( pdiag, "Tridiag_tke beg:pdiag" )
end if
-allocate( zy (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zgam(size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zbet(size( pvarm, 1 ), size( pvarm, 2 ) ) )
+JIU = size( pvarm, 1 )
+JJU = size( pvarm, 2 )
+JKU = size( pvarm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zy (JIU,JJU,JKU ) )
+allocate( zgam(JIU,JJU,JKU ) )
+allocate( zbet(JIU,JJU ) )
+#else
+CALL MNH_CHECK_IN_ZT3D("TRIDIAG_TKE")
+izy = MNH_ALLOCATE_ZT3D( zy ,JIU,JJU,JKU )
+izgam = MNH_ALLOCATE_ZT3D( zgam,JIU,JJU,JKU )
+izbet = MNH_ALLOCATE_ZT2D( zbet,JIU,JJU )
+#endif
-!$acc data create( ZY, ZGAM, ZBET )
+!$acc data present( ZY, ZGAM, ZBET )
!
!* 1. COMPUTE THE RIGHT HAND SIDE
@@ -202,20 +220,26 @@ IKE=KKU-JPVEXT_TURB*KKL
!
!
-ZY(:,:,IKB) = PVARM(:,:,IKB) + PTSTEP*PSOURCE(:,:,IKB) - &
- PEXPL / PRHODJ(:,:,IKB) * PA(:,:,IKB+KKL) * (PVARM(:,:,IKB+KKL) - PVARM(:,:,IKB))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZY(JI,JJ,IKB) = PVARM(JI,JJ,IKB) + PTSTEP*PSOURCE(JI,JJ,IKB) - &
+ PEXPL / PRHODJ(JI,JJ,IKB) * PA(JI,JJ,IKB+KKL) * (PVARM(JI,JJ,IKB+KKL) - PVARM(JI,JJ,IKB))
+END DO !CONCURRENT
!
DO JK=IKTB+1,IKTE-1
- ZY(:,:,JK)= PVARM(:,:,JK) + PTSTEP*PSOURCE(:,:,JK) - &
- PEXPL / PRHODJ(:,:,JK) * &
- ( PVARM(:,:,JK-KKL)*PA(:,:,JK) &
- -PVARM(:,:,JK)*(PA(:,:,JK)+PA(:,:,JK+KKL)) &
- +PVARM(:,:,JK+KKL)*PA(:,:,JK+KKL) &
- )
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZY(JI,JJ,JK)= PVARM(JI,JJ,JK) + PTSTEP*PSOURCE(JI,JJ,JK) - &
+ PEXPL / PRHODJ(JI,JJ,JK) * &
+ ( PVARM(JI,JJ,JK-KKL)*PA(JI,JJ,JK) &
+ -PVARM(JI,JJ,JK)*(PA(JI,JJ,JK)+PA(JI,JJ,JK+KKL)) &
+ +PVARM(JI,JJ,JK+KKL)*PA(JI,JJ,JK+KKL) &
+ )
+ END DO !CONCURRENT
END DO
-!
-ZY(:,:,IKE)= PVARM(:,:,IKE) + PTSTEP*PSOURCE(:,:,IKE) + &
- PEXPL / PRHODJ(:,:,IKE) * PA(:,:,IKE) * (PVARM(:,:,IKE)-PVARM(:,:,IKE-KKL))
+!
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZY(JI,JJ,IKE)= PVARM(JI,JJ,IKE) + PTSTEP*PSOURCE(JI,JJ,IKE) + &
+ PEXPL / PRHODJ(JI,JJ,IKE) * PA(JI,JJ,IKE) * (PVARM(JI,JJ,IKE)-PVARM(JI,JJ,IKE-KKL))
+END DO !CONCURRENT
!
!
!* 2. INVERSION OF THE TRIDIAGONAL SYSTEM
@@ -225,15 +249,17 @@ IF ( PIMPL > 1.E-10 ) THEN
!
!
! going up
- !
- ZBET(:,:) = 1. + PIMPL * (PDIAG(:,:,IKB)-PA(:,:,IKB+KKL) / PRHODJ(:,:,IKB))
- ! bet = b(ikb)
- PVARP(:,:,IKB) = ZY(:,:,IKB) / ZBET(:,:)
+ !
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZBET(JI,JJ) = 1. + PIMPL * (PDIAG(JI,JJ,IKB)-PA(JI,JJ,IKB+KKL) / PRHODJ(JI,JJ,IKB))
+ ! bet = b(ikb)
+ PVARP(JI,JJ,IKB) = ZY(JI,JJ,IKB) / ZBET(JI,JJ)
+ END DO !CONCURRENT
!
DO JK = IKB+KKL,IKE-KKL,KKL
!$acc loop collapse(2) independent
- DO JJ=1,SIZE(ZGAM,2)
- DO JI=1,SIZE(ZGAM,1)
+ DO JJ=1,JJU
+ DO JI=1,JIU
ZGAM(JI,JJ,JK) = PIMPL * PA(JI,JJ,JK) / PRHODJ(JI,JJ,JK-KKL) / ZBET(JI,JJ)
! gam(k) = c(k-1) / bet
ZBET(JI,JJ) = 1. + PIMPL * ( PDIAG(JI,JJ,JK) - &
@@ -249,26 +275,32 @@ IF ( PIMPL > 1.E-10 ) THEN
END DO
END DO
! special treatment for the last level
- ZGAM(:,:,IKE) = PIMPL * PA(:,:,IKE) / PRHODJ(:,:,IKE-KKL) / ZBET(:,:)
- ! gam(k) = c(k-1) / bet
- ZBET(:,:) = 1. + PIMPL * ( PDIAG(:,:,IKE) - &
- ( PA(:,:,IKE) * (1. + ZGAM(:,:,IKE)) ) / PRHODJ(:,:,IKE) &
- )
- ! bet = b(k) - a(k)* gam(k)
- PVARP(:,:,IKE)= ( ZY(:,:,IKE) - PIMPL * PA(:,:,IKE) / PRHODJ(:,:,IKE) &
- * PVARP(:,:,IKE-KKL) &
- ) / ZBET(:,:)
- ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZGAM(JI,JJ,IKE) = PIMPL * PA(JI,JJ,IKE) / PRHODJ(JI,JJ,IKE-KKL) / ZBET(JI,JJ)
+ ! gam(k) = c(k-1) / bet
+ ZBET(JI,JJ) = 1. + PIMPL * ( PDIAG(JI,JJ,IKE) - &
+ ( PA(JI,JJ,IKE) * (1. + ZGAM(JI,JJ,IKE)) ) / PRHODJ(JI,JJ,IKE) &
+ )
+ ! bet = b(k) - a(k)* gam(k)
+ PVARP(JI,JJ,IKE)= ( ZY(JI,JJ,IKE) - PIMPL * PA(JI,JJ,IKE) / PRHODJ(JI,JJ,IKE) &
+ * PVARP(JI,JJ,IKE-KKL) &
+ ) / ZBET(JI,JJ)
+ ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+ END DO !CONCURRENT
!
! going down
!
DO JK = IKE-KKL,IKB,-1*KKL
- PVARP(:,:,JK) = PVARP(:,:,JK) - ZGAM(:,:,JK+KKL) * PVARP(:,:,JK+KKL)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,JK) = PVARP(JI,JJ,JK) - ZGAM(JI,JJ,JK+KKL) * PVARP(JI,JJ,JK+KKL)
+ END DO !CONCURRENT
END DO
!
ELSE
-!
- PVARP(:,:,IKTB:IKTE) = ZY(:,:,IKTB:IKTE)
+ !
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,IKTB:IKTE) = ZY(JI,JJ,IKTB:IKTE)
+ END DO !CONCURRENT
!
END IF
!
@@ -276,8 +308,10 @@ END IF
!* 3. FILL THE UPPER AND LOWER EXTERNAL VALUES
! ----------------------------------------
!
-PVARP(:,:,KKA)=PVARP(:,:,IKB)
-PVARP(:,:,KKU)=PVARP(:,:,IKE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,KKA)=PVARP(JI,JJ,IKB)
+ PVARP(JI,JJ,KKU)=PVARP(JI,JJ,IKE)
+END DO !CONCURRENT
!$acc end kernels
if ( mppdb_initialized ) then
@@ -287,6 +321,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( ZY, ZGAM, ZBET )
+#else
+CALL MNH_REL_ZT3D( IZY, IZGAM, IZBET )
+CALL MNH_CHECK_OUT_ZT3D("TRIDIAG_TKE")
+#endif
+
!$acc end data
!-------------------------------------------------------------------------------
diff --git a/src/MNH/tridiag_w.f90 b/src/MNH/tridiag_w.f90
index 74d7775d5..87965f9d0 100644
--- a/src/MNH/tridiag_w.f90
+++ b/src/MNH/tridiag_w.f90
@@ -161,6 +161,10 @@ USE MODI_SHUMAN_DEVICE
USE MODI_BITREP
#endif
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D , MNH_ALLOCATE_ZT2D
+#endif
+!
IMPLICIT NONE
!
!
@@ -177,15 +181,18 @@ REAL, DIMENSION(:,:,:), INTENT(OUT):: PVARP ! variable at t+1 at flux poi
!
!* 0.2 declarations of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZRHODJ_DFDDWDZ_O_DZ2
-REAL, DIMENSION(:,:,:), allocatable :: ZMZM_RHODJ
-REAL, DIMENSION(:,:,:), allocatable :: ZA, ZB, ZC
-REAL, DIMENSION(:,:,:), allocatable :: ZY ,ZGAM ! RHS of the equation, 3D work array
-REAL, DIMENSION(:,:), allocatable :: ZBET ! 2D work array
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZRHODJ_DFDDWDZ_O_DZ2
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZMZM_RHODJ
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZA, ZB, ZC
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZY ,ZGAM ! RHS of the equation, 3D work array
+REAL, DIMENSION(:,:), pointer , contiguous :: ZBET ! 2D work array
+INTEGER :: IZRHODJ_DFDDWDZ_O_DZ2,IZMZM_RHODJ,IZA, IZB, IZC,IZY ,IZGAM,IZBET
!
INTEGER :: JK ! loop counter
INTEGER :: IKB,IKE ! inner vertical limits
!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ
! ---------------------------------------------------------------------------
!$acc data present( PVARM, PF, PDFDDWDZ, PMZF_DZZ, PRHODJ, PVARP )
@@ -199,16 +206,31 @@ if ( mppdb_initialized ) then
call Mppdb_check( prhodj, "Tridiag_w beg:prhodj" )
end if
-allocate( zrhodj_dfddwdz_o_dz2(size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zmzm_rhodj (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( za (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zb (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zc (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zy (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zgam (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zbet (size( pvarm, 1 ), size( pvarm, 2 ) ) )
+JIU = size( pvarm, 1 )
+JJU = size( pvarm, 2 )
+JKU = size( pvarm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zrhodj_dfddwdz_o_dz2(JIU,JJU,JKU ) )
+allocate( zmzm_rhodj (JIU,JJU,JKU ) )
+allocate( za (JIU,JJU,JKU ) )
+allocate( zb (JIU,JJU,JKU ) )
+allocate( zc (JIU,JJU,JKU ) )
+allocate( zy (JIU,JJU,JKU ) )
+allocate( zgam (JIU,JJU,JKU ) )
+allocate( zbet (JIU,JJU ) )
+#else
+izrhodj_dfddwdz_o_dz2 = MNH_ALLOCATE_ZT3D( zrhodj_dfddwdz_o_dz2,JIU,JJU,JKU )
+izmzm_rhodj = MNH_ALLOCATE_ZT3D( zmzm_rhodj ,JIU,JJU,JKU )
+iza = MNH_ALLOCATE_ZT3D( za ,JIU,JJU,JKU )
+izb = MNH_ALLOCATE_ZT3D( zb ,JIU,JJU,JKU )
+izc = MNH_ALLOCATE_ZT3D( zc ,JIU,JJU,JKU )
+izy = MNH_ALLOCATE_ZT3D( zy ,JIU,JJU,JKU )
+izgam = MNH_ALLOCATE_ZT3D( zgam ,JIU,JJU,JKU )
+izbet = MNH_ALLOCATE_ZT2D( zbet ,JIU,JJU )
+#endif
-!$acc data create( ZRHODJ_DFDDWDZ_O_DZ2, ZMZM_RHODJ, ZA, ZB, ZC, ZY, ZGAM, ZBET )
+!$acc data present( ZRHODJ_DFDDWDZ_O_DZ2, ZMZM_RHODJ, ZA, ZB, ZC, ZY, ZGAM, ZBET )
!
!* 1. Preliminaries
@@ -222,22 +244,24 @@ ZMZM_RHODJ = MZM(PRHODJ)
#else
CALL MZM_DEVICE(PRHODJ,ZMZM_RHODJ)
#endif
-!$acc kernels async
+!$acc kernels ! async
#ifndef MNH_BITREP
ZRHODJ_DFDDWDZ_O_DZ2 = PRHODJ*PDFDDWDZ/PMZF_DZZ**2
#else
-ZRHODJ_DFDDWDZ_O_DZ2 = PRHODJ*PDFDDWDZ/BR_P2(PMZF_DZZ)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,JK) = PRHODJ(JI,JJ,JK)*PDFDDWDZ(JI,JJ,JK)/BR_P2(PMZF_DZZ(JI,JJ,JK))
+END DO !CONCURRENT
#endif
!$acc end kernels
!
-!$acc kernels async
+!$acc kernels ! async
ZA=0.
ZB=0.
ZC=0.
ZY=0.
!$acc end kernels
!
-!$acc wait
+! acc wait
!
!
!* 2. COMPUTE THE RIGHT HAND SIDE
@@ -258,31 +282,37 @@ ZY=0.
!! + PRHODJ(k-1) * PDFDDWDZ(k-1) * PVARM(k-1)/BR_P2(PMZF_DZZ(k-1))
!!#endif
!
-!$acc kernels async
-ZY(:,:,IKB) = ZMZM_RHODJ(:,:,IKB)*PVARM(:,:,IKB)/PTSTEP &
- - PRHODJ(:,:,IKB ) * PF(:,:,IKB )/PMZF_DZZ(:,:,IKB ) &
- + PRHODJ(:,:,IKB-1) * PF(:,:,IKB-1)/PMZF_DZZ(:,:,IKB-1) &
- + ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB) * PVARM(:,:,IKB+1)&
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB) * PVARM(:,:,IKB )
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZY(JI,JJ,IKB) = ZMZM_RHODJ(JI,JJ,IKB)*PVARM(JI,JJ,IKB)/PTSTEP &
+ - PRHODJ(JI,JJ,IKB ) * PF(JI,JJ,IKB )/PMZF_DZZ(JI,JJ,IKB ) &
+ + PRHODJ(JI,JJ,IKB-1) * PF(JI,JJ,IKB-1)/PMZF_DZZ(JI,JJ,IKB-1) &
+ + ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB) * PVARM(JI,JJ,IKB+1)&
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB) * PVARM(JI,JJ,IKB )
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
- ZY(:,:,IKB+1:IKE-1) = ZMZM_RHODJ(:,:,IKB+1:IKE-1)*PVARM(:,:,IKB+1:IKE-1)/PTSTEP &
- - PRHODJ(:,:,IKB+1:IKE-1 ) * PF(:,:,IKB+1:IKE-1 )/PMZF_DZZ(:,:,IKB+1:IKE-1 ) &
- + PRHODJ(:,:,IKB:IKE-2) * PF(:,:,IKB:IKE-2)/PMZF_DZZ(:,:,IKB:IKE-2) &
- + ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB+1:IKE-1 ) * PVARM(:,:,IKB+2:IKE) &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB+1:IKE-1 ) * PVARM(:,:,IKB+1:IKE-1 ) &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB:IKE-2) * PVARM(:,:,IKB+1:IKE-1 ) &
- + ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB:IKE-2) * PVARM(:,:,IKB:IKE-2)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZY(JI,JJ,IKB+1:IKE-1) = ZMZM_RHODJ(JI,JJ,IKB+1:IKE-1)*PVARM(JI,JJ,IKB+1:IKE-1)/PTSTEP &
+ - PRHODJ(JI,JJ,IKB+1:IKE-1 ) * PF(JI,JJ,IKB+1:IKE-1 )/PMZF_DZZ(JI,JJ,IKB+1:IKE-1 ) &
+ + PRHODJ(JI,JJ,IKB:IKE-2) * PF(JI,JJ,IKB:IKE-2)/PMZF_DZZ(JI,JJ,IKB:IKE-2) &
+ + ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB+1:IKE-1 ) * PVARM(JI,JJ,IKB+2:IKE) &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB+1:IKE-1 ) * PVARM(JI,JJ,IKB+1:IKE-1 ) &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB:IKE-2) * PVARM(JI,JJ,IKB+1:IKE-1 ) &
+ + ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB:IKE-2) * PVARM(JI,JJ,IKB:IKE-2)
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
-ZY(:,:,IKE) = ZMZM_RHODJ(:,:,IKE)*PVARM(:,:,IKE)/PTSTEP &
- - PRHODJ(:,:,IKE ) * PF(:,:,IKE )/PMZF_DZZ(:,:,IKE ) &
- + PRHODJ(:,:,IKE-1) * PF(:,:,IKE-1)/PMZF_DZZ(:,:,IKE-1) &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKE ) * PVARM(:,:,IKE ) &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKE-1) * PVARM(:,:,IKE ) &
- + ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKE-1) * PVARM(:,:,IKE-1)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZY(JI,JJ,IKE) = ZMZM_RHODJ(JI,JJ,IKE)*PVARM(JI,JJ,IKE)/PTSTEP &
+ - PRHODJ(JI,JJ,IKE ) * PF(JI,JJ,IKE )/PMZF_DZZ(JI,JJ,IKE ) &
+ + PRHODJ(JI,JJ,IKE-1) * PF(JI,JJ,IKE-1)/PMZF_DZZ(JI,JJ,IKE-1) &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKE ) * PVARM(JI,JJ,IKE ) &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKE-1) * PVARM(JI,JJ,IKE ) &
+ + ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKE-1) * PVARM(JI,JJ,IKE-1)
+END DO !CONCURRENT
!$acc end kernels
!
!* 3. INVERSION OF THE TRIDIAGONAL SYSTEM
@@ -298,71 +328,90 @@ ZY(:,:,IKE) = ZMZM_RHODJ(:,:,IKE)*PVARM(:,:,IKE)/PTSTEP &
!! - PRHODJ(k-1) * PDFDDWDZ(k-1)/PMZF_DZZ(k-1)**2
!! c(k) = + PRHODJ(k) * PDFDDWDZ(k)/PMZF_DZZ(k)**2
!
-!$acc kernels async
- ZB(:,:,IKB) = ZMZM_RHODJ(:,:,IKB)/PTSTEP &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZB(JI,JJ,IKB) = ZMZM_RHODJ(JI,JJ,IKB)/PTSTEP &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB)
+END DO !CONCURRENT
!$acc end kernels
-!$acc kernels async
- ZC(:,:,IKB) = ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZC(JI,JJ,IKB) = ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKB)
+END DO !CONCURRENT
!$acc end kernels
-!$acc kernels async
- ZA(:,:,IKB+1:IKE-1) = ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB:IKE-2)
- ZB(:,:,IKB+1:IKE-1) = ZMZM_RHODJ(:,:,IKB+1:IKE-1)/PTSTEP &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB+1:IKE-1 ) &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB:IKE-2)
- ZC(:,:,IKB+1:IKE-1) = ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKB+1:IKE-1 )
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=IKB+1:IKE-1)
+ ZA(JI,JJ,JK) = ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,JK-1)
+ ZB(JI,JJ,JK) = ZMZM_RHODJ(JI,JJ,JK)/PTSTEP &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,JK ) &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,JK-1)
+ ZC(JI,JJ,JK) = ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,JK )
+END DO !CONCURRENT
!$acc end kernels
-!$acc kernels async
- ZA(:,:,IKE) = ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKE-1)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZA(JI,JJ,IKE) = ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKE-1)
+END DO !CONCURRENT
!$acc end kernels
-!$acc kernels async
- ZB(:,:,IKE) = ZMZM_RHODJ(:,:,IKE)/PTSTEP &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKE ) &
- - ZRHODJ_DFDDWDZ_O_DZ2(:,:,IKE-1)
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZB(JI,JJ,IKE) = ZMZM_RHODJ(JI,JJ,IKE)/PTSTEP &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKE ) &
+ - ZRHODJ_DFDDWDZ_O_DZ2(JI,JJ,IKE-1)
+END DO !CONCURRENT
!$acc end kernels
!
!
-!$acc wait
+! acc wait
!
!* 3.2 going up
! --------
!
!$acc kernels
- ZBET(:,:) = ZB(:,:,IKB) ! bet = b(ikb)
- PVARP(:,:,IKB) = ZY(:,:,IKB) / ZBET(:,:)
-
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZBET(JI,JJ) = ZB(JI,JJ,IKB) ! bet = b(ikb)
+ PVARP(JI,JJ,IKB) = ZY(JI,JJ,IKB) / ZBET(JI,JJ)
+END DO !CONCURRENT
!
- DO JK = IKB+1,IKE-1
- ZGAM(:,:,JK) = ZC(:,:,JK-1) / ZBET(:,:)
- ! gam(k) = c(k-1) / bet
- ZBET(:,:) = ZB(:,:,JK) - ZA(:,:,JK) * ZGAM(:,:,JK)
- ! bet = b(k) - a(k)* gam(k)
- PVARP(:,:,JK)= ( ZY(:,:,JK) - ZA(:,:,JK) * PVARP(:,:,JK-1) ) / ZBET(:,:)
- ! res(k) = (y(k) -a(k)*res(k-1))/ bet
- END DO
- ! special treatment for the last level
- ZGAM(:,:,IKE) = ZC(:,:,IKE-1) / ZBET(:,:)
- ! gam(k) = c(k-1) / bet
- ZBET(:,:) = ZB(:,:,IKE) - ZA(:,:,IKE) * ZGAM(:,:,IKE)
- ! bet = b(k) - a(k)* gam(k)
- PVARP(:,:,IKE)= ( ZY(:,:,IKE) - ZA(:,:,IKE) * PVARP(:,:,IKE-1) ) / ZBET(:,:)
- ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+DO JK = IKB+1,IKE-1
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZGAM(JI,JJ,JK) = ZC(JI,JJ,JK-1) / ZBET(JI,JJ)
+ ! gam(k) = c(k-1) / bet
+ ZBET(JI,JJ) = ZB(JI,JJ,JK) - ZA(JI,JJ,JK) * ZGAM(JI,JJ,JK)
+ ! bet = b(k) - a(k)* gam(k)
+ PVARP(JI,JJ,JK)= ( ZY(JI,JJ,JK) - ZA(JI,JJ,JK) * PVARP(JI,JJ,JK-1) ) / ZBET(JI,JJ)
+ ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+ END DO !CONCURRENT
+END DO
+! special treatment for the last level
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZGAM(JI,JJ,IKE) = ZC(JI,JJ,IKE-1) / ZBET(JI,JJ)
+ ! gam(k) = c(k-1) / bet
+ ZBET(JI,JJ) = ZB(JI,JJ,IKE) - ZA(JI,JJ,IKE) * ZGAM(JI,JJ,IKE)
+ ! bet = b(k) - a(k)* gam(k)
+ PVARP(JI,JJ,IKE)= ( ZY(JI,JJ,IKE) - ZA(JI,JJ,IKE) * PVARP(JI,JJ,IKE-1) ) / ZBET(JI,JJ)
+ ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+END DO !CONCURRENT
!
!* 3.3 going down
! ----------
!
- DO JK = IKE-1,IKB,-1
- PVARP(:,:,JK) = PVARP(:,:,JK) - ZGAM(:,:,JK+1) * PVARP(:,:,JK+1)
- END DO
+DO JK = IKE-1,IKB,-1
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,JK) = PVARP(JI,JJ,JK) - ZGAM(JI,JJ,JK+1) * PVARP(JI,JJ,JK+1)
+ END DO !CONCURRENT
+END DO
!
!
!* 4. FILL THE UPPER AND LOWER EXTERNAL VALUES
! ----------------------------------------
!
-PVARP(:,:,IKB-1)=PVARP(:,:,IKB)
-PVARP(:,:,IKE+1)=0.
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,IKB-1)=PVARP(JI,JJ,IKB)
+ PVARP(JI,JJ,IKE+1)=0.
+END DO !CONCURRENT
!$acc end kernels
if ( mppdb_initialized ) then
@@ -372,6 +421,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate (ZRHODJ_DFDDWDZ_O_DZ2, ZMZM_RHODJ, ZA, ZB, ZC, ZY, ZGAM, ZBET)
+#else
+CALL MNH_REL_ZT3D(IZRHODJ_DFDDWDZ_O_DZ2, IZMZM_RHODJ, IZA, IZB, IZC, IZY, IZGAM, IZBET)
+#endif
+
+
!$acc end data
!-------------------------------------------------------------------------------
diff --git a/src/MNH/tridiag_wind.f90 b/src/MNH/tridiag_wind.f90
index b7819835b..e0451c912 100644
--- a/src/MNH/tridiag_wind.f90
+++ b/src/MNH/tridiag_wind.f90
@@ -32,7 +32,6 @@ END INTERFACE
END MODULE MODI_TRIDIAG_WIND
!
!
-!
! #############################################################
SUBROUTINE TRIDIAG_WIND(KKA,KKU,KKL,PVARM,PA,PCOEFS,PTSTEP,PEXPL,PIMPL, &
PRHODJA,PSOURCE,PVARP )
@@ -149,6 +148,11 @@ USE MODD_PARAMETERS
use mode_mppdb
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D , MNH_ALLOCATE_ZT2D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
+#endif
+
IMPLICIT NONE
!
!
@@ -174,8 +178,11 @@ INTEGER :: JI,JJ,JK ! loop counters
INTEGER :: IKB,IKE ! inner vertical limits
INTEGER :: IKT ! array size in k direction
INTEGER :: IKTB,IKTE ! start, end of k loops in physical domain
-REAL, DIMENSION(:,:,:), allocatable :: ZY ,ZGAM ! RHS of the equation, 3D work array
-REAL, DIMENSION(:,:), allocatable :: ZBET ! 2D work array
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZY ,ZGAM ! RHS of the equation, 3D work array
+REAL, DIMENSION(:,:), pointer , contiguous :: ZBET ! 2D work array
+INTEGER :: IZY ,IZGAM, IZBET
+!
+INTEGER :: JIU,JJU,JKU
!
! ---------------------------------------------------------------------------
@@ -190,11 +197,22 @@ if ( mppdb_initialized ) then
call Mppdb_check( psource, "Tridiag_wind beg:psource" )
end if
-allocate( zy (size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zgam(size( pvarm, 1 ), size( pvarm, 2 ), size( pvarm, 3 ) ) )
-allocate( zbet(size( pvarm, 1 ), size( pvarm, 2 ) ) )
+JIU = size( pvarm, 1 )
+JJU = size( pvarm, 2 )
+JKU = size( pvarm, 3 )
-!$acc data create( ZY, ZGAM, ZBET )
+#ifndef MNH_OPENACC
+allocate( zy (JIU,JJU,JKU ) )
+allocate( zgam(JIU,JJU,JKU ) )
+allocate( zbet(JIU,JJU ) )
+#else
+CALL MNH_CHECK_IN_ZT3D("TRIDIAG_WIND")
+izy = MNH_ALLOCATE_ZT3D( zy ,JIU,JJU,JKU )
+izgam = MNH_ALLOCATE_ZT3D( zgam,JIU,JJU,JKU )
+izbet = MNH_ALLOCATE_ZT2D( zbet,JIU,JJU )
+#endif
+
+!$acc data present( ZY, ZGAM, ZBET )
!
!* 1. COMPUTE THE RIGHT HAND SIDE
@@ -208,26 +226,32 @@ IKE=KKU-JPVEXT_TURB*KKL
!
!
-!$acc kernels async
-ZY(:,:,IKB) = PVARM(:,:,IKB) + PTSTEP*PSOURCE(:,:,IKB) - &
- PEXPL / PRHODJA(:,:,IKB) * PA(:,:,IKB+KKL) * (PVARM(:,:,IKB+KKL) - PVARM(:,:,IKB))
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ZY(JI,JJ,IKB) = PVARM(JI,JJ,IKB) + PTSTEP*PSOURCE(JI,JJ,IKB) - &
+ PEXPL / PRHODJA(JI,JJ,IKB) * PA(JI,JJ,IKB+KKL) * (PVARM(JI,JJ,IKB+KKL) - PVARM(JI,JJ,IKB))
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
- ZY(:,:,IKTB+1:IKTE-1)= PVARM(:,:,IKTB+1:IKTE-1) + PTSTEP*PSOURCE(:,:,IKTB+1:IKTE-1) - &
- PEXPL / PRHODJA(:,:,IKTB+1:IKTE-1) * &
- ( PVARM(:,:,IKTB+1-KKL:IKTE-1-KKL)*PA(:,:,IKTB+1:IKTE-1) &
- -PVARM(:,:,IKTB+1:IKTE-1)*(PA(:,:,IKTB+1:IKTE-1)+PA(:,:,IKTB+1+KKL:IKTE-1+KKL)) &
- +PVARM(:,:,IKTB+1+KKL:IKTE-1+KKL)*PA(:,:,IKTB+1+KKL:IKTE-1+KKL) &
- )
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=IKTB+1:IKTE-1)
+ ZY(JI,JJ,JK)= PVARM(JI,JJ,JK) + PTSTEP*PSOURCE(JI,JJ,JK) - &
+ PEXPL / PRHODJA(JI,JJ,JK) * &
+ ( PVARM(JI,JJ,JK-KKL)*PA(JI,JJ,JK) &
+ -PVARM(JI,JJ,JK)*(PA(JI,JJ,JK)+PA(JI,JJ,JK+KKL)) &
+ +PVARM(JI,JJ,JK+KKL)*PA(JI,JJ,JK+KKL) &
+ )
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc kernels async
-ZY(:,:,IKE)= PVARM(:,:,IKE) + PTSTEP*PSOURCE(:,:,IKE) + &
- PEXPL / PRHODJA(:,:,IKE) * PA(:,:,IKE) * (PVARM(:,:,IKE)-PVARM(:,:,IKE-KKL))
+!$acc kernels ! async
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ZY(JI,JJ,IKE)= PVARM(JI,JJ,IKE) + PTSTEP*PSOURCE(JI,JJ,IKE) + &
+ PEXPL / PRHODJA(JI,JJ,IKE) * PA(JI,JJ,IKE) * (PVARM(JI,JJ,IKE)-PVARM(JI,JJ,IKE-KKL))
+END DO !CONCURRENT
!$acc end kernels
!
-!$acc wait
+! acc wait
!
!
!* 2. INVERSION OF THE TRIDIAGONAL SYSTEM
@@ -238,15 +262,17 @@ IF ( PIMPL > 1.E-10 ) THEN
!
! going up
!
-!$acc kernels
- ZBET(:,:) = 1. - PIMPL * ( PA(:,:,IKB+KKL) / PRHODJA(:,:,IKB) &
- + PCOEFS(:,:) * PTSTEP ) ! bet = b(ikb)
- PVARP(:,:,IKB) = ZY(:,:,IKB) / ZBET(:,:)
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZBET(JI,JJ) = 1. - PIMPL * ( PA(JI,JJ,IKB+KKL) / PRHODJA(JI,JJ,IKB) &
+ + PCOEFS(JI,JJ) * PTSTEP ) ! bet = b(ikb)
+ PVARP(JI,JJ,IKB) = ZY(JI,JJ,IKB) / ZBET(JI,JJ)
+ END DO !CONCURRENT
!
- DO JK = IKB+KKL,IKE-KKL,KKL
+ DO JK = IKB+KKL,IKE-KKL,KKL
!$acc loop collapse(2) independent
- DO JJ=1,SIZE(ZGAM,2)
- DO JI=1,SIZE(ZGAM,1)
+ DO JJ=1,JJU
+ DO JI=1,JIU
ZGAM(JI,JJ,JK) = PIMPL * PA(JI,JJ,JK) / PRHODJA(JI,JJ,JK-KKL) / ZBET(JI,JJ)
! gam(k) = c(k-1) / bet
ZBET(JI,JJ) = 1. - PIMPL * ( PA(JI,JJ,JK) * (1. + ZGAM(JI,JJ,JK)) &
@@ -261,27 +287,33 @@ IF ( PIMPL > 1.E-10 ) THEN
END DO
END DO
! special treatment for the last level
- ZGAM(:,:,IKE) = PIMPL * PA(:,:,IKE) / PRHODJA(:,:,IKE-KKL) / ZBET(:,:)
- ! gam(k) = c(k-1) / bet
- ZBET(:,:) = 1. - PIMPL * ( PA(:,:,IKE) * (1. + ZGAM(:,:,IKE)) &
- ) / PRHODJA(:,:,IKE)
- ! bet = b(k) - a(k)* gam(k)
- PVARP(:,:,IKE)= ( ZY(:,:,IKE) - PIMPL * PA(:,:,IKE) / PRHODJA(:,:,IKE) &
- * PVARP(:,:,IKE-KKL) &
- ) / ZBET(:,:)
- ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZGAM(JI,JJ,IKE) = PIMPL * PA(JI,JJ,IKE) / PRHODJA(JI,JJ,IKE-KKL) / ZBET(JI,JJ)
+ ! gam(k) = c(k-1) / bet
+ ZBET(JI,JJ) = 1. - PIMPL * ( PA(JI,JJ,IKE) * (1. + ZGAM(JI,JJ,IKE)) &
+ ) / PRHODJA(JI,JJ,IKE)
+ ! bet = b(k) - a(k)* gam(k)
+ PVARP(JI,JJ,IKE)= ( ZY(JI,JJ,IKE) - PIMPL * PA(JI,JJ,IKE) / PRHODJA(JI,JJ,IKE) &
+ * PVARP(JI,JJ,IKE-KKL) &
+ ) / ZBET(JI,JJ)
+ ! res(k) = (y(k) -a(k)*res(k-1))/ bet
+ END DO !CONCURRENT
!
! going down
!
DO JK = IKE-KKL,IKB,-1*KKL
- PVARP(:,:,JK) = PVARP(:,:,JK) - ZGAM(:,:,JK+KKL) * PVARP(:,:,JK+KKL)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,JK) = PVARP(JI,JJ,JK) - ZGAM(JI,JJ,JK+KKL) * PVARP(JI,JJ,JK+KKL)
+ END DO !CONCURRENT
END DO
!$acc end kernels
!
ELSE
!
-!$acc kernels
- PVARP(:,:,IKTB:IKTE) = ZY(:,:,IKTB:IKTE)
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=IKTB:IKTE)
+ PVARP(JI,JJ,JK) = ZY(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
!
END IF
@@ -291,8 +323,10 @@ END IF
! ----------------------------------------
!
!$acc kernels
-PVARP(:,:,KKA)=PVARP(:,:,IKB)
-PVARP(:,:,KKU)=PVARP(:,:,IKE)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ PVARP(JI,JJ,KKA)=PVARP(JI,JJ,IKB)
+ PVARP(JI,JJ,KKU)=PVARP(JI,JJ,IKE)
+END DO !CONCURRENT
!$acc end kernels
if ( mppdb_initialized ) then
@@ -302,6 +336,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate ( zy,zgam,zbet )
+#else
+CALL MNH_REL_ZT3D( izy,izgam,izbet )
+CALL MNH_CHECK_OUT_ZT3D("TRIDIAG_WIND")
+#endif
+
!$acc end data
!-------------------------------------------------------------------------------
diff --git a/src/MNH/turb.f90 b/src/MNH/turb.f90
index 1eb7127f6..4e9ca2df0 100644
--- a/src/MNH/turb.f90
+++ b/src/MNH/turb.f90
@@ -8,7 +8,10 @@ module mode_turb
!###############
#ifdef MNH_OPENACC
-use mode_msg
+ use mode_msg
+ USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D, &
+ MNH_ALLOCATE_ZT4D , MNH_REL_ZT4D , &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
#endif
#ifdef MNH_BITREP
@@ -389,7 +392,7 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PLEM ! Mixing length
!
! 0.2 declaration of local variables
!
-REAL, ALLOCATABLE, DIMENSION(:,:,:) ::&
+REAL, POINTER , CONTIGUOUS, DIMENSION(:,:,:) ::&
ZCP, & ! Cp at t-1
ZEXN, & ! EXN at t-1
ZT, & ! T at t-1
@@ -402,10 +405,13 @@ REAL, ALLOCATABLE, DIMENSION(:,:,:) ::&
ZMWTH,ZMWR,ZMTH2,ZMR2,ZMTHR,& ! 3rd order moments
ZFWTH,ZFWR,ZFTH2,ZFR2,ZFTHR,& ! opposite of verticale derivate of 3rd order moments
ZTHLM ! initial potential temp.
+INTEGER :: IZCP,IZEXN,IZT,IZLOCPEXNM,IZLEPS,IZTRH,IZATHETA,IZAMOIST &
+ ,IZCOEF_DISS,IZFRAC_ICE,IZMWTH,IZMWR,IZMTH2,IZMR2,IZMTHR &
+ ,IZFWTH,IZFWR,IZFTH2,IZFR2,IZFTHR,IZTHLM
!
-REAL, ALLOCATABLE, DIMENSION(:,:,:,:) :: &
+REAL, POINTER , CONTIGUOUS, DIMENSION(:,:,:,:) :: &
ZRM ! initial mixing ratio
-REAL, ALLOCATABLE, DIMENSION(:,:) :: ZTAU11M,ZTAU12M, &
+REAL, POINTER , CONTIGUOUS, DIMENSION(:,:) :: ZTAU11M,ZTAU12M, &
ZTAU22M,ZTAU33M, &
! tangential surface fluxes in the axes following the orography
ZUSLOPE,ZVSLOPE, &
@@ -420,9 +426,12 @@ REAL, ALLOCATABLE, DIMENSION(:,:) :: ZTAU11M,ZTAU12M, &
!
! Virtual Potential Temp. used
! in the Deardorff mixing length computation
-REAL, DIMENSION(:,:,:), ALLOCATABLE :: &
+INTEGER :: IZRM,IZTAU11M,IZTAU12M,IZTAU22M,IZTAU33M,IZUSLOPE,IZVSLOPE &
+ ,IZCDUEFF,IZUSTAR,IZLMO,IZRVM,IZSFRV
+REAL, DIMENSION(:,:,:), POINTER , CONTIGUOUS :: &
ZLVOCPEXNM,ZLSOCPEXNM, & ! Lv/Cp/EXNREF and Ls/Cp/EXNREF at t-1
ZATHETA_ICE,ZAMOIST_ICE ! coefficients for s = f (Thetal,Rnp)
+INTEGER :: IZLVOCPEXNM,IZLSOCPEXNM,IZATHETA_ICE,IZAMOIST_ICE
!
REAL :: ZEXPL ! 1-PIMPL deg of expl.
REAL :: ZRVORD ! RV/RD
@@ -438,14 +447,19 @@ REAL :: ZALPHA ! proportionnality constant between Dz/2 and
! ! BL89 mixing length near the surface
!
REAL :: ZTIME1, ZTIME2
-REAL, DIMENSION(:,:,:), allocatable :: ZTT,ZEXNE,ZLV,ZCPH
-REAL, DIMENSION(:,:,:), allocatable :: ZSHEAR, ZDUDZ, ZDVDZ
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTT,ZEXNE,ZLV,ZCPH
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZSHEAR, ZDUDZ, ZDVDZ
+INTEGER :: IZTT,IZEXNE,IZLV,IZCPH,IZSHEAR, IZDUDZ, IZDVDZ
TYPE(TFIELDDATA) :: TZFIELD
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE
+INTEGER :: IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE
#endif
!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JLU_ZRM, JLU_TURB, JJU_ORMC01, JKU_CLOUD, JKU_TURB
+!
!------------------------------------------------------------------------------------------
!
! IN variables
@@ -512,70 +526,144 @@ if ( mppdb_initialized ) then
call Mppdb_check( prsvs, "Turb beg:prsvs" )
end if
-ALLOCATE (ZCP (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZEXN (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZT (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZLOCPEXNM (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZLEPS (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZTRH (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZATHETA (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZAMOIST (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZCOEF_DISS(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZFRAC_ICE (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-
-ALLOCATE (ZMWTH (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZMWR (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZMTH2 (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZMR2 (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZMTHR (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-
-ALLOCATE (ZFWTH (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZFWR (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZFTH2 (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZFR2 (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZFTHR (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-ALLOCATE (ZTHLM (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-
-IF ( HTURBLEN == 'BL89' .OR. HTURBLEN == 'RM17' .OR. ORMC01 ) &
- ALLOCATE ( ZRM(SIZE(PRT,1),SIZE(PRT,2),SIZE(PRT,3),SIZE(PRT,4)) )
-
-ALLOCATE ( ZTAU11M(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZTAU12M(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZTAU22M(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZTAU33M(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZUSLOPE(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZVSLOPE(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZCDUEFF(SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-ALLOCATE ( ZLMO (SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-IF (ORMC01) then
- ALLOCATE ( ZUSTAR (SIZE(PTHLT,1),SIZE(PTHLT,2)) )
- ALLOCATE ( ZRVM (SIZE(PTHLT,1),SIZE(PTHLT,2)) )
- ALLOCATE ( ZSFRV (SIZE(PTHLT,1),SIZE(PTHLT,2)) )
-end if
+JIU = size(pthlt, 1 )
+JJU = size(pthlt, 2 )
+JKU = size(pthlt, 3 )
-IF ( HCLOUD == 'KHKO' .OR. HCLOUD == 'C2R2' ) then
- allocate( ztt (size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
- allocate( zexne (size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
- allocate( zlv (size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
- allocate( zcph (size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
-end if
-IF ( HTURBLEN == 'BL89' .OR. HTURBLEN == 'RM17' ) then
- allocate( zshear(size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
-end if
-IF ( HTURBLEN == 'RM17' ) then
- allocate( zdudz (size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
- allocate( zdvdz (size( put, 1 ), size( put, 2 ), size( put, 3 ) ) )
-end if
+#ifndef MNH_OPENACC
+ALLOCATE (ZCP (JIU,JJU,JKU) )
+ALLOCATE (ZEXN (JIU,JJU,JKU) )
+ALLOCATE (ZT (JIU,JJU,JKU) )
+ALLOCATE (ZLOCPEXNM (JIU,JJU,JKU) )
+ALLOCATE (ZLEPS (JIU,JJU,JKU) )
+ALLOCATE (ZTRH (JIU,JJU,JKU) )
+ALLOCATE (ZATHETA (JIU,JJU,JKU) )
+ALLOCATE (ZAMOIST (JIU,JJU,JKU) )
+ALLOCATE (ZCOEF_DISS(JIU,JJU,JKU) )
+ALLOCATE (ZFRAC_ICE (JIU,JJU,JKU) )
+
+ALLOCATE (ZMWTH (JIU,JJU,JKU) )
+ALLOCATE (ZMWR (JIU,JJU,JKU) )
+ALLOCATE (ZMTH2 (JIU,JJU,JKU) )
+ALLOCATE (ZMR2 (JIU,JJU,JKU) )
+ALLOCATE (ZMTHR (JIU,JJU,JKU) )
+
+ALLOCATE (ZFWTH (JIU,JJU,JKU) )
+ALLOCATE (ZFWR (JIU,JJU,JKU) )
+ALLOCATE (ZFTH2 (JIU,JJU,JKU) )
+ALLOCATE (ZFR2 (JIU,JJU,JKU) )
+ALLOCATE (ZFTHR (JIU,JJU,JKU) )
+ALLOCATE (ZTHLM (JIU,JJU,JKU) )
+
+JLU_TURB = 0
+IF ( HTURBLEN == 'BL89' .OR. HTURBLEN == 'RM17' .OR. ORMC01 ) JLU_TURB = SIZE(PRT,4)
+ALLOCATE ( ZRM(JIU,JJU,JKU, JLU_TURB ) )
+
+ALLOCATE ( ZTAU11M(JIU,JJU) )
+ALLOCATE ( ZTAU12M(JIU,JJU) )
+ALLOCATE ( ZTAU22M(JIU,JJU) )
+ALLOCATE ( ZTAU33M(JIU,JJU) )
+ALLOCATE ( ZUSLOPE(JIU,JJU) )
+ALLOCATE ( ZVSLOPE(JIU,JJU) )
+ALLOCATE ( ZCDUEFF(JIU,JJU) )
+ALLOCATE ( ZLMO (JIU,JJU) )
+
+JJU_ORMC01 = 0
+IF (ORMC01) JJU_ORMC01 = SIZE(PTHLT,2)
+ALLOCATE ( ZUSTAR (JIU,JJU_ORMC01) )
+ALLOCATE ( ZRVM (JIU,JJU_ORMC01) )
+ALLOCATE ( ZSFRV (JIU,JJU_ORMC01) )
+
+JKU_CLOUD = 0
+IF ( HCLOUD == 'KHKO' .OR. HCLOUD == 'C2R2' ) JKU_CLOUD = size( put, 3 )
+allocate( ztt (JIU,JJU, JKU_CLOUD ) )
+allocate( zexne (JIU,JJU, JKU_CLOUD ) )
+allocate( zlv (JIU,JJU, JKU_CLOUD ) )
+allocate( zcph (JIU,JJU, JKU_CLOUD ) )
+
+JKU_TURB = 0
+IF ( HTURBLEN == 'BL89' .OR. HTURBLEN == 'RM17' ) JKU_TURB = size( put, 3 )
+allocate( zshear(JIU,JJU, JKU_TURB ) )
+
+JKU_TURB = 0
+IF ( HTURBLEN == 'RM17' ) JKU_TURB = size( put, 3 )
+allocate( zdudz (JIU,JJU, JKU_TURB ) )
+allocate( zdvdz (JIU,JJU, JKU_TURB ) )
+
+#else
+CALL MNH_CHECK_IN_ZT3D("TURB")
+IZCP = MNH_ALLOCATE_ZT3D (ZCP ,JIU,JJU,JKU )
+IZEXN = MNH_ALLOCATE_ZT3D (ZEXN ,JIU,JJU,JKU )
+IZT = MNH_ALLOCATE_ZT3D (ZT ,JIU,JJU,JKU )
+IZLOCPEXNM = MNH_ALLOCATE_ZT3D (ZLOCPEXNM ,JIU,JJU,JKU )
+IZLEPS = MNH_ALLOCATE_ZT3D (ZLEPS ,JIU,JJU,JKU )
+IZTRH = MNH_ALLOCATE_ZT3D (ZTRH ,JIU,JJU,JKU )
+IZATHETA = MNH_ALLOCATE_ZT3D (ZATHETA ,JIU,JJU,JKU )
+IZAMOIST = MNH_ALLOCATE_ZT3D (ZAMOIST ,JIU,JJU,JKU )
+IZCOEF_DISS = MNH_ALLOCATE_ZT3D (ZCOEF_DISS,JIU,JJU,JKU )
+IZFRAC_ICE = MNH_ALLOCATE_ZT3D (ZFRAC_ICE ,JIU,JJU,JKU )
+
+IZMWTH = MNH_ALLOCATE_ZT3D (ZMWTH ,JIU,JJU,JKU )
+IZMWR = MNH_ALLOCATE_ZT3D (ZMWR ,JIU,JJU,JKU )
+IZMTH2 = MNH_ALLOCATE_ZT3D (ZMTH2 ,JIU,JJU,JKU )
+IZMR2 = MNH_ALLOCATE_ZT3D (ZMR2 ,JIU,JJU,JKU )
+IZMTHR = MNH_ALLOCATE_ZT3D (ZMTHR ,JIU,JJU,JKU )
+
+IZFWTH = MNH_ALLOCATE_ZT3D (ZFWTH ,JIU,JJU,JKU )
+IZFWR = MNH_ALLOCATE_ZT3D (ZFWR ,JIU,JJU,JKU )
+IZFTH2 = MNH_ALLOCATE_ZT3D (ZFTH2 ,JIU,JJU,JKU )
+IZFR2 = MNH_ALLOCATE_ZT3D (ZFR2 ,JIU,JJU,JKU )
+IZFTHR = MNH_ALLOCATE_ZT3D (ZFTHR ,JIU,JJU,JKU )
+IZTHLM = MNH_ALLOCATE_ZT3D (ZTHLM ,JIU,JJU,JKU )
+
+JLU_ZRM = 0
+IF ( HTURBLEN == 'BL89' .OR. HTURBLEN == 'RM17' .OR. ORMC01 ) JLU_ZRM = SIZE(PRT,4)
+IZRM = MNH_ALLOCATE_ZT4D ( ZRM,JIU,JJU,JKU, JLU_ZRM )
+
+IZTAU11M = MNH_ALLOCATE_ZT2D ( ZTAU11M,JIU,JJU )
+IZTAU12M = MNH_ALLOCATE_ZT2D ( ZTAU12M,JIU,JJU )
+IZTAU22M = MNH_ALLOCATE_ZT2D ( ZTAU22M,JIU,JJU )
+IZTAU33M = MNH_ALLOCATE_ZT2D ( ZTAU33M,JIU,JJU )
+IZUSLOPE = MNH_ALLOCATE_ZT2D ( ZUSLOPE,JIU,JJU )
+IZVSLOPE = MNH_ALLOCATE_ZT2D ( ZVSLOPE,JIU,JJU )
+IZCDUEFF = MNH_ALLOCATE_ZT2D ( ZCDUEFF,JIU,JJU )
+IZLMO = MNH_ALLOCATE_ZT2D ( ZLMO ,JIU,JJU )
+
+JJU_ORMC01 = 0
+IF (ORMC01) JJU_ORMC01 = SIZE(PTHLT,2)
+IZUSTAR = MNH_ALLOCATE_ZT2D ( ZUSTAR ,JIU,JJU_ORMC01 )
+IZRVM = MNH_ALLOCATE_ZT2D ( ZRVM ,JIU,JJU_ORMC01 )
+IZSFRV = MNH_ALLOCATE_ZT2D ( ZSFRV ,JIU,JJU_ORMC01 )
+
+JKU_CLOUD = 0
+IF ( HCLOUD == 'KHKO' .OR. HCLOUD == 'C2R2' ) JKU_CLOUD = size( put, 3 )
+iztt = MNH_ALLOCATE_ZT3D( ztt ,JIU,JJU,JKU_CLOUD )
+izexne = MNH_ALLOCATE_ZT3D( zexne ,JIU,JJU,JKU_CLOUD )
+izlv = MNH_ALLOCATE_ZT3D( zlv ,JIU,JJU,JKU_CLOUD )
+izcph = MNH_ALLOCATE_ZT3D( zcph ,JIU,JJU,JKU_CLOUD )
+
+JKU_TURB = 0
+IF ( HTURBLEN == 'BL89' .OR. HTURBLEN == 'RM17' ) JKU_TURB = size( put, 3 )
+izshear = MNH_ALLOCATE_ZT3D( zshear,JIU,JJU, JKU_TURB )
+
+JKU_TURB = 0
+IF ( HTURBLEN == 'RM17' ) JKU_TURB = size( put, 3 )
+izdudz = MNH_ALLOCATE_ZT3D( zdudz ,JIU,JJU, JKU_TURB )
+izdvdz = MNH_ALLOCATE_ZT3D( zdvdz ,JIU,JJU, JKU_TURB )
+
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlt, 1 ), size( pthlt, 2 ), size( pthlt, 3 ) ) )
-IF (HTURBDIM=="1DIM") then
- allocate( ztmp2_device(size( pthlt, 1 ), size( pthlt, 2 ), size( pthlt, 3 ) ) )
- allocate( ztmp3_device(size( pthlt, 1 ), size( pthlt, 2 ), size( pthlt, 3 ) ) )
-end if
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+
+JKU_TURB = 0
+IF (HTURBDIM=="1DIM") JKU_TURB = size( pthlt, 3 )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU, JKU_TURB )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU, JKU_TURB )
+
#endif
-!$acc data create( zcp, zexn, zt, zlocpexnm, zleps, ztrh, &
+!$acc data present( zcp, zexn, zt, zlocpexnm, zleps, ztrh, &
!$acc & zatheta, zamoist, zcoef_diss, zfrac_ice, &
!$acc & zmwth, zmwr, zmth2, zmr2, zmthr, &
!$acc & zfwth, zfwr, zfth2, zfr2, zfthr, zthlm, &
@@ -664,10 +752,10 @@ IF (KRRL >=1) THEN
!* 2.5 Lv/Cph/Exn
!
IF ( KRRI >= 1 ) THEN
- ALLOCATE(ZLVOCPEXNM(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)))
- ALLOCATE(ZLSOCPEXNM(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)))
- ALLOCATE(ZAMOIST_ICE(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)))
- ALLOCATE(ZATHETA_ICE(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)))
+ ALLOCATE(ZLVOCPEXNM(JIU,JJU,JKU))
+ ALLOCATE(ZLSOCPEXNM(JIU,JJU,JKU))
+ ALLOCATE(ZAMOIST_ICE(JIU,JJU,JKU))
+ ALLOCATE(ZATHETA_ICE(JIU,JJU,JKU))
!$acc enter data create( zlvocpexnm, zlsocpexnm )
!$acc data create( zamoist_ice, zatheta_ice )
@@ -1426,6 +1514,36 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( zcp, zexn, zt, zlocpexnm, zleps, ztrh, &
+ zatheta, zamoist, zcoef_diss, zfrac_ice, &
+ zmwth, zmwr, zmth2, zmr2, zmthr, &
+ zfwth, zfwr, zfth2, zfr2, zfthr, zthlm, &
+ zrm, &
+ ztau11m, ztau12m, ztau22m, ztau33m, &
+ zuslope, zvslope, zcdueff, zlmo, &
+ zustar, zrvm, zsfrv, &
+ ztt, zexne, zlv, zcph, zshear, zdudz, zdvdz )
+#else
+
+CALL MNH_REL_ZT3D ( iztt, izexne, izlv, izcph, izshear, izdudz, izdvdz, &
+ iztmp1_device, iztmp2_device, iztmp3_device )
+
+CALL MNH_REL_ZT3D ( iztau11m, iztau12m, iztau22m, iztau33m, &
+ izuslope, izvslope, izcdueff, izlmo, &
+ izustar, izrvm, izsfrv )
+
+CALL MNH_REL_ZT3D ( izrm)
+
+CALL MNH_REL_ZT3D ( izmwth, izmwr, izmth2, izmr2, izmthr, &
+ izfwth, izfwr, izfth2, izfr2, izfthr, izthlm )
+
+CALL MNH_REL_ZT3D ( izcp, izexn, izt, izlocpexnm, izleps, iztrh, &
+ izatheta, izamoist, izcoef_diss, izfrac_ice )
+
+CALL MNH_CHECK_OUT_ZT3D("TURB")
+#endif
+
!$acc end data
!----------------------------------------------------------------------------
@@ -1567,8 +1685,8 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PAMOIST,PATHETA
!* 0.2 Declarations of local variables
!
REAL :: ZEPS ! XMV / XMD
-real, dimension(:,:,:), allocatable :: zrvsat
-real, dimension(:,:,:), allocatable :: zdrvsatdt
+real, dimension(:,:,:), pointer , contiguous :: zrvsat
+real, dimension(:,:,:), pointer , contiguous :: zdrvsatdt
!
!-------------------------------------------------------------------------------
@@ -1710,10 +1828,10 @@ IMPLICIT NONE
REAL :: ZPENTE ! Slope of the amplification straight line
REAL :: ZCOEF_AMPL_CEI_NUL! Ordonnate at the origin of the
! amplification straight line
-real, dimension(:,:,:), allocatable :: zcoef_ampl
+real, dimension(:,:,:), pointer , contiguous :: zcoef_ampl
! Amplification coefficient of the mixing length
! when the instability criterium is verified
-real, dimension(:,:,:), allocatable :: zlm_cloud
+real, dimension(:,:,:), pointer , contiguous :: zlm_cloud
! Turbulent mixing length in the clouds
!
!-------------------------------------------------------------------------------
@@ -1902,7 +2020,7 @@ REAL :: ZALPHA ! proportionnality constant between Dz/2 and
! ! BL89 mixing length near the surface
REAL :: ZD ! distance to the surface
#ifdef MNH_OPENACC
-real, dimension(:,:,:), allocatable :: ztmp1_device, ztmp2_device
+real, dimension(:,:,:), pointer , contiguous :: ztmp1_device, ztmp2_device
#endif
!
!-------------------------------------------------------------------------------
@@ -2080,16 +2198,17 @@ REAL :: ZALPHA ! proportionnality constant between Dz/2 and
! ! BL89 mixing length near the surface
REAL :: ZD ! distance to the surface
REAL :: ZVAR ! Intermediary variable
-REAL, DIMENSION(:,:), ALLOCATABLE :: ZWORK2D
+REAL, DIMENSION(:,:), POINTER , CONTIGUOUS :: ZWORK2D
!
-REAL, DIMENSION(:,:,:), ALLOCATABLE :: &
+REAL, DIMENSION(:,:,:), POINTER , CONTIGUOUS :: &
ZDTHLDZ,ZDRTDZ, &!dtheta_l/dz, drt_dz used for computing the stablity
! ! criterion
ZETHETA,ZEMOIST !coef ETHETA and EMOIST
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZTMP1_DEVICE,ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), POINTER , CONTIGUOUS :: ZTMP1_DEVICE,ZTMP2_DEVICE
#endif
+INTEGER :: JIU,JJU,JKU
!----------------------------------------------------------------------------
!$acc data present( PDXX, PDYY, PDZZ, PZZ, PDIRCOSZW, PTHLT, PTHVREF, PTKET, PSRCT, PRT, PLOCPEXNM, PATHETA, PAMOIST, PLM )
@@ -2111,15 +2230,19 @@ if ( mppdb_initialized ) then
call Mppdb_check( pamoist, "Dear beg:pamoist" )
end if
+JIU = size(pthlt, 1 )
+JJU = size(pthlt, 2 )
+JKU = size(pthlt, 3 )
+
!-------------------------------------------------------------------------------
allocate( ZWORK2D(SIZE(PLM,1),SIZE(PLM,2)) )
-allocate( ZDTHLDZ(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-allocate( ZDRTDZ (SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-allocate( ZETHETA(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-allocate( ZEMOIST(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
+allocate( ZDTHLDZ(JIU,JJU,JKU) )
+allocate( ZDRTDZ (JIU,JJU,JKU) )
+allocate( ZETHETA(JIU,JJU,JKU) )
+allocate( ZEMOIST(JIU,JJU,JKU) )
#ifdef MNH_OPENACC
-allocate( ZTMP1_DEVICE(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
-allocate( ZTMP2_DEVICE(SIZE(PTHLT,1),SIZE(PTHLT,2),SIZE(PTHLT,3)) )
+allocate( ZTMP1_DEVICE(JIU,JJU,JKU) )
+allocate( ZTMP2_DEVICE(JIU,JJU,JKU) )
#endif
!$acc data create( zwork2d, zdthldz, zdrtdz, zetheta, zemoist, &
diff --git a/src/MNH/turb_hor_dyn_corr.f90 b/src/MNH/turb_hor_dyn_corr.f90
index 3fc86172e..7e4e378b7 100644
--- a/src/MNH/turb_hor_dyn_corr.f90
+++ b/src/MNH/turb_hor_dyn_corr.f90
@@ -173,6 +173,9 @@ USE MODE_MPPDB
#ifdef MNH_BITREP
USE MODI_BITREP
#endif
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
!
IMPLICIT NONE
!
@@ -229,9 +232,10 @@ REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PDP,PTP ! TKE production terms
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX,ZWORK ! work arrays, PK is the turb. mixing coef.
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX,ZWORK ! work arrays, PK is the turb. mixing coef.
!
-REAL, DIMENSION(:,:), allocatable ::ZDIRSINZW
+REAL, DIMENSION(:,:), pointer , contiguous :: ZDIRSINZW
+INTEGER :: IZFLX,IZWORK,IZDIRSINZW
! sinus of the angle between the vertical and the normal to the orography
INTEGER :: IKB,IKE
! Index values for the Beginning and End
@@ -239,20 +243,23 @@ INTEGER :: IKB,IKE
INTEGER :: IKU
INTEGER :: JSV ! scalar loop counter
!
-REAL, DIMENSION(:,:,:), allocatable :: GX_U_M_PUM
-REAL, DIMENSION(:,:,:), allocatable :: GY_V_M_PVM
-REAL, DIMENSION(:,:,:), allocatable :: GZ_W_M_PWM
-REAL, DIMENSION(:,:,:), allocatable :: GZ_W_M_ZWP
-REAL, DIMENSION(:,:,:), allocatable :: ZMZF_DZZ ! MZF(PDZZ)
-REAL, DIMENSION(:,:,:), allocatable :: ZDFDDWDZ ! formal derivative of the
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GX_U_M_PUM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GY_V_M_PVM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GZ_W_M_PWM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GZ_W_M_ZWP
+INTEGER :: IGX_U_M_PUM,IGY_V_M_PVM,IGZ_W_M_PWM,IGZ_W_M_ZWP
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZMZF_DZZ ! MZF(PDZZ)
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZDFDDWDZ ! formal derivative of the
! ! flux (variable: dW/dz)
-REAL, DIMENSION(:,:,:), allocatable :: ZWP ! W at future time-step
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZWP ! W at future time-step
!
-REAL, DIMENSION(:,:,:), allocatable :: ZDU_DZ_DZS_DX ! du/dz*dzs/dx surf
-REAL, DIMENSION(:,:,:), allocatable :: ZDV_DZ_DZS_DY ! dv/dz*dzs/dy surf
-REAL, DIMENSION(:,:,:), allocatable :: ZDU_DX ! du/dx surf
-REAL, DIMENSION(:,:,:), allocatable :: ZDV_DY ! dv/dy surf
-REAL, DIMENSION(:,:,:), allocatable :: ZDW_DZ ! dw/dz surf
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZDU_DZ_DZS_DX ! du/dz*dzs/dx surf
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZDV_DZ_DZS_DY ! dv/dz*dzs/dy surf
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZDU_DX ! du/dx surf
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZDV_DY ! dv/dy surf
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZDW_DZ ! dw/dz surf
+INTEGER :: IZMZF_DZZ,IZDFDDWDZ,IZWP,IZDU_DZ_DZS_DX,IZDV_DZ_DZS_DY &
+ ,IZDU_DX,IZDV_DY,IZDW_DZ
!
INTEGER :: IINFO_ll ! return code of parallel routine
TYPE(LIST_ll), POINTER :: TZFIELDS_ll ! list of fields to exchange
@@ -260,14 +267,19 @@ TYPE(LIST_ll), POINTER :: TZFIELDS_ll ! list of fields to exchange
REAL :: ZTIME1, ZTIME2
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFF , ZDZZ
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFF , ZDZZ
! coefficients for the uncentred gradient
! computation near the ground
+INTEGER :: IZCOEFF , IZDZZ
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! --------------------------------------------------------------------------
!$acc data present( PK, PINV_PDZZ, PDXX, PDYY, PDZZ, PDZX, PDZY, PZZ, PDIRCOSZW, &
@@ -313,36 +325,64 @@ if ( mppdb_initialized ) then
call Mppdb_check( ptp, "Turb_hor_dyn_corr beg:ptp" )
end if
-allocate( zflx (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( zwork(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
+JIU = size(pum, 1 )
+JJU = size(pum, 2 )
+JKU = size(pum, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU ) )
+allocate( zwork(JIU,JJU,JKU ) )
-allocate( zdirsinzw(size( pum, 1 ), size( pum, 2 ) ) )
+allocate( zdirsinzw(JIU,JJU ) )
+
+allocate( gx_u_m_pum(JIU,JJU,JKU ) )
+allocate( gy_v_m_pvm(JIU,JJU,JKU ) )
+allocate( gz_w_m_pwm(JIU,JJU,JKU ) )
+allocate( gz_w_m_zwp(JIU,JJU,JKU ) )
+allocate( zmzf_dzz (JIU,JJU,JKU ) )
+allocate( zdfddwdz (JIU,JJU,JKU ) )
+allocate( zwp (JIU,JJU,JKU ) )
+
+allocate( zdu_dz_dzs_dx(JIU,JJU, 1 ) )
+allocate( zdv_dz_dzs_dy(JIU,JJU, 1 ) )
+allocate( zdu_dx (JIU,JJU, 1 ) )
+allocate( zdv_dy (JIU,JJU, 1 ) )
+allocate( zdw_dz (JIU,JJU, 1 ) )
+
+allocate( zcoeff(JIU,JJU, 1 + jpvext : 3 + jpvext ) )
+allocate( zdzz (JIU,JJU, 1 + jpvext : 3 + jpvext ) )
+#else
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU )
+izwork = MNH_ALLOCATE_ZT3D( zwork,JIU,JJU,JKU )
-allocate( gx_u_m_pum(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( gy_v_m_pvm(size( pvm, 1 ), size( pvm, 2 ), size( pvm, 3 ) ) )
-allocate( gz_w_m_pwm(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( gz_w_m_zwp(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( zmzf_dzz (size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( zdfddwdz (size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( zwp (size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+izdirsinzw = MNH_ALLOCATE_ZT2D( zdirsinzw,JIU,JJU )
-allocate( zdu_dz_dzs_dx(size( pwm, 1 ), size( pwm, 2 ), 1 ) )
-allocate( zdv_dz_dzs_dy(size( pwm, 1 ), size( pwm, 2 ), 1 ) )
-allocate( zdu_dx (size( pwm, 1 ), size( pwm, 2 ), 1 ) )
-allocate( zdv_dy (size( pwm, 1 ), size( pwm, 2 ), 1 ) )
-allocate( zdw_dz (size( pwm, 1 ), size( pwm, 2 ), 1 ) )
+igx_u_m_pum = MNH_ALLOCATE_ZT3D( gx_u_m_pum,JIU,JJU,JKU )
+igy_v_m_pvm = MNH_ALLOCATE_ZT3D( gy_v_m_pvm,JIU,JJU,JKU )
+igz_w_m_pwm = MNH_ALLOCATE_ZT3D( gz_w_m_pwm,JIU,JJU,JKU )
+igz_w_m_zwp = MNH_ALLOCATE_ZT3D( gz_w_m_zwp,JIU,JJU,JKU )
+izmzf_dzz = MNH_ALLOCATE_ZT3D( zmzf_dzz ,JIU,JJU,JKU )
+izdfddwdz = MNH_ALLOCATE_ZT3D( zdfddwdz ,JIU,JJU,JKU )
+izwp = MNH_ALLOCATE_ZT3D( zwp ,JIU,JJU,JKU )
-allocate( zcoeff(size( pdzz, 1 ), size( pdzz, 2 ), 1 + jpvext : 3 + jpvext ) )
-allocate( zdzz (size( pdzz, 1 ), size( pdzz, 2 ), 1 + jpvext : 3 + jpvext ) )
+izdu_dz_dzs_dx = MNH_ALLOCATE_ZT3DP( zdu_dz_dzs_dx,JIU,JJU, 1 , 1 )
+izdv_dz_dzs_dy = MNH_ALLOCATE_ZT3DP( zdv_dz_dzs_dy,JIU,JJU, 1 , 1 )
+izdu_dx = MNH_ALLOCATE_ZT3DP( zdu_dx ,JIU,JJU, 1 , 1 )
+izdv_dy = MNH_ALLOCATE_ZT3DP( zdv_dy ,JIU,JJU, 1 , 1 )
+izdw_dz = MNH_ALLOCATE_ZT3DP( zdw_dz ,JIU,JJU, 1 , 1 )
+
+izcoeff = MNH_ALLOCATE_ZT3DP( zcoeff,JIU,JJU, 1 + jpvext , 3 + jpvext )
+izdzz = MNH_ALLOCATE_ZT3DP( zdzz ,JIU,JJU, 1 + jpvext , 3 + jpvext )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
#endif
-!$acc data create( ZFLX, ZWORK, ZDIRSINZW, ZCOEFF, ZDZZ, &
+!$acc data present(ZFLX, ZWORK, ZDIRSINZW, ZCOEFF, ZDZZ, &
!$acc & GX_U_M_PUM, GY_V_M_PVM, GZ_W_M_PWM, GZ_W_M_ZWP, &
!$acc & ZMZF_DZZ, ZDFDDWDZ, ZWP, &
!$acc & ZDU_DZ_DZS_DX, ZDV_DZ_DZS_DY, ZDU_DX, ZDV_DY, ZDW_DZ, &
@@ -395,13 +435,15 @@ CALL ADD3DFIELD_ll( TZFIELDS_ll, ZFLX, 'TURB_HOR_DYN_CORR::ZFLX' )
!
! Computes the U variance
IF (.NOT. L2D) THEN
- !$acc kernels async(2)
- ZFLX(:,:,:)= (2./3.) * PTKEM &
- - XCMFS * PK *( (4./3.) * GX_U_M_PUM &
- -(2./3.) * ( GY_V_M_PVM &
- +GZ_W_M_PWM ) )
- !$acc end kernels
- !! & to be tested later
+ !$acc kernels async(2)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK)= (2./3.) * PTKEM(JI,JJ,JK) &
+ - XCMFS * PK(JI,JJ,JK) *( (4./3.) * GX_U_M_PUM(JI,JJ,JK) &
+ -(2./3.) * ( GY_V_M_PVM(JI,JJ,JK) &
+ +GZ_W_M_PWM(JI,JJ,JK) ) )
+ END DO !CONCURRENT
+ !$acc end kernels
+ !! & to be tested later
!! + XCMFB * PLM / SQRT(PTKEM) * (-2./3.) * PTP
ELSE
!$acc kernels async(2)
@@ -640,7 +682,9 @@ END IF
#else
CALL MXF_DEVICE(PDXX, ZTMP1_DEVICE)
!$acc kernels async(10)
-ZTMP2_DEVICE = PRHODJ * ZFLX / ZTMP1_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) * ZFLX(JI,JJ,JK) / ZTMP1_DEVICE(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
!
!!! wait for the computation of ZTMP2_DEVICE and the update of ZFLX
@@ -650,33 +694,41 @@ CALL DXM_DEVICE(ZTMP2_DEVICE, ZTMP3_DEVICE)
IF (.NOT. LFLAT) THEN
CALL MZM_DEVICE(PDXX,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PRHODJ * ZFLX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) * ZFLX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP4_DEVICE * PINV_PDZZ
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP4_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MXM_DEVICE( ZTMP2_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = PDZX / ZTMP1_DEVICE * ZTMP4_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PDZX(JI,JJ,JK) / ZTMP1_DEVICE(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels async(1)
- PRUS(:,:,:)=PRUS &
- -ZTMP3_DEVICE &
- +ZTMP1_DEVICE
+ PRUS(:,:,:)=PRUS(:,:,:) &
+ -ZTMP3_DEVICE(:,:,:) &
+ +ZTMP1_DEVICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels async(1)
- PRUS(:,:,:)=PRUS - ZTMP3_DEVICE
+ PRUS(:,:,:)=PRUS(:,:,:) - ZTMP3_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
!
IF (KSPLT==1) THEN
! Contribution to the dynamic production of TKE:
- !$acc kernels async(2)
- ZWORK(:,:,:) = - ZFLX(:,:,:) * GX_U_M_PUM
+ !$acc kernels async(2)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZWORK(JI,JJ,JK) = - ZFLX(JI,JJ,JK) * GX_U_M_PUM(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
!
! evaluate the dynamic production at w(IKB+1) in PDP(IKB)
@@ -723,12 +775,14 @@ END IF
!
! Computes the V variance
IF (.NOT. L2D) THEN
- !$acc kernels async(3)
- ZFLX(:,:,:)= (2./3.) * PTKEM &
- - XCMFS * PK *( (4./3.) * GY_V_M_PVM &
- -(2./3.) * ( GX_U_M_PUM &
- +GZ_W_M_PWM ) )
- !$acc end kernels
+ !$acc kernels async(3)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK)= (2./3.) * PTKEM(JI,JJ,JK) &
+ - XCMFS * PK(JI,JJ,JK) *( (4./3.) * GY_V_M_PVM(JI,JJ,JK) &
+ -(2./3.) * ( GX_U_M_PUM(JI,JJ,JK) &
+ +GZ_W_M_PWM(JI,JJ,JK) ) )
+ END DO !CONCURRENT
+ !$acc end kernels
!! & to be tested
!! + XCMFB * PLM / SQRT(PTKEM) * (-2./3.) * PTP
!
@@ -837,7 +891,9 @@ IF (.NOT. L2D) THEN
#else
CALL MYF_DEVICE(PDYY, ZTMP1_DEVICE)
!$acc kernels async(10)
- ZTMP2_DEVICE = PRHODJ * ZFLX / ZTMP1_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) * ZFLX(JI,JJ,JK) / ZTMP1_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
!
!!! wait for the computation of ZTMP2_DEVICE and the update of ZFLX
@@ -847,31 +903,41 @@ IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
CALL MZM_DEVICE(PDYY,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PRHODJ * ZFLX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) * ZFLX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP4_DEVICE * PINV_PDZZ
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP4_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MYM_DEVICE( ZTMP2_DEVICE,ZTMP4_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = PDZY / ZTMP1_DEVICE * ZTMP4_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PDZY(JI,JJ,JK) / ZTMP1_DEVICE(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP4_DEVICE )
!$acc kernels async(1)
- PRVS(:,:,:)=PRVS &
- -ZTMP3_DEVICE &
- +ZTMP4_DEVICE
+ PRVS(:,:,:)=PRVS(:,:,:) &
+ -ZTMP3_DEVICE(:,:,:) &
+ +ZTMP4_DEVICE(:,:,:)
!$acc end kernels
ELSE
- !$acc kernels async(1)
- PRVS(:,:,:)=PRVS - ZTMP3_DEVICE
+ !$acc kernels async(1)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRVS(JI,JJ,JK)=PRVS(JI,JJ,JK) - ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
END IF
! Contribution to the dynamic production of TKE:
IF (KSPLT==1) THEN
- !$acc kernels async(2)
- ZWORK(:,:,:) = - ZFLX(:,:,:) * GY_V_M_PVM
+ !$acc kernels async(2)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZWORK(JI,JJ,JK) = - ZFLX(JI,JJ,JK) * GY_V_M_PVM(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
ENDIF
#endif
@@ -923,11 +989,13 @@ END IF
!
! Computes the W variance
IF (.NOT. L2D) THEN
- !$acc kernels async(2)
- ZFLX(:,:,:)= (2./3.) * PTKEM &
- - XCMFS * PK *( (4./3.) * GZ_W_M_PWM &
- -(2./3.) * ( GX_U_M_PUM &
- +GY_V_M_PVM ) )
+ !$acc kernels async(2)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = (2./3.) * PTKEM(JI,JJ,JK) &
+ - XCMFS * PK(JI,JJ,JK) *( (4./3.) * GZ_W_M_PWM(JI,JJ,JK) &
+ -(2./3.) * ( GX_U_M_PUM(JI,JJ,JK) &
+ +GY_V_M_PVM(JI,JJ,JK) ) )
+ END DO !CONCURRENT
!$acc end kernels
!! & to be tested
!! -2.* XCMFB * PLM / SQRT(PTKEM) * (-2./3.) * PTP
@@ -1035,15 +1103,19 @@ GZ_W_M_ZWP = GZ_W_M(ZWP,PDZZ)
CALL GZ_W_M_DEVICE(1,IKU,1,ZWP,PDZZ,GZ_W_M_ZWP)
#endif
!$acc kernels async(2)
-ZFLX(:,:,IKB+1:)=ZFLX(:,:,IKB+1:) &
- - XCMFS * PK(:,:,IKB+1:) * (4./3.) * (GZ_W_M_ZWP(:,:,IKB+1:) - GZ_W_M_PWM(:,:,IKB+1:))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU)
+ ZFLX(JI,JJ,IKB+1:)=ZFLX(JI,JJ,IKB+1:) &
+ - XCMFS * PK(JI,JJ,IKB+1:) * (4./3.) * (GZ_W_M_ZWP(JI,JJ,IKB+1:) - GZ_W_M_PWM(JI,JJ,IKB+1:))
+END DO !CONCURRENT
!$acc end kernels
!
IF (KSPLT==1) THEN
- !Contribution to the dynamic production of TKE:
- !$acc kernels async(2)
- ZWORK(:,:,:) = - ZFLX(:,:,:) * GZ_W_M_ZWP
- !$acc end kernels
+ !Contribution to the dynamic production of TKE:
+ !$acc kernels async(2)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZWORK(JI,JJ,JK) = - ZFLX(JI,JJ,JK) * GZ_W_M_ZWP(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
!
! evaluate the dynamic production at w(IKB+1) in PDP(IKB)
!
@@ -1173,6 +1245,22 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+DEALLOCATE (ZFLX, ZWORK, ZDIRSINZW, ZCOEFF, ZDZZ, &
+ GX_U_M_PUM, GY_V_M_PVM, GZ_W_M_PWM, GZ_W_M_ZWP, &
+ ZMZF_DZZ, ZDFDDWDZ, ZWP, &
+ ZDU_DZ_DZS_DX, ZDV_DZ_DZS_DY, ZDU_DX, ZDV_DY, ZDW_DZ )
+#else
+CALL MNH_REL_ZT3D(IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE )
+CALL MNH_REL_ZT3D(IZFLX, IZWORK, IZDIRSINZW, &
+ IGX_U_M_PUM, IGY_V_M_PVM, IGZ_W_M_PWM, IGZ_W_M_ZWP, &
+ IZMZF_DZZ, IZDFDDWDZ, IZWP, &
+ IZDU_DZ_DZS_DX, IZDV_DZ_DZS_DY, IZDU_DX, IZDV_DY, IZDW_DZ, &
+ IZCOEFF, IZDZZ )
+
+#endif
+
+
!$acc end data
END SUBROUTINE TURB_HOR_DYN_CORR
diff --git a/src/MNH/turb_hor_splt.f90 b/src/MNH/turb_hor_splt.f90
index 452aeddec..05d4a0e6f 100644
--- a/src/MNH/turb_hor_splt.f90
+++ b/src/MNH/turb_hor_splt.f90
@@ -270,6 +270,10 @@ USE MODI_SHUMAN_DEVICE
USE MODI_TURB_HOR
USE MODI_TURB_HOR_TKE
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D, &
+ MNH_ALLOCATE_ZT4D , MNH_REL_ZT4D
+#endif
!
IMPLICIT NONE
!
@@ -347,12 +351,13 @@ REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PSIGS
!
!* 0.2 declaration of local variables
!
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZK ! Turbulent diffusion doef.
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZK ! Turbulent diffusion doef.
! ZK = PLM * SQRT(PTKEM)
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZINV_PDXX ! 1./PDXX
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZINV_PDYY ! 1./PDYY
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZINV_PDZZ ! 1./PDZZ
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZMZM_PRHODJ ! MZM(PRHODJ)
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZINV_PDXX ! 1./PDXX
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZINV_PDYY ! 1./PDYY
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZINV_PDZZ ! 1./PDZZ
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZMZM_PRHODJ ! MZM(PRHODJ)
+INTEGER :: IZK,IZINV_PDXX,IZINV_PDYY,IZINV_PDZZ,IZMZM_PRHODJ
!
INTEGER :: JSPLT ! current split
!
@@ -362,15 +367,21 @@ INTEGER :: JRR, JSV
INTEGER :: ISV
INTEGER :: IINFO_ll
!
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZUM, ZVM, ZWM, ZTHLM, ZTKEM
-REAL,ALLOCATABLE,DIMENSION(:,:,:,:) :: ZRM, ZSVM
-REAL,ALLOCATABLE,DIMENSION(:,:,:) :: ZRUS, ZRVS, ZRWS, ZRTHLS
-REAL,ALLOCATABLE,DIMENSION(:,:,:,:) :: ZRRS, ZRSVS
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
+!
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZUM, ZVM, ZWM, ZTHLM, ZTKEM
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:,:) :: ZRM, ZSVM
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:) :: ZRUS, ZRVS, ZRWS, ZRTHLS
+REAL,POINTER , CONTIGUOUS,DIMENSION(:,:,:,:) :: ZRRS, ZRSVS
+INTEGER :: IZUM, IZVM, IZWM, IZTHLM, IZTKEM, IZRM, IZSVM &
+ , IZRUS, IZRVS, IZRWS, IZRTHLS, IZRRS, IZRSVS
!
TYPE(LIST_ll), POINTER, SAVE :: TZFIELDS_ll
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZTMP1_DEVICE,ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), POINTER , CONTIGUOUS :: ZTMP1_DEVICE,ZTMP2_DEVICE
+INTEGER :: IZTMP1_DEVICE,IZTMP2_DEVICE
#endif
! ---------------------------------------------------------------------------
@@ -445,17 +456,30 @@ IKE = SIZE(PUM,3) - JPVEXT
CALL GET_INDICE_ll (IIB,IJB,IIE,IJE)
ISV=SIZE(PSVM,4)
!
-ALLOCATE(ZK(SIZE(PTHLM,1),SIZE(PTHLM,2),SIZE(PTHLM,3)))
-ALLOCATE(ZINV_PDXX(SIZE(PDXX,1),SIZE(PDXX,2),SIZE(PDXX,3)))
-ALLOCATE(ZINV_PDYY(SIZE(PDYY,1),SIZE(PDYY,2),SIZE(PDYY,3)))
-ALLOCATE(ZINV_PDZZ(SIZE(PDZZ,1),SIZE(PDZZ,2),SIZE(PDZZ,3)))
-ALLOCATE(ZMZM_PRHODJ(SIZE(PRHODJ,1),SIZE(PRHODJ,2),SIZE(PRHODJ,3)))
+JIU = size(pthlm, 1 )
+JJU = size(pthlm, 2 )
+JKU = size(pthlm, 3 )
+!
+#ifndef MNH_OPENACC
+ALLOCATE(ZK(JIU,JJU,JKU))
+ALLOCATE(ZINV_PDXX(JIU,JJU,JKU))
+ALLOCATE(ZINV_PDYY(JIU,JJU,JKU))
+ALLOCATE(ZINV_PDZZ(JIU,JJU,JKU))
+ALLOCATE(ZMZM_PRHODJ(JIU,JJU,JKU))
+#else
+IZK = MNH_ALLOCATE_ZT3D(ZK, JIU,JJU,JKU)
+IZINV_PDXX = MNH_ALLOCATE_ZT3D(ZINV_PDXX, JIU,JJU,JKU)
+IZINV_PDYY = MNH_ALLOCATE_ZT3D(ZINV_PDYY, JIU,JJU,JKU)
+IZINV_PDZZ = MNH_ALLOCATE_ZT3D(ZINV_PDZZ, JIU,JJU,JKU)
+IZMZM_PRHODJ = MNH_ALLOCATE_ZT3D(ZMZM_PRHODJ, JIU,JJU,JKU)
+#endif
+
#ifdef MNH_OPENACC
-allocate( ZTMP1_DEVICE( SIZE( PTHLM, 1 ), SIZE( PTHLM, 2 ), SIZE( PTHLM, 3 ) ) )
-allocate( ZTMP2_DEVICE( SIZE( PTHLM, 1 ), SIZE( PTHLM, 2 ), SIZE( PTHLM, 3 ) ) )
+IZTMP1_DEVICE = MNH_ALLOCATE_ZT3D( ZTMP1_DEVICE, JIU,JJU,JKU )
+IZTMP2_DEVICE = MNH_ALLOCATE_ZT3D( ZTMP2_DEVICE, JIU,JJU,JKU )
#endif
-!$acc data create( ZK, ZINV_PDXX, ZINV_PDYY, ZINV_PDZZ, ZMZM_PRHODJ, &
+!$acc data present( ZK, ZINV_PDXX, ZINV_PDYY, ZINV_PDZZ, ZMZM_PRHODJ, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
@@ -482,7 +506,8 @@ IF (KSPLIT>1 .AND. CPROGRAM=='MESONH') THEN
!
!* 2.1 allocations
! -----------
-!
+ !
+#ifndef MNH_OPENACC
ALLOCATE(ZUM(SIZE(PUM,1),SIZE(PUM,2),SIZE(PUM,3)))
ALLOCATE(ZVM(SIZE(PVM,1),SIZE(PVM,2),SIZE(PVM,3)))
ALLOCATE(ZWM(SIZE(PWM,1),SIZE(PWM,2),SIZE(PWM,3)))
@@ -496,7 +521,28 @@ IF (KSPLIT>1 .AND. CPROGRAM=='MESONH') THEN
ALLOCATE(ZRSVS(SIZE(PRSVS,1),SIZE(PRSVS,2),SIZE(PRSVS,3),SIZE(PRSVS,4)))
ALLOCATE(ZRTHLS(SIZE(PRTHLS,1),SIZE(PRTHLS,2),SIZE(PRTHLS,3)))
ALLOCATE(ZRRS(SIZE(PRRS,1),SIZE(PRRS,2),SIZE(PRRS,3),SIZE(PRRS,4)))
-!$acc data create( zum, zvm, zwm, zsvm, zthlm, ztkem, zrm, zrus, zrvs, zrws, zrsvs, zrthls, zrrs )
+#else
+ IZUM = MNH_ALLOCATE_ZT3D(ZUM,JIU,JJU,JKU)
+ IZVM = MNH_ALLOCATE_ZT3D(ZVM,JIU,JJU,JKU)
+ IZWM = MNH_ALLOCATE_ZT3D(ZWM,JIU,JJU,JKU)
+
+ IZTHLM = MNH_ALLOCATE_ZT3D(ZTHLM,JIU,JJU,JKU)
+ IZTKEM = MNH_ALLOCATE_ZT3D(ZTKEM,JIU,JJU,JKU)
+
+ IZRUS = MNH_ALLOCATE_ZT3D(ZRUS,JIU,JJU,JKU)
+ IZRVS = MNH_ALLOCATE_ZT3D(ZRVS,JIU,JJU,JKU)
+ IZRWS = MNH_ALLOCATE_ZT3D(ZRWS,JIU,JJU,JKU)
+
+ IZRTHLS = MNH_ALLOCATE_ZT3D(ZRTHLS,JIU,JJU,JKU)
+
+ IZSVM = MNH_ALLOCATE_ZT4D(ZSVM,JIU,JJU,JKU, SIZE(PSVM,4) )
+ IZRM = MNH_ALLOCATE_ZT4D(ZRM,JIU,JJU,JKU, SIZE(PRM,4) )
+ IZRSVS = MNH_ALLOCATE_ZT4D(ZRSVS,JIU,JJU,JKU, SIZE(PRSVS,4) )
+ IZRRS = MNH_ALLOCATE_ZT4D(ZRRS,JIU,JJU,JKU, SIZE(PRRS,4) )
+
+#endif
+
+!$acc data present( zum, zvm, zwm, zsvm, zthlm, ztkem, zrm, zrus, zrvs, zrws, zrsvs, zrthls, zrrs )
!
!
!* 2.2 list for parallel exchanges
@@ -702,6 +748,7 @@ IF (KSPLIT>1 .AND. CPROGRAM=='MESONH') THEN
! -------------
!
!$acc end data
+#ifndef MNH_OPENACC
DEALLOCATE(ZUM)
DEALLOCATE(ZVM)
DEALLOCATE(ZWM)
@@ -715,6 +762,14 @@ IF (KSPLIT>1 .AND. CPROGRAM=='MESONH') THEN
DEALLOCATE(ZRSVS)
DEALLOCATE(ZRTHLS)
DEALLOCATE(ZRRS)
+#else
+ CALL MNH_REL_ZT4D (SIZE(PRRS,4) , IZRRS )
+ CALL MNH_REL_ZT4D (SIZE(PRSVS,4) , IZRSVS )
+ CALL MNH_REL_ZT4D (SIZE(PRM,4) , IZRM )
+ CALL MNH_REL_ZT4D (SIZE(PSVM,4) , IZSVM )
+ CALL MNH_REL_ZT3D ( izum, izvm, izwm, izthlm, iztkem, izrus, izrvs, izrws, izrthls)
+#endif
+
!
CALL CLEANLIST_ll(TZFIELDS_ll)
!
@@ -755,14 +810,15 @@ END IF
!
!$acc end data
+#ifndef MNH_OPENACC
DEALLOCATE(ZK)
DEALLOCATE(ZINV_PDXX)
DEALLOCATE(ZINV_PDYY)
DEALLOCATE(ZINV_PDZZ)
DEALLOCATE(ZMZM_PRHODJ)
-#ifdef MNH_OPENACC
-deallocate( ZTMP1_DEVICE )
-deallocate( ZTMP2_DEVICE )
+#else
+CALL MNH_REL_ZT3D(IZK, IZINV_PDXX, IZINV_PDYY, IZINV_PDZZ, IZMZM_PRHODJ, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE )
#endif
if ( mppdb_initialized ) then
diff --git a/src/MNH/turb_hor_sv_flux.f90 b/src/MNH/turb_hor_sv_flux.f90
index 2d3ce6c4e..8a80775f4 100644
--- a/src/MNH/turb_hor_sv_flux.f90
+++ b/src/MNH/turb_hor_sv_flux.f90
@@ -138,6 +138,10 @@ USE MODI_LES_MEAN_SUBGRID
!
USE MODI_SECOND_MNH
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
+!
IMPLICIT NONE
!
!
@@ -175,8 +179,8 @@ REAL, DIMENSION(:,:,:,:), INTENT(INOUT) :: PRSVS ! var. at t+1 -split-
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLXX, ZFLXY ! work arrays
-REAL, DIMENSION(:,:,:), allocatable :: ZWORK2D
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLXX, ZFLXY ! work arrays
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZWORK2D
!
REAL :: ZCSV !constant for the scalar flux
@@ -185,7 +189,8 @@ INTEGER :: IKB,IKE
! mass points of the domain
INTEGER :: JSV ! loop counter
INTEGER :: ISV ! number of scalar var.
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFF
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFF
+INTEGER :: IZFLXX, IZFLXY, IZWORK2D, IZCOEFF
! coefficients for the uncentred gradient
! computation near the ground
!
@@ -194,9 +199,13 @@ TYPE(TFIELDDATA) :: TZFIELD
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, &
- ZTMP4_DEVICE, ZTMP5_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, &
+ ZTMP4_DEVICE, ZTMP5_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE, IZTMP5_DEVICE
#endif
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PK, PINV_PDXX, PINV_PDYY, PINV_PDZZ, PMZM_PRHODJ, &
@@ -229,22 +238,35 @@ if ( mppdb_initialized ) then
call Mppdb_check( prsvs, "Turb_hor_sv_flux beg:prsvs" )
end if
-allocate( zflxx(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
-allocate( zflxy(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
+JIU = size(psvm, 1 )
+JJU = size(psvm, 2 )
+JKU = size(psvm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zflxx(JIU,JJU,JKU ) )
+allocate( zflxy(JIU,JJU,JKU ) )
+
+allocate( zwork2d(JIU,JJU, 1 ) )
-allocate( zwork2d(size( psvm, 1 ), size( psvm, 2 ), 1 ) )
+allocate( zcoeff((JIU,JJU, 1 + jpvext : 3 + jpvext ) )
+#else
+izflxx = MNH_ALLOCATE_ZT3D( zflxx,JIU,JJU,JKU)
+izflxy = MNH_ALLOCATE_ZT3D( zflxy,JIU,JJU,JKU)
+
+izwork2d = MNH_ALLOCATE_ZT3DP( zwork2d,JIU,JJU, 1 , 1 )
-allocate( zcoeff(size( pdzz, 1 ), size( pdzz, 2 ), 1 + jpvext : 3 + jpvext ) )
+izcoeff = MNH_ALLOCATE_ZT3DP( zcoeff,JIU,JJU, 1 + jpvext , 3 + jpvext )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
-allocate( ztmp2_device(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
-allocate( ztmp3_device(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
-allocate( ztmp4_device(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
-allocate( ztmp5_device(size( psvm, 1 ), size( psvm, 2 ), size( psvm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU)
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU)
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU)
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU)
+iztmp5_device = MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU)
#endif
-!$acc data create( ZFLXX, ZFLXY, ZWORK2D, ZCOEFF, &
+!$acc data present( ZFLXX, ZFLXY, ZWORK2D, ZCOEFF, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, ZTMP5_DEVICE )
!
@@ -619,6 +641,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( ZFLXX, ZFLXY, ZWORK2D, ZCOEFF )
+#else
+CALL MNH_REL_ZT3D ( IZFLXX, IZFLXY, IZWORK2D, IZCOEFF, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE, IZTMP5_DEVICE )
+#endif
+
!$acc end data
END SUBROUTINE TURB_HOR_SV_FLUX
diff --git a/src/MNH/turb_hor_thermo_corr.f90 b/src/MNH/turb_hor_thermo_corr.f90
index 6e1e1ba27..ad792de7e 100644
--- a/src/MNH/turb_hor_thermo_corr.f90
+++ b/src/MNH/turb_hor_thermo_corr.f90
@@ -149,6 +149,11 @@ USE MODI_SECOND_MNH
USE MODI_BITREP
#endif
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D, &
+ MNH_ALLOCATE_ZT4D , MNH_REL_ZT4D
+#endif
+!
IMPLICIT NONE
!
!
@@ -197,22 +202,27 @@ REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PSIGS
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX,ZWORK,ZA ! work arrays
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX,ZWORK,ZA ! work arrays
!
INTEGER :: IKB,IKE,IKU
! Index values for the Beginning and End
! mass points of the domain
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFF
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFF
+INTEGER :: IZFLX,IZWORK,IZA,IZCOEFF
! coefficients for the uncentred gradient
! computation near the ground
REAL :: ZTIME1, ZTIME2
TYPE(TFIELDDATA) :: TZFIELD
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE, ZTMP8_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE, ZTMP8_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE ,&
+ IZTMP5_DEVICE, IZTMP6_DEVICE, IZTMP7_DEVICE, IZTMP8_DEVICE
#endif
!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PINV_PDXX, PINV_PDYY, &
@@ -247,24 +257,36 @@ if ( mppdb_initialized ) then
call Mppdb_check( psigs, "Turb_hor_thermo_corr beg:psigs" )
end if
-allocate( zflx (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zwork(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( za (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size(pthlm, 1 )
+JJU = size(pthlm, 2 )
+JKU = size(pthlm, 3 )
-allocate( zcoeff(size( pdzz, 1 ), size( pdzz, 2 ), 1 + jpvext : 3 + jpvext ) )
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU ) )
+allocate( zwork(JIU,JJU,JKU ) )
+allocate( za (JIU,JJU,JKU ) )
+
+allocate( zcoeff(JIU,JJU, 1 + jpvext : 3 + jpvext ) )
+#else
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU )
+izwork = MNH_ALLOCATE_ZT3D( zwork ,JIU,JJU,JKU )
+iza = MNH_ALLOCATE_ZT3D( za ,JIU,JJU,JKU )
+
+izcoeff= MNH_ALLOCATE_ZT3DP( zcoeff,JIU,JJU, 1 + jpvext , 3 + jpvext )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp5_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp6_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp7_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp8_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+iztmp1_device= MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device= MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device= MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device= MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
+iztmp5_device= MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU )
+iztmp6_device= MNH_ALLOCATE_ZT3D( ztmp6_device,JIU,JJU,JKU )
+iztmp7_device= MNH_ALLOCATE_ZT3D( ztmp7_device,JIU,JJU,JKU )
+iztmp8_device= MNH_ALLOCATE_ZT3D( ztmp8_device,JIU,JJU,JKU )
#endif
-!$acc data create( ZFLX, ZWORK, ZA, ZCOEFF, &
+!$acc data present( ZFLX, ZWORK, ZA, ZCOEFF, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, &
!$acc & ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE, ZTMP8_DEVICE )
@@ -457,7 +479,9 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlPz, .TRUE. )
!
!$acc end data
+
#endif
+
CALL SECOND_MNH(ZTIME2)
XTIME_LES = XTIME_LES + ZTIME2 - ZTIME1
END IF
@@ -488,7 +512,8 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL GY_M_M_DEVICE(1,IKU,1,PTHLM ,PDYY,PDZZ,PDZY,ZTMP3_DEVICE)
CALL GY_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP4_DEVICE)
!$acc kernels
- ZFLX(:,:,:)=PLM(:,:,:) * PLEPS(:,:,:) * (ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)+ZTMP3_DEVICE(:,:,:)*ZTMP4_DEVICE(:,:,:) ) * (XCHT1+XCHT2)
+ ZFLX(:,:,:)=PLM(:,:,:) * PLEPS(:,:,:) * (ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:) &
+ +ZTMP3_DEVICE(:,:,:)*ZTMP4_DEVICE(:,:,:) ) * (XCHT1+XCHT2)
!$acc end kernels
ELSE
CALL GX_M_M_DEVICE(1,IKU,1,PTHLM ,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
@@ -858,6 +883,14 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate (zflx,zwork,za,zcoeff)
+#else
+CALL MNH_REL_ZT3D ( IZFLX, IZWORK, IZA, IZCOEFF, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE, &
+ IZTMP5_DEVICE, IZTMP6_DEVICE, IZTMP7_DEVICE, IZTMP8_DEVICE )
+#endif
+
!$acc end data
END SUBROUTINE TURB_HOR_THERMO_CORR
diff --git a/src/MNH/turb_hor_thermo_flux.f90 b/src/MNH/turb_hor_thermo_flux.f90
index f50efc83e..f589aec72 100644
--- a/src/MNH/turb_hor_thermo_flux.f90
+++ b/src/MNH/turb_hor_thermo_flux.f90
@@ -153,6 +153,12 @@ USE MODI_LES_MEAN_SUBGRID
!
USE MODI_SECOND_MNH
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D, &
+ MNH_ALLOCATE_ZT4D , MNH_REL_ZT4D, &
+ MNH_CHECK_IN_ZT3D,MNH_CHECK_OUT_ZT3D
+#endif
+!
IMPLICIT NONE
!
!
@@ -207,23 +213,30 @@ REAL, DIMENSION(:,:,:,:), INTENT(INOUT) :: PRRS ! var. at t+1 -split-
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX,ZFLXC ! work arrays
-!! REAL, DIMENSION(:,:,:), allocatable :: ZVPTV
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX,ZFLXC ! work arrays
+!! REAL, DIMENSION(:,:,:), pointer , contiguous :: ZVPTV
INTEGER :: IKB,IKE,IKU
! Index values for the Beginning and End
! mass points of the domain
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFF
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFF
! coefficients for the uncentred gradient
! computation near the ground
+INTEGER :: IZFLX,IZFLXC,IZCOEFF
!
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE, ZTMP8_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE, ZTMP8_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE, &
+ IZTMP5_DEVICE, IZTMP6_DEVICE, IZTMP7_DEVICE, IZTMP8_DEVICE
#endif
!
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
+!
! ---------------------------------------------------------------------------
!$acc data present( PK, PINV_PDXX, PINV_PDYY, PINV_PDZZ, PMZM_PRHODJ, &
@@ -263,24 +276,38 @@ if ( mppdb_initialized ) then
call Mppdb_check( prrs, "Turb_hor_thermo_flux beg:prrs" )
end if
-allocate( zflx (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zflxc(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-! allocate( zvptv(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size(pthlm, 1 )
+JJU = size(pthlm, 2 )
+JKU = size(pthlm, 3 )
-allocate( zcoeff(size( pdzz, 1 ), size( pdzz, 2 ), 1 + jpvext : 3 + jpvext ) )
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU) )
+allocate( zflxc(JIU,JJU,JKU) )
+! allocate( zvptv(JIU,JJU,JKU) )
+
+allocate( zcoeff(JIU,JJU, 1 + jpvext : 3 + jpvext ) )
+#else
+CALL MNH_CHECK_IN_ZT3D("TURB_HOR_THERMO_FLUX")
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU )
+izflxc = MNH_ALLOCATE_ZT3D( zflxc,JIU,JJU,JKU )
+! izvptv= MNH_ALLOCATE_ZT3D( zvptv,JIU,JJU,JKU )
+
+izcoeff= MNH_ALLOCATE_ZT3DP( zcoeff,JIU,JJU, 1 + jpvext , 3 + jpvext )
+
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp5_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp6_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp7_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp8_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+iztmp1_device= MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device= MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device= MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device= MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
+iztmp5_device= MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU )
+iztmp6_device= MNH_ALLOCATE_ZT3D( ztmp6_device,JIU,JJU,JKU )
+iztmp7_device= MNH_ALLOCATE_ZT3D( ztmp7_device,JIU,JJU,JKU )
+iztmp8_device= MNH_ALLOCATE_ZT3D( ztmp8_device,JIU,JJU,JKU )
#endif
-!$acc data create( ZFLX, ZFLXC, ZCOEFF, &
+!$acc data present( ZFLX, ZFLXC, ZCOEFF, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, &
!$acc & ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE, ZTMP8_DEVICE )
@@ -315,7 +342,9 @@ ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
CALL MXM_DEVICE( PK, ZTMP1_DEVICE )
CALL GX_M_U_DEVICE(1,IKU,1,PTHLM,PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
-ZFLX(:,:,:) = -XCSHF * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = -XCSHF * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+END DO
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
#endif
@@ -376,19 +405,27 @@ END IF
IF (.NOT. LFLAT) THEN
CALL MXM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDXX(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DXF_DEVICE(ZTMP2_DEVICE, ZTMP3_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDXX(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = PDZX(:,:,:)*ZTMP4_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PDZX(JI,JJ,JK)*ZTMP4_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MXF_DEVICE(ZTMP2_DEVICE, ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP4_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP4_DEVICE )
!$acc kernels
@@ -606,7 +643,9 @@ IF (KSPLT==1 .AND. LLES_CALL) THEN
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE,X_LES_RES_ddxa_Rt_SBG_UaThl , .TRUE. )
END IF
!$acc end data
+
#endif
+
CALL SECOND_MNH(ZTIME2)
XTIME_LES = XTIME_LES + ZTIME2 - ZTIME1
END IF
@@ -729,7 +768,9 @@ END IF
CALL MXM_DEVICE( PK, ZTMP1_DEVICE )
CALL GX_M_U_DEVICE(1,IKU,1,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
- ZFLX(:,:,:) = -XCHF * ZTMP1_DEVICE * ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = -XCHF * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+END DO
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
!
@@ -765,23 +806,33 @@ END IF
IF (.NOT. LFLAT) THEN
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDXX(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DXF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDXX(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = PDZX(:,:,:)*ZTMP4_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PDZX(JI,JJ,JK)*ZTMP4_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MXF_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP4_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP2_DEVICE, ZTMP4_DEVICE)
!$acc kernels
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRRS(JI,JJ,JK,1) = PRRS(JI,JJ,JK,1) - ZTMP3_DEVICE(JI,JJ,JK) + ZTMP4_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
ELSE
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
@@ -1089,7 +1140,9 @@ END IF
CALL MYM_DEVICE( PK, ZTMP1_DEVICE )
CALL GY_M_V_DEVICE(1,IKU,1,PTHLM,PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
!$acc kernels
- ZFLX(:,:,:) = -XCSHF * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = -XCSHF * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+END DO
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
ELSE
@@ -1133,23 +1186,33 @@ IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDYY(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDYY(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = PDZY(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MYF_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP2_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- PRTHLS(:,:,:) = PRTHLS(:,:,:) - ZTMP3_DEVICE(:,:,:) + ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRTHLS(JI,JJ,JK) = PRTHLS(JI,JJ,JK) - ZTMP3_DEVICE(JI,JJ,JK) + ZTMP2_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
ELSE
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
@@ -1438,7 +1501,9 @@ IF (KRR/=0) THEN
CALL MYM_DEVICE( PK, ZTMP1_DEVICE )
CALL GY_M_V_DEVICE(1,IKU,1,PRM(:,:,:,1),PDYY,PDZZ,PDZY, ZTMP2_DEVICE)
!$acc kernels
- ZFLX(:,:,:) = -XCHF * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = -XCHF * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
ELSE
@@ -1481,25 +1546,35 @@ IF (KRR/=0) THEN
IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDYY(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDYY(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = PDZY(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MYF_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP2_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP1_DEVICE,ZTMP2_DEVICE )
!
!$acc kernels
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE(:,:,:) + ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRRS(JI,JJ,JK,1) = PRRS(JI,JJ,JK,1) - ZTMP3_DEVICE(JI,JJ,JK) + ZTMP2_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
ELSE
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
@@ -1703,6 +1778,15 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate (zflx,zflxc,zcoeff)
+#else
+CALL MNH_REL_ZT3D ( IZFLX, IZFLXC, IZCOEFF, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE, &
+ IZTMP5_DEVICE, IZTMP6_DEVICE, IZTMP7_DEVICE, IZTMP8_DEVICE )
+CALL MNH_CHECK_OUT_ZT3D("TURB_HOR_THERMO_FLUX")
+#endif
+
!$acc end data
END SUBROUTINE TURB_HOR_THERMO_FLUX
diff --git a/src/MNH/turb_hor_tke.f90 b/src/MNH/turb_hor_tke.f90
index f98d8de25..60f38ea4d 100644
--- a/src/MNH/turb_hor_tke.f90
+++ b/src/MNH/turb_hor_tke.f90
@@ -98,7 +98,11 @@ USE MODI_GRADIENT_M
USE MODI_LES_MEAN_SUBGRID
!
USE MODI_SECOND_MNH
-!
+
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
+
IMPLICIT NONE
!
!
@@ -125,17 +129,22 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PTRH ! horizontal transport of T
!
INTEGER :: IKB, IKU
!
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFF
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFF
! coefficients for the uncentred gradient
! computation near the ground
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX
+INTEGER :: IZCOEFF,IZFLX
!
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE
#endif
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PDXX, PDYY, PDZZ, PDZX, PDZY, &
@@ -161,18 +170,29 @@ if ( mppdb_initialized ) then
call Mppdb_check( ptrh, "Turb_hor_tke beg:ptrh" )
end if
-allocate( zflx (size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
+JIU = size(ptkem, 1 )
+JJU = size(ptkem, 2 )
+JKU = size(ptkem, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU ) )
+
+allocate( zcoeff(JIU,JJU,JKU, 1 + jpvext : 3 + jpvext ) )
+#else
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU )
+
+izcoeff = MNH_ALLOCATE_ZT3DP( zcoeff,JIU,JJU, 1 + jpvext , 3 + jpvext )
+#endif
-allocate( zcoeff(size( pdzz, 1 ), size( pdzz, 2 ), 1 + jpvext : 3 + jpvext ) )
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( ztmp2_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( ztmp3_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
-allocate( ztmp4_device(size( ptkem, 1 ), size( ptkem, 2 ), size( ptkem, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU)
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU)
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU)
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU)
#endif
-!$acc data create( ZCOEFF, ZFLX, &
+!$acc data present( ZCOEFF, ZFLX, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE )
!
@@ -206,7 +226,9 @@ ZFLX = -XCET * MXM(PK) * GX_M_U(1,IKU,1,PTKEM,PDXX,PDZZ,PDZX) ! < u'e >
CALL MXM_DEVICE(PK,ZTMP1_DEVICE)
CALL GX_M_U_DEVICE(1,IKU,1,PTKEM,PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
-ZFLX = -XCET * ZTMP1_DEVICE * ZTMP2_DEVICE ! < u'e >
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = -XCET * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) ! < u'e >
+END DO !CONCURRENT
#endif
!
! special case near the ground ( uncentred gradient )
@@ -263,23 +285,33 @@ END IF
IF (.NOT. LFLAT) THEN
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDXX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DXF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLX*PINV_PDXX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK)*PINV_PDXX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PDZX * ZTMP3_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PDZX(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MXF_DEVICE( ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PMZM_PRHODJ * ZTMP3_DEVICE * PINV_PDZZ
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- PTRH =-( ZTMP1_DEVICE - ZTMP3_DEVICE ) /PRHODJ
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PTRH(JI,JJ,JK) =-( ZTMP1_DEVICE(JI,JJ,JK) - ZTMP3_DEVICE(JI,JJ,JK) ) /PRHODJ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
ELSE
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
@@ -319,12 +351,16 @@ IF (.NOT. L2D) THEN
#else
CALL MYM_DEVICE(PK,ZTMP1_DEVICE)
CALL GY_M_V_DEVICE(1,IKU,1,PTKEM,PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
-!$acc kernels
- ZFLX =-XCET * ZTMP1_DEVICE * ZTMP2_DEVICE ! < v'e >
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) =-XCET * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) ! < v'e >
+ END DO !CONCURRENT
+ !$acc end kernels
#endif
!
! special case near the ground ( uncentred gradient )
!
+!$acc kernels
ZFLX(:,:,IKB) = ZCOEFF(:,:,IKB+2)*PTKEM(:,:,IKB+2) &
+ ZCOEFF(:,:,IKB+1)*PTKEM(:,:,IKB+1) &
+ ZCOEFF(:,:,IKB )*PTKEM(:,:,IKB )
@@ -379,23 +415,33 @@ IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDYY
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DYF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLX*PINV_PDYY
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK)*PINV_PDYY(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PDZY * ZTMP3_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PDZY(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MYF_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PMZM_PRHODJ * ZTMP3_DEVICE * PINV_PDZZ
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- PTRH = PTRH - ( ZTMP1_DEVICE - ZTMP3_DEVICE ) /PRHODJ
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PTRH(JI,JJ,JK) = PTRH(JI,JJ,JK) - ( ZTMP1_DEVICE(JI,JJ,JK) - ZTMP3_DEVICE(JI,JJ,JK) ) /PRHODJ(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
ELSE
CALL MYM_DEVICE(PRHODJ,ZTMP1_DEVICE)
@@ -434,6 +480,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( ZCOEFF, ZFLX )
+#else
+CALL MNH_REL_ZT3D( IZFLX, IZCOEFF, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE )
+#endif
+
!$acc end data
!----------------------------------------------------------------------------
diff --git a/src/MNH/turb_hor_uv.f90 b/src/MNH/turb_hor_uv.f90
index d8ab326ee..328e6fd57 100644
--- a/src/MNH/turb_hor_uv.f90
+++ b/src/MNH/turb_hor_uv.f90
@@ -153,6 +153,10 @@ USE MODI_SECOND_MNH
USE MODI_BITREP
#endif
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
+!
IMPLICIT NONE
!
!
@@ -204,29 +208,35 @@ REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PDP ! TKE production terms
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX,ZWORK ! work arrays
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX,ZWORK ! work arrays
!
-REAL, DIMENSION(:,:), allocatable :: ZDIRSINZW
+REAL, DIMENSION(:,:), pointer , contiguous :: ZDIRSINZW
! sinus of the angle between the vertical and the normal to the orography
INTEGER :: IKB,IKE,IKU
! Index values for the Beginning and End
! mass points of the domain
!
-REAL, DIMENSION(:,:,:), allocatable :: GY_U_UV_PUM
-REAL, DIMENSION(:,:,:), allocatable :: GX_V_UV_PVM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GY_U_UV_PUM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GX_V_UV_PVM
+INTEGER :: IZFLX,IZWORK,IZDIRSINZW,IGY_U_UV_PUM,IGX_V_UV_PVM
!
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP2_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP3_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP4_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP5_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP6_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP7_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP5_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP6_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP7_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE,&
+ IZTMP5_DEVICE,IZTMP6_DEVICE,IZTMP7_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PK, PINV_PDXX, PINV_PDYY, PINV_PDZZ, PMZM_PRHODJ, PDXX, PDYY, PDZZ, PDZX, PDZY, &
@@ -265,25 +275,39 @@ if ( mppdb_initialized ) then
call Mppdb_check( pdp, "Turb_hor_uv beg:pdp" )
end if
-allocate( zflx (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( zwork(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
+JIU = size(pum, 1 )
+JJU = size(pum, 2 )
+JKU = size(pum, 3 )
-allocate( zdirsinzw(size( pum, 1 ), size( pum, 2 ) ) )
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU ) )
+allocate( zwork(JIU,JJU,JKU ) )
-allocate( gy_u_uv_pum(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( gx_v_uv_pvm(size( pvm, 1 ), size( pvm, 2 ), size( pvm, 3 ) ) )
+allocate( zdirsinzw(JIU,JJU ) )
+
+allocate( gy_u_uv_pum(JIU,JJU,JKU ) )
+allocate( gx_v_uv_pvm(JIU,JJU,JKU ) )
+#else
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU )
+izwork = MNH_ALLOCATE_ZT3D( zwork,JIU,JJU,JKU )
+
+izdirsinzw = MNH_ALLOCATE_ZT2D( zdirsinzw,JIU,JJU )
+
+igy_u_uv_pum = MNH_ALLOCATE_ZT3D( gy_u_uv_pum,JIU,JJU,JKU )
+igx_v_uv_pvm = MNH_ALLOCATE_ZT3D( gx_v_uv_pvm,JIU,JJU,JKU )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( ztmp2_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( ztmp3_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( ztmp4_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( ztmp5_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( ztmp6_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( ztmp7_device(size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
+iztmp5_device = MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU )
+iztmp6_device = MNH_ALLOCATE_ZT3D( ztmp6_device,JIU,JJU,JKU )
+iztmp7_device = MNH_ALLOCATE_ZT3D( ztmp7_device,JIU,JJU,JKU )
#endif
-!$acc data create( ZFLX, ZWORK, ZDIRSINZW, GY_U_UV_PUM, GX_V_UV_PVM, &
+!$acc data present( ZFLX, ZWORK, ZDIRSINZW, GY_U_UV_PUM, GX_V_UV_PVM, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE, &
!$acc & ZTMP5_DEVICE, ZTMP6_DEVICE, ZTMP7_DEVICE )
@@ -330,9 +354,11 @@ END IF
CALL MXM_DEVICE(PK,ZTMP1_DEVICE)
CALL MYM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
IF (.NOT. L2D) THEN
- !$acc kernels
- ZFLX(:,:,:)= - XCMFS * ZTMP2_DEVICE * (GY_U_UV_PUM + GX_V_UV_PVM)
- !$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK)= - XCMFS * ZTMP2_DEVICE(JI,JJ,JK) * (GY_U_UV_PUM(JI,JJ,JK) + GX_V_UV_PVM(JI,JJ,JK))
+ END DO !CONCURRENT
+ !$acc end kernels
ELSE
!$acc kernels
ZFLX(:,:,:)= - XCMFS * ZTMP2_DEVICE * (GX_V_UV_PVM)
@@ -479,35 +505,49 @@ END IF
#else
CALL MYM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE = ZTMP1_DEVICE * PINV_PDYY
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
CALL MXM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE = ZFLX * ZTMP1_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
CALL DYF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
IF (.NOT. LFLAT) THEN
CALL MZM_DEVICE(ZFLX,ZTMP2_DEVICE)
CALL MZM_DEVICE(PDYY,ZTMP3_DEVICE)
-!$acc kernels
- ZTMP4_DEVICE = PDZY/ZTMP3_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = PDZY(JI,JJ,JK)/ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MXM_DEVICE(ZTMP4_DEVICE,ZTMP5_DEVICE)
-!$acc kernels
- ZTMP4_DEVICE = ZTMP2_DEVICE*ZTMP5_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)*ZTMP5_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MYF_DEVICE(ZTMP4_DEVICE,ZTMP2_DEVICE)
-!$acc kernels
- ZTMP3_DEVICE = PMZM_PRHODJ * PINV_PDZZ
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MXM_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
-!$acc kernels
- ZTMP5_DEVICE = ZTMP2_DEVICE*ZTMP4_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP5_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)*ZTMP4_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP5_DEVICE,ZTMP3_DEVICE)
-!$acc kernels
- PRUS(:,:,:) = PRUS(:,:,:) - ZTMP1_DEVICE + ZTMP3_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRUS(JI,JJ,JK) = PRUS(JI,JJ,JK) - ZTMP1_DEVICE(JI,JJ,JK) + ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
ELSE
!$acc kernels
PRUS(:,:,:) = PRUS(:,:,:) - ZTMP1_DEVICE
@@ -528,35 +568,49 @@ END IF
#else
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE = ZTMP1_DEVICE * PINV_PDXX
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
CALL MYM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE = ZFLX * ZTMP1_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
CALL DXF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
IF (.NOT. LFLAT) THEN
CALL MZM_DEVICE(ZFLX,ZTMP2_DEVICE)
CALL MZM_DEVICE(PDXX,ZTMP3_DEVICE)
-!$acc kernels
- ZTMP4_DEVICE = PDZX/ZTMP3_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = PDZX(JI,JJ,JK)/ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MYM_DEVICE(ZTMP4_DEVICE,ZTMP5_DEVICE)
-!$acc kernels
- ZTMP4_DEVICE = ZTMP2_DEVICE*ZTMP5_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)*ZTMP5_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MXF_DEVICE(ZTMP4_DEVICE,ZTMP2_DEVICE)
-!$acc kernels
- ZTMP3_DEVICE = PMZM_PRHODJ * PINV_PDZZ
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = PMZM_PRHODJ(JI,JJ,JK) * PINV_PDZZ(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL MYM_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
-!$acc kernels
- ZTMP5_DEVICE = ZTMP2_DEVICE*ZTMP4_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP5_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)*ZTMP4_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP5_DEVICE,ZTMP3_DEVICE)
-!$acc kernels
- PRVS(:,:,:) = PRVS(:,:,:) - ZTMP1_DEVICE + ZTMP3_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRVS(JI,JJ,JK) = PRVS(JI,JJ,JK) - ZTMP1_DEVICE(JI,JJ,JK) + ZTMP3_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
ELSE
!$acc kernels
PRVS(:,:,:) = PRVS(:,:,:) - ZTMP1_DEVICE
@@ -578,8 +632,10 @@ IF (KSPLT==1) THEN
ENDIF
#else
IF (.NOT. L2D) THEN
-!$acc kernels
- ZTMP1_DEVICE = ZFLX * (GY_U_UV_PUM + GX_V_UV_PVM)
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) * (GY_U_UV_PUM(JI,JJ,JK) + GX_V_UV_PVM(JI,JJ,JK))
+ END DO !CONCURRENT
!$acc end kernels
ELSE
!$acc kernels
@@ -588,9 +644,11 @@ IF (KSPLT==1) THEN
ENDIF
CALL MYF_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
CALL MXF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
-!$acc kernels
- ZWORK(:,:,:) = - ZTMP1_DEVICE
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZWORK(JI,JJ,JK) = - ZTMP1_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
#endif
!
! evaluate the dynamic production at w(IKB+1) in PDP(IKB)
@@ -612,9 +670,9 @@ IF (KSPLT==1) THEN
) / MXF(MYM( 0.5*(PDXX(:,:,IKB:IKB)+PDXX(:,:,IKB+1:IKB+1)) ) )&
)
#else
-!$acc kernels
+ !$acc kernels
ZTMP1_DEVICE(:,:,1) = 0.5 * (ZFLX(:,:,IKB+1)+ZFLX(:,:,IKB))
-!$acc end kernels
+ !$acc end kernels
CALL MYF_DEVICE(ZTMP1_DEVICE(:,:,1:1),ZTMP2_DEVICE(:,:,1:1))
CALL MXF_DEVICE(ZTMP2_DEVICE(:,:,1:1),ZTMP1_DEVICE(:,:,1:1))
!
@@ -712,6 +770,15 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate ( ZFLX, ZWORK, ZDIRSINZW, GY_U_UV_PUM, GX_V_UV_PVM )
+#else
+CALL MNH_REL_ZT3D ( IZFLX, IZWORK, IZDIRSINZW, IGY_U_UV_PUM, IGX_V_UV_PVM, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE, &
+ IZTMP5_DEVICE, IZTMP6_DEVICE, IZTMP7_DEVICE )
+#endif
+
+
!$acc end data
END SUBROUTINE TURB_HOR_UV
diff --git a/src/MNH/turb_hor_uw.f90 b/src/MNH/turb_hor_uw.f90
index f64d43c2a..ff27caa32 100644
--- a/src/MNH/turb_hor_uw.f90
+++ b/src/MNH/turb_hor_uw.f90
@@ -139,7 +139,11 @@ USE MODI_COEFJ
USE MODI_LES_MEAN_SUBGRID
!
USE MODI_SECOND_MNH
-!
+
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
+
IMPLICIT NONE
!
!
@@ -179,24 +183,29 @@ REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PDP ! TKE production terms
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX,ZWORK ! work arrays
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX,ZWORK ! work arrays
!
INTEGER :: IKB,IKE,IKU
! Index values for the Beginning and End
! mass points of the domain
INTEGER :: JSV ! scalar loop counter
!
-REAL, DIMENSION(:,:,:), allocatable :: GX_W_UW_PWM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GX_W_UW_PWM
+INTEGER :: IZFLX,IZWORK,IGX_W_UW_PWM
!
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP2_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP3_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PK, PINV_PDXX, PINV_PDZZ, PMZM_PRHODJ, PDXX, PDZZ, PDZX, &
@@ -228,19 +237,30 @@ if ( mppdb_initialized ) then
call Mppdb_check( pdp, "Turb_hor_uw beg:pdp" )
end if
-allocate( zflx (size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( zwork(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+JIU = size(pwm, 1 )
+JJU = size(pwm, 2 )
+JKU = size(pwm, 3 )
-allocate( gx_w_uw_pwm(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU ) )
+allocate( zwork(JIU,JJU,JKU ) )
+
+allocate( gx_w_uw_pwm(JIU,JJU,JKU ) )
+#else
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU)
+izwork = MNH_ALLOCATE_ZT3D( zwork,JIU,JJU,JKU)
+
+igx_w_uw_pwm = MNH_ALLOCATE_ZT3D( gx_w_uw_pwm,JIU,JJU,JKU)
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( ztmp2_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( ztmp3_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( ztmp4_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU)
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU)
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU)
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU)
#endif
-!$acc data create( ZFLX, ZWORK, GX_W_UW_PWM, &
+!$acc data present( ZFLX, ZWORK, GX_W_UW_PWM, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE )
!
@@ -271,7 +291,9 @@ ZFLX(:,:,:) = &
CALL MZM_DEVICE(PK,ZTMP1_DEVICE)
CALL MXM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
-ZFLX(:,:,:) = - XCMFS * ZTMP2_DEVICE * GX_W_UW_PWM
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = - XCMFS * ZTMP2_DEVICE(JI,JJ,JK) * GX_W_UW_PWM(JI,JJ,JK)
+END DO !CONCURRENT
#endif
!! & to be tested
!! - (2./3.) * XCMFB * MZM( ZVPTU * MXM( PLM / SQRT(PTKEM) * XG / PTHVREF ) )
@@ -309,11 +331,15 @@ PRUS(:,:,:) = PRUS(:,:,:) - DZF( ZFLX* MXM( PMZM_PRHODJ ) / MXM( PDZZ ) )
CALL MXM_DEVICE( PMZM_PRHODJ, ZTMP1_DEVICE )
CALL MXM_DEVICE( PDZZ, ZTMP2_DEVICE )
!$acc kernels
-ZTMP3_DEVICE = ZFLX* ZTMP1_DEVICE / ZTMP2_DEVICE
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK)* ZTMP1_DEVICE(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP3_DEVICE, ZTMP1_DEVICE )
!$acc kernels
-PRUS(:,:,:) = PRUS(:,:,:) - ZTMP1_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRUS(JI,JJ,JK) = PRUS(JI,JJ,JK) - ZTMP1_DEVICE(JI,JJ,JK)
+END DO !CONCURRENT
!$acc end kernels
#endif
!
@@ -329,32 +355,44 @@ END IF
#else
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * PINV_PDXX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * PINV_PDXX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DXF_DEVICE( ZTMP2_DEVICE,ZTMP1_DEVICE)
IF (.NOT. LFLAT) THEN
- !$acc kernels
- ZTMP2_DEVICE = ZFLX*PDZX
- !$acc end kernels
- CALL MZF_DEVICE(1,IKU,1, ZTMP2_DEVICE, ZTMP3_DEVICE )
- !$acc kernels
- ZTMP2_DEVICE = ZTMP3_DEVICE*PINV_PDXX
- !$acc end kernels
- CALL MXF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
- CALL MZF_DEVICE(1,IKU,1,PDZZ, ZTMP2_DEVICE)
- !$acc kernels
- ZTMP4_DEVICE = PRHODJ * ZTMP3_DEVICE / ZTMP2_DEVICE
- !$acc end kernels
- CALL DZM_DEVICE(1,IKU,1, ZTMP4_DEVICE, ZTMP2_DEVICE )
- !$acc kernels
- PRWS(:,:,:) = PRWS(:,:,:) &
- - ZTMP1_DEVICE &
- + ZTMP2_DEVICE
- !$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK)*PDZX(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
+ CALL MZF_DEVICE(1,IKU,1, ZTMP2_DEVICE, ZTMP3_DEVICE )
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK)*PINV_PDXX(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
+ CALL MXF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
+ CALL MZF_DEVICE(1,IKU,1,PDZZ, ZTMP2_DEVICE)
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
+ CALL DZM_DEVICE(1,IKU,1, ZTMP4_DEVICE, ZTMP2_DEVICE )
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRWS(JI,JJ,JK) = PRWS(JI,JJ,JK) &
+ - ZTMP1_DEVICE(JI,JJ,JK) &
+ + ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
ELSE
!$acc kernels
PRWS(:,:,:) = PRWS(:,:,:) - ZTMP1_DEVICE
@@ -372,12 +410,16 @@ IF (KSPLT==1) THEN
#else
CALL GZ_U_UW_DEVICE(1,IKU,1,PUM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLX *( ZTMP1_DEVICE + GX_W_UW_PWM )
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) *( ZTMP1_DEVICE(JI,JJ,JK) + GX_W_UW_PWM(JI,JJ,JK) )
+ END DO !CONCURRENT
!$acc end kernels
CALL MXF_DEVICE( ZTMP2_DEVICE,ZTMP1_DEVICE )
CALL MZF_DEVICE(1,IKU,1, ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZWORK(:,:,:) = -ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZWORK(JI,JJ,JK) = -ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
#endif
!
@@ -518,6 +560,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( ZFLX, ZWORK, GX_W_UW_PWM )
+#else
+CALL MNH_REL_ZT3D ( IZFLX, IZWORK, IGX_W_UW_PWM, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE )
+#endif
+
!$acc end data
END SUBROUTINE TURB_HOR_UW
diff --git a/src/MNH/turb_hor_vw.f90 b/src/MNH/turb_hor_vw.f90
index 475a4972e..6ea12270b 100644
--- a/src/MNH/turb_hor_vw.f90
+++ b/src/MNH/turb_hor_vw.f90
@@ -138,7 +138,11 @@ USE MODI_COEFJ
USE MODI_LES_MEAN_SUBGRID
!
USE MODI_SECOND_MNH
-!
+
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
+
IMPLICIT NONE
!
!
@@ -177,24 +181,29 @@ REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PDP ! TKE production terms
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: ZFLX,ZWORK ! work arrays
-!! REAL, DIMENSION(:,:,:), allocatable :: ZVPTV
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZFLX,ZWORK ! work arrays
+!! REAL, DIMENSION(:,:,:), pointer , contiguous :: ZVPTV
INTEGER :: IKB,IKE,IKU
! Index values for the Beginning and End
! mass points of the domain
INTEGER :: JSV ! scalar loop counter
!
-REAL, DIMENSION(:,:,:), allocatable :: GY_W_VW_PWM
+REAL, DIMENSION(:,:,:), pointer , contiguous :: GY_W_VW_PWM
+INTEGER :: IZFLX,IZWORK,IGY_W_VW_PWM
!
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP2_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP3_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP2_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP3_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
! ---------------------------------------------------------------------------
!$acc data present( PK, PINV_PDYY, PINV_PDZZ, PMZM_PRHODJ, PDYY, PDZZ, PDZY, &
@@ -225,19 +234,30 @@ if ( mppdb_initialized ) then
call Mppdb_check( pdp, "Turb_hor_vw beg:pdp" )
end if
-allocate( zflx (size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( zwork(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+JIU = size(pwm, 1 )
+JJU = size(pwm, 2 )
+JKU = size(pwm, 3 )
-allocate( gy_w_vw_pwm(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+#ifndef MNH_OPENACC
+allocate( zflx (JIU,JJU,JKU ) )
+allocate( zwork(JIU,JJU,JKU ) )
+
+allocate( gy_w_vw_pwm(JIU,JJU,JKU ) )
+#else
+izflx = MNH_ALLOCATE_ZT3D( zflx ,JIU,JJU,JKU)
+izwork = MNH_ALLOCATE_ZT3D( zwork,JIU,JJU,JKU)
+
+igy_w_vw_pwm = MNH_ALLOCATE_ZT3D( gy_w_vw_pwm,JIU,JJU,JKU)
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( ztmp2_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( ztmp3_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
-allocate( ztmp4_device(size( pwm, 1 ), size( pwm, 2 ), size( pwm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU)
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU)
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU)
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU)
#endif
-!$acc data create( ZFLX, ZWORK, GY_W_VW_PWM, &
+!$acc data present( ZFLX, ZWORK, GY_W_VW_PWM, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE )
!
@@ -278,9 +298,11 @@ END IF
IF (.NOT. L2D) THEN
CALL MZM_DEVICE(PK,ZTMP1_DEVICE)
CALL MYM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
-!$acc kernels
- ZFLX(:,:,:) = - XCMFS * ZTMP2_DEVICE * GY_W_VW_PWM
-!$acc end kernels
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLX(JI,JJ,JK) = - XCMFS * ZTMP2_DEVICE(JI,JJ,JK) * GY_W_VW_PWM(JI,JJ,JK)
+ END DO !CONCURRENT
+ !$acc end kernels
!! & to be tested
!! - (2./3.) * XCMFB * MZM( ZVPTV * MYM( PLM / SQRT(PTKEM) * XG / PTHVREF ) )
ELSE
@@ -328,11 +350,15 @@ IF (.NOT. L2D) THEN
CALL MYM_DEVICE( PMZM_PRHODJ, ZTMP1_DEVICE )
CALL MYM_DEVICE( PDZZ, ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZFLX* ZTMP1_DEVICE / ZTMP2_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK)* ZTMP1_DEVICE(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP3_DEVICE, ZTMP1_DEVICE )
!$acc kernels
- PRVS(:,:,:) = PRVS(:,:,:) - ZTMP1_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRVS(JI,JJ,JK) = PRVS(JI,JJ,JK) - ZTMP1_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
ENDIF
#endif
@@ -353,30 +379,42 @@ IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * PINV_PDYY
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLX(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP1_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = ZFLX*PDZY
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) *PDZY(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP3_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = ZTMP3_DEVICE * PINV_PDYY
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK) * PINV_PDYY(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL MYF_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL MZF_DEVICE(1,IKU,1,PDZZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP4_DEVICE = PRHODJ * ZTMP3_DEVICE / ZTMP2_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP4_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
CALL DZM_DEVICE(1,IKU,1,ZTMP4_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- PRWS(:,:,:) = PRWS(:,:,:) &
- - ZTMP1_DEVICE &
- + ZTMP2_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PRWS(JI,JJ,JK) = PRWS(JI,JJ,JK) &
+ - ZTMP1_DEVICE(JI,JJ,JK) &
+ + ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
ELSE
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
@@ -405,12 +443,16 @@ IF (KSPLT==1) THEN
#else
CALL GZ_V_VW_DEVICE(1,IKU,1,PVM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLX *( ZTMP1_DEVICE + GY_W_VW_PWM )
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLX(JI,JJ,JK) *( ZTMP1_DEVICE(JI,JJ,JK) + GY_W_VW_PWM(JI,JJ,JK) )
+ END DO !CONCURRENT
!$acc end kernels
CALL MYF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
CALL MZF_DEVICE(1,IKU,1,ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZWORK(:,:,:) = -ZTMP2_DEVICE
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZWORK(JI,JJ,JK) = -ZTMP2_DEVICE(JI,JJ,JK)
+ END DO !CONCURRENT
!$acc end kernels
#endif
!
@@ -559,6 +601,13 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate( ZFLX, ZWORK, GY_W_VW_PWM )
+#else
+CALL MNH_REL_ZT3D ( IZFLX, IZWORK, IGY_W_VW_PWM, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE )
+#endif
+
!$acc end data
END SUBROUTINE TURB_HOR_VW
diff --git a/src/MNH/turb_ver.f90 b/src/MNH/turb_ver.f90
index b188f0778..673c4c304 100644
--- a/src/MNH/turb_ver.f90
+++ b/src/MNH/turb_ver.f90
@@ -343,6 +343,10 @@ USE MODE_PRANDTL
!
USE MODI_SECOND_MNH
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK, ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D
+#endif
+!
IMPLICIT NONE
!
!* 0.1 declarations of arguments
@@ -434,7 +438,7 @@ REAL, DIMENSION(:,:,:,:),INTENT(OUT) :: PWSV ! scalar flux
!
!* 0.2 declaration of local variables
!
-REAL, DIMENSION(:,:,:), allocatable :: &
+REAL, DIMENSION(:,:,:), pointer,contiguous :: &
ZBETA, & ! buoyancy coefficient
ZSQRT_TKE,& ! sqrt(e)
ZDTH_DZ, & ! d(th)/dz
@@ -456,6 +460,10 @@ REAL, DIMENSION(:,:,:), allocatable :: &
ZTHLP, & ! guess of potential temperature due to vert. turbulent flux
ZRP ! guess of total water due to vert. turbulent flux
+INTEGER :: izbeta,izsqrt_tke,izdth_dz,izdr_dz,izred2th3,izred2r3,izred2thr3, &
+ izbll_o_e,izetheta,izemoist,izredth1,izredr1,izphi3,izpsi3, &
+ izd,izwthv,izwu,izwv,izthlp,izrp
+
REAL, DIMENSION(:,:,:,:), allocatable :: &
ZPSI_SV, & ! Prandtl number for scalars
ZREDS1, & ! 1D Redeslperger number R_sv
@@ -471,6 +479,9 @@ REAL :: ZTIME2
!
TYPE(TFIELDDATA) :: TZFIELD
!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
+!
!----------------------------------------------------------------------------
!$acc data present( PDXX, PDYY, PDZZ, PDZX, PDZY, PDIRCOSZW, PZZ, &
@@ -542,36 +553,63 @@ if ( mppdb_initialized ) then
call Mppdb_check( prrs, "Turb_ver beg:prrs" )
end if
-allocate( zbeta (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zsqrt_tke(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zdth_dz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zdr_dz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zred2th3 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zred2r3 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zred2thr3(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zbll_o_e (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zetheta (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zemoist (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zredth1 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zredr1 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zphi3 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zpsi3 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zd (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zwthv (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zwu (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zwv (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zthlp (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zrp (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size( pthlm, 1 )
+JJU = size( pthlm, 2 )
+JKU = size( pthlm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zbeta (JIU,JJU,JKU) )
+allocate( zsqrt_tke(JIU,JJU,JKU) )
+allocate( zdth_dz (JIU,JJU,JKU) )
+allocate( zdr_dz (JIU,JJU,JKU) )
+allocate( zred2th3 (JIU,JJU,JKU) )
+allocate( zred2r3 (JIU,JJU,JKU) )
+allocate( zred2thr3(JIU,JJU,JKU) )
+allocate( zbll_o_e (JIU,JJU,JKU) )
+allocate( zetheta (JIU,JJU,JKU) )
+allocate( zemoist (JIU,JJU,JKU) )
+allocate( zredth1 (JIU,JJU,JKU) )
+allocate( zredr1 (JIU,JJU,JKU) )
+allocate( zphi3 (JIU,JJU,JKU) )
+allocate( zpsi3 (JIU,JJU,JKU) )
+allocate( zd (JIU,JJU,JKU) )
+allocate( zwthv (JIU,JJU,JKU) )
+allocate( zwu (JIU,JJU,JKU) )
+allocate( zwv (JIU,JJU,JKU) )
+allocate( zthlp (JIU,JJU,JKU) )
+allocate( zrp (JIU,JJU,JKU) )
+#else
+izbeta = MNH_ALLOCATE_ZT3D( zbeta ,JIU,JJU,JKU )
+izsqrt_tke = MNH_ALLOCATE_ZT3D( zsqrt_tke,JIU,JJU,JKU )
+izdth_dz = MNH_ALLOCATE_ZT3D( zdth_dz ,JIU,JJU,JKU )
+izdr_dz = MNH_ALLOCATE_ZT3D( zdr_dz ,JIU,JJU,JKU )
+izred2th3 = MNH_ALLOCATE_ZT3D( zred2th3 ,JIU,JJU,JKU )
+izred2r3 = MNH_ALLOCATE_ZT3D( zred2r3 ,JIU,JJU,JKU )
+izred2thr3 = MNH_ALLOCATE_ZT3D( zred2thr3,JIU,JJU,JKU )
+izbll_o_e = MNH_ALLOCATE_ZT3D( zbll_o_e ,JIU,JJU,JKU )
+izetheta = MNH_ALLOCATE_ZT3D( zetheta ,JIU,JJU,JKU )
+izemoist = MNH_ALLOCATE_ZT3D( zemoist ,JIU,JJU,JKU )
+izredth1 = MNH_ALLOCATE_ZT3D( zredth1 ,JIU,JJU,JKU )
+izredr1 = MNH_ALLOCATE_ZT3D( zredr1 ,JIU,JJU,JKU )
+izphi3 = MNH_ALLOCATE_ZT3D( zphi3 ,JIU,JJU,JKU )
+izpsi3 = MNH_ALLOCATE_ZT3D( zpsi3 ,JIU,JJU,JKU )
+izd = MNH_ALLOCATE_ZT3D( zd ,JIU,JJU,JKU )
+izwthv = MNH_ALLOCATE_ZT3D( zwthv ,JIU,JJU,JKU )
+izwu = MNH_ALLOCATE_ZT3D( zwu ,JIU,JJU,JKU )
+izwv = MNH_ALLOCATE_ZT3D( zwv ,JIU,JJU,JKU )
+izthlp = MNH_ALLOCATE_ZT3D( zthlp ,JIU,JJU,JKU )
+izrp = MNH_ALLOCATE_ZT3D( zrp ,JIU,JJU,JKU )
+#endif
allocate( zpsi_sv (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ), nsv ) )
allocate( zreds1 (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ), nsv ) )
allocate( zred2ths(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ), nsv ) )
allocate( zred2rs (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ), nsv ) )
-!$acc data create( ZBETA, ZSQRT_TKE, ZDTH_DZ, ZDR_DZ, ZRED2TH3, ZRED2R3, ZRED2THR3,&
+!$acc data present (ZBETA, ZSQRT_TKE, ZDTH_DZ, ZDR_DZ, ZRED2TH3, ZRED2R3, ZRED2THR3,&
!$acc & ZBLL_O_E, ZETHETA, ZEMOIST, ZREDTH1, ZREDR1, &
-!$acc & ZPHI3, ZPSI3, ZD, ZWTHV, ZWU, ZWV, ZTHLP, ZRP, &
-!$acc & ZPSI_SV, ZREDS1, ZRED2THS, ZRED2RS )
+!$acc & ZPHI3, ZPSI3, ZD, ZWTHV, ZWU, ZWV, ZTHLP, ZRP) &
+!$acc & create ( ZPSI_SV, ZREDS1, ZRED2THS, ZRED2RS )
!
!* 1. PRELIMINARIES
@@ -628,7 +666,9 @@ ENDIF
! Denominator factor in 3rd order terms
!
!$acc kernels
-ZD(:,:,:) = (1.+ZREDTH1(:,:,:)+ZREDR1(:,:,:)) * (1.+0.5*(ZREDTH1(:,:,:)+ZREDR1(:,:,:)))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZD(JI,JJ,JK) = (1.+ZREDTH1(JI,JJ,JK)+ZREDR1(JI,JJ,JK)) * (1.+0.5*(ZREDTH1(JI,JJ,JK)+ZREDR1(JI,JJ,JK)))
+END DO
!$acc end kernels
!
! Phi3 and Psi3 Prandtl numbers
@@ -857,6 +897,16 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+DEALLOCATE(zbeta,zsqrt_tke,zdth_dz,zdr_dz,zred2th3,zred2r3,zred2thr3, &
+ zbll_o_e,zetheta,zemoist,zredth1,zredr1,zphi3,zpsi3, &
+ zd,zwthv,zwu,zwv,zthlp,zrp)
+#else
+CALL MNH_REL_ZT3D(izbeta,izsqrt_tke,izdth_dz,izdr_dz,izred2th3,izred2r3,izred2thr3, &
+ izbll_o_e,izetheta,izemoist,izredth1,izredr1,izphi3,izpsi3, &
+ izd,izwthv,izwu,izwv,izthlp,izrp)
+#endif
+
!$acc end data
!----------------------------------------------------------------------------
diff --git a/src/MNH/turb_ver_dyn_flux.f90 b/src/MNH/turb_ver_dyn_flux.f90
index 879867dd0..834aa2d85 100644
--- a/src/MNH/turb_ver_dyn_flux.f90
+++ b/src/MNH/turb_ver_dyn_flux.f90
@@ -82,7 +82,6 @@ END INTERFACE
!
END MODULE MODI_TURB_VER_DYN_FLUX
!
-!
! ###############################################################
SUBROUTINE TURB_VER_DYN_FLUX(KKA,KKU,KKL, &
OCLOSE_OUT,OTURB_FLX,KRR, &
@@ -314,6 +313,10 @@ USE MODE_IO_FIELD_WRITE, only: IO_Field_write
USE MODE_ll
use mode_mppdb
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_ZT3DP , MNH_ALLOCATE_ZT2D
+#endif
+
IMPLICIT NONE
!
!* 0.1 declarations of arguments
@@ -374,11 +377,11 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PDP ! Dynamic TKE production t
!* 0.2 declaration of local variables
!
!
-REAL, DIMENSION(:,:), allocatable :: ZDIRSINZW ! sinus of the angle
+REAL, DIMENSION(:,:), pointer , contiguous :: ZDIRSINZW ! sinus of the angle
! between the normal and the vertical at the surface
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFS ! coeff. for the
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFS ! coeff. for the
! implicit scheme for the wind at the surface
-REAL, DIMENSION(:,:,:), allocatable :: &
+REAL, DIMENSION(:,:,:), pointer , contiguous :: &
ZA, & ! under diagonal elements of the tri-diagonal matrix involved
! in the temporal implicit scheme (also used to store coefficient
! J in Section 5)
@@ -388,25 +391,31 @@ REAL, DIMENSION(:,:,:), allocatable :: &
ZFLXZ, & ! vertical flux of the treated variable
ZSOURCE, & ! source of evolution for the treated variable
ZKEFF ! effectif diffusion coeff = LT * SQRT( TKE )
+INTEGER :: IZDIRSINZW,IZCOEFS,IZA,IZRES,IZFLXZ,IZSOURCE,IZKEFF
INTEGER :: IIB,IIE, & ! I index values for the Beginning and End
IJB,IJE, & ! mass points of the domain in the 3 direct.
IKB,IKE !
INTEGER :: IKT ! array size in k direction
INTEGER :: IKTB,IKTE ! start, end of k loops in physical domain
INTEGER :: JSV ! scalar loop counter
-REAL, DIMENSION(:,:,:), allocatable :: ZCOEFFLXU, &
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZCOEFFLXU, &
ZCOEFFLXV, ZUSLOPEM, ZVSLOPEM
! coefficients for the surface flux
! evaluation and copy of PUSLOPEM and
- ! PVSLOPEM in local 3D arrays
+ ! PVSLOPEM in local 3D arrays
+INTEGER :: IZCOEFFLXU,IZCOEFFLXV,IZUSLOPEM,IZVSLOPEM
INTEGER :: IIU,IJU ! size of array in x,y,z directions
!
REAL :: ZTIME1, ZTIME2
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE,ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE,ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE,IZTMP4_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!----------------------------------------------------------------------------
!$acc data present( PDXX, PDYY, PDZZ, PDZX, PDZY, PDIRCOSZW, &
@@ -449,29 +458,50 @@ if ( mppdb_initialized ) then
call Mppdb_check( prws, "Turb_ver_dyn_flux beg:prws" )
end if
-allocate( zdirsinzw(size( pum, 1 ), size( pum, 2 ) ) )
+JIU = size(pum, 1 )
+JJU = size(pum, 2 )
+JKU = size(pum, 3 )
+
+#ifndef MNH_OPENACC
+allocate( zdirsinzw(JIU,JJU ) )
+
+allocate( zcoefs (JIU,JJU, 1 ) )
+
+allocate( za (JIU,JJU,JKU ) )
+allocate( zres (JIU,JJU,JKU ) )
+allocate( zflxz (JIU,JJU,JKU ) )
+allocate( zsource (JIU,JJU,JKU ) )
+allocate( zkeff (JIU,JJU,JKU ) )
-allocate( zcoefs (size( pum, 1 ), size( pum, 2 ), 1 ) )
+allocate( zcoefflxu(JIU,JJU, 1 ) )
+allocate( zcoefflxv(JIU,JJU, 1 ) )
+allocate( zuslopem (JIU,JJU, 1 ) )
+allocate( zvslopem (JIU,JJU, 1 ) )
+#else
+izdirsinzw = MNH_ALLOCATE_ZT2D( zdirsinzw,JIU,JJU )
+
+izcoefs = MNH_ALLOCATE_ZT3DP( zcoefs ,JIU,JJU, 1 , 1 )
-allocate( za (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( zres (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( zflxz (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( zsource (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
-allocate( zkeff (size( pum, 1 ), size( pum, 2 ), size( pum, 3 ) ) )
+iza = MNH_ALLOCATE_ZT3D( za ,JIU,JJU,JKU )
+izres = MNH_ALLOCATE_ZT3D( zres ,JIU,JJU,JKU )
+izflxz = MNH_ALLOCATE_ZT3D( zflxz ,JIU,JJU,JKU )
+izsource = MNH_ALLOCATE_ZT3D( zsource ,JIU,JJU,JKU )
+izkeff = MNH_ALLOCATE_ZT3D( zkeff ,JIU,JJU,JKU )
-allocate( zcoefflxu(size( pdzz, 1 ), size( pdzz, 2 ), 1 ) )
-allocate( zcoefflxv(size( pdzz, 1 ), size( pdzz, 2 ), 1 ) )
-allocate( zuslopem (size( pdzz, 1 ), size( pdzz, 2 ), 1 ) )
-allocate( zvslopem (size( pdzz, 1 ), size( pdzz, 2 ), 1 ) )
+izcoefflxu = MNH_ALLOCATE_ZT3DP( zcoefflxu,JIU,JJU, 1 , 1 )
+izcoefflxv = MNH_ALLOCATE_ZT3DP( zcoefflxv,JIU,JJU, 1 , 1 )
+izuslopem = MNH_ALLOCATE_ZT3DP( zuslopem ,JIU,JJU, 1 , 1 )
+izvslopem = MNH_ALLOCATE_ZT3DP( zvslopem ,JIU,JJU, 1 , 1 )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
#endif
-!$acc data create( zdirsinzw, zcoefs, za, zres, zflxz, zsource, zkeff, zcoefflxu, zcoefflxv, zuslopem, zvslopem, &
+!$acc data present( zdirsinzw, zcoefs, za, zres, zflxz, zsource, zkeff, zcoefflxu, zcoefflxv, zuslopem, zvslopem, &
!$acc & ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device )
!
@@ -540,7 +570,9 @@ CALL MXM_DEVICE( PDZZ, ZTMP4_DEVICE )
#ifndef MNH_BITREP
ZA(:,:,:) = -PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / ZTMP4_DEVICE(:,:,:)**2
#else
-ZA(:,:,:) = -PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / BR_P2(ZTMP4_DEVICE(:,:,:))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = -PTSTEP * XCMFS * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) / BR_P2(ZTMP4_DEVICE(JI,JJ,JK))
+END DO
#endif
!$acc end kernels
#endif
@@ -628,6 +660,7 @@ PRUS(:,:,:)=PRUS(:,:,:)+MXM(PRHODJ(:,:,:))*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
#else
!$acc kernels
PRUS(:,:,:)=PRUS(:,:,:)+ZTMP1_DEVICE(:,:,:)*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
+!$acc end kernels
#endif
!
!
@@ -639,13 +672,18 @@ PRUS(:,:,:)=PRUS(:,:,:)+ZTMP1_DEVICE(:,:,:)*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
ZFLXZ(:,:,:) = -XCMFS * MXM(ZKEFF) * &
DZM (PIMPL*ZRES + PEXPL*PUM) / MXM(PDZZ)
#else
-ZTMP2_DEVICE(:,:,:) = PIMPL*ZRES(:,:,:) + PEXPL*PUM(:,:,:)
+!$acc kernels
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = PIMPL*ZRES(JI,JJ,JK) + PEXPL*PUM(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MXM_DEVICE(ZKEFF,ZTMP1_DEVICE)
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL MXM_DEVICE(PDZZ,ZTMP4_DEVICE)
!$acc kernels
-ZFLXZ(:,:,:) = -XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / ZTMP4_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = -XCMFS * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) / ZTMP4_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
#endif
!
@@ -700,7 +738,9 @@ PDP(:,:,:) = - MZF( MXF ( ZFLXZ * GZ_U_UW(PUM,PDZZ) ) )
#else
CALL GZ_U_UW_DEVICE(KKA,KKU,KKL,PUM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU )
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLXZ(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MXF_DEVICE( ZTMP2_DEVICE,ZTMP3_DEVICE )
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE, ZTMP4_DEVICE )
@@ -785,25 +825,35 @@ IF(HTURBDIM=='3DIM') THEN
#else
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) /PDXX(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) /PDXX(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE )
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) * ZFLXZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK) * ZFLXZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL DXF_DEVICE( ZTMP2_DEVICE,ZTMP1_DEVICE )
IF (.NOT. LFLAT) THEN
CALL MZF_DEVICE(KKA,KKU,KKL,PDZZ,ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZFLXZ(:,:,:)*PDZX(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZFLXZ(JI,JJ,JK)*PDZX(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE,ZTMP4_DEVICE )
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) / PDXX(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP4_DEVICE(JI,JJ,JK) / PDXX(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MXF_DEVICE( ZTMP3_DEVICE,ZTMP4_DEVICE )
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = PRHODJ(:,:,:) / ZTMP2_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE,ZTMP2_DEVICE)
!$acc kernels
@@ -823,12 +873,16 @@ IF(HTURBDIM=='3DIM') THEN
#else
CALL GX_W_UW_DEVICE(KKA,KKU,KKL, PWM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLXZ(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MXF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZA(:,:,:)=-ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK)=-ZTMP2_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
#endif
!
@@ -959,7 +1013,9 @@ CALL MYM_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
#ifndef MNH_BITREP
ZA(:,:,:) = - PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)**2
#else
-ZA(:,:,:) = - PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:) / BR_P2(ZTMP2_DEVICE(:,:,:))
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = - PTSTEP * XCMFS * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK) / BR_P2(ZTMP2_DEVICE(JI,JJ,JK))
+END DO
#endif
#endif
!
@@ -1063,13 +1119,17 @@ ZFLXZ(:,:,IKB:IKB) = MYM(PDZZ(:,:,IKB:IKB)) * &
) / 0.5 / ( 1. + MYM(PRHODJ(:,:,KKA:KKA)) / MYM(PRHODJ(:,:,IKB:IKB)) )
#else
!$acc kernels
-ZTMP1_DEVICE(:,:,:) = PIMPL*ZRES(:,:,:) + PEXPL*PVM(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ZTMP1_DEVICE(JI,JJ,JK) = PIMPL*ZRES(JI,JJ,JK) + PEXPL*PVM(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
CALL MYM_DEVICE(PDZZ,ZTMP3_DEVICE)
CALL MYM_DEVICE(ZKEFF,ZTMP1_DEVICE)
!$acc kernels
-ZFLXZ(:,:,:) = -XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:) / ZTMP3_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = -XCMFS * ZTMP1_DEVICE(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) / ZTMP3_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
!
CALL MYM_DEVICE(PDZZ(:,:,IKB:IKB),ZTMP1_DEVICE(:,:,1:1))
@@ -1115,12 +1175,16 @@ ZA(:,:,:) = - MZF( MYF ( ZFLXZ * GZ_V_VW(PVM,PDZZ) ) )
#else
CALL GZ_V_VW_DEVICE(KKA,KKU,KKL,PVM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLXZ(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE, ZTMP1_DEVICE )
!$acc kernels
-ZA(:,:,:) = - ZTMP1_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = - ZTMP1_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
#endif
!
@@ -1198,25 +1262,35 @@ IF(HTURBDIM=='3DIM') THEN
IF (.NOT. L2D) THEN
CALL MYM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) /PDYY(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) /PDYY(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLXZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE,ZTMP1_DEVICE )
IF (.NOT. LFLAT) THEN
CALL MZF_DEVICE(KKA,KKU,KKL,PDZZ,ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZFLXZ(:,:,:)*PDZY(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZFLXZ(JI,JJ,JK)*PDZY(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) / PDYY(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP4_DEVICE(JI,JJ,JK) / PDYY(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP3_DEVICE(:,:,:) = PRHODJ(:,:,:) / ZTMP2_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = PRHODJ(JI,JJ,JK) / ZTMP2_DEVICE(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE, ZTMP4_DEVICE)
!$acc kernels
@@ -1237,12 +1311,16 @@ IF(HTURBDIM=='3DIM') THEN
#else
CALL GY_W_VW_DEVICE(KKA,KKU,KKL, PWM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZFLXZ(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MYF_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZA(:,:,:) = - ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = - ZTMP2_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
#endif
!
@@ -1378,6 +1456,12 @@ end if
!$acc end data
+#ifndef MNH_OPENACC
+deallocate (zdirsinzw,zcoefs,za,zres,zflxz,zsource,zkeff,zcoefflxu,zcoefflxv,zuslopem,zvslopem)
+#else
+CALL MNH_REL_ZT3D(izdirsinzw,izcoefs,iza,izres,izflxz,izsource,izkeff,izcoefflxu,izcoefflxv,izuslopem,izvslopem,&
+ iztmp1_device,iztmp2_device,iztmp3_device,iztmp4_device)
+#endif
!$acc end data
!----------------------------------------------------------------------------
diff --git a/src/MNH/turb_ver_thermo_corr.f90 b/src/MNH/turb_ver_thermo_corr.f90
index 8bdb18ba4..56ee3d729 100644
--- a/src/MNH/turb_ver_thermo_corr.f90
+++ b/src/MNH/turb_ver_thermo_corr.f90
@@ -319,6 +319,10 @@ USE MODI_SECOND_MNH
USE MODI_BITREP
#endif
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_GT3D , MNH_REL_GT3D , MNH_ALLOCATE_ZT3DP
+#endif
+
IMPLICIT NONE
!
!* 0.1 declarations of arguments
@@ -384,18 +388,20 @@ REAL, DIMENSION(:,:,:), INTENT(OUT) :: PSIGS ! Vert. part of Sigma_s at
!* 0.2 declaration of local variables
!
!
-REAL, DIMENSION(:,:,:), allocatable :: &
+REAL, DIMENSION(:,:,:), pointer , contiguous :: &
ZFLXZ, & ! vertical flux of the treated variable
ZKEFF, & ! effectif diffusion coeff = LT * SQRT( TKE )
ZF, & ! Flux in dTh/dt =-dF/dz (evaluated at t-1)(or rt instead of Th)
ZDFDDTDZ, & ! dF/d(dTh/dz)
ZDFDDRDZ ! dF/d(dr/dz)
+INTEGER :: IZFLXZ,IZKEFF,IZF,IZDFDDTDZ,IZDFDDRDZ
INTEGER :: IKB,IKE ! I index values for the Beginning and End
! mass points of the domain in the 3 direct.
INTEGER :: I1,I2 ! For ZCOEFF allocation
-REAL, DIMENSION(:,:,:),ALLOCATABLE :: ZCOEFF
+REAL, DIMENSION(:,:,:),POINTER , CONTIGUOUS :: ZCOEFF
! coefficients for the uncentred gradient
! computation near the ground
+INTEGER :: IZCOEFF
!
REAL :: ZTIME1, ZTIME2
!
@@ -407,10 +413,15 @@ LOGICAL :: GFWR ! flag to use w'2r'
LOGICAL :: GFTHR ! flag to use w'th'r'
!
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE,ZTMP4_DEVICE
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP5_DEVICE,ZTMP6_DEVICE,ZTMP7_DEVICE,ZTMP8_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE,ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP5_DEVICE,ZTMP6_DEVICE,ZTMP7_DEVICE,ZTMP8_DEVICE
+INTEGER :: IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE,IZTMP4_DEVICE
+INTEGER :: IZTMP5_DEVICE,IZTMP6_DEVICE,IZTMP7_DEVICE,IZTMP8_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+!
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ,JK
!----------------------------------------------------------------------------
!$acc data present( PDZZ, &
@@ -466,26 +477,41 @@ IKE=KKU-JPVEXT_TURB*KKL
I1=MIN(KKA+JPVEXT_TURB*KKL,KKA+JPVEXT_TURB*KKL+2*KKL)
I2=MAX(KKA+JPVEXT_TURB*KKL,KKA+JPVEXT_TURB*KKL+2*KKL)
-allocate( zflxz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zkeff (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zf (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zdfddtdz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zdfddrdz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size( pthlm, 1 )
+JJU = size( pthlm, 2 )
+JKU = size( pthlm, 3 )
-allocate( zcoeff(size( pdzz, 1 ), size( pdzz, 2 ), i1 : i2 ) )
+#ifndef MNH_OPENACC
+allocate( zflxz (JIU,JJU,JKU) )
+allocate( zkeff (JIU,JJU,JKU) )
+allocate( zf (JIU,JJU,JKU) )
+allocate( zdfddtdz (JIU,JJU,JKU) )
+allocate( zdfddrdz (JIU,JJU,JKU) )
+
+allocate( zcoeff(JIU,JJU, i1 : i2 ) )
+#else
+izflxz = MNH_ALLOCATE_ZT3D( zflxz ,JIU,JJU,JKU )
+izkeff = MNH_ALLOCATE_ZT3D( zkeff ,JIU,JJU,JKU )
+izf = MNH_ALLOCATE_ZT3D( zf ,JIU,JJU,JKU )
+izdfddtdz = MNH_ALLOCATE_ZT3D( zdfddtdz ,JIU,JJU,JKU )
+izdfddrdz = MNH_ALLOCATE_ZT3D( zdfddrdz ,JIU,JJU,JKU )
+
+izcoeff = MNH_ALLOCATE_ZT3DP( zcoeff,JIU,JJU, i1 , i2 )
+!!$allocate( zcoeff(JIU,JJU, i1 : i2 ) )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp5_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp6_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp7_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp8_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
+iztmp5_device = MNH_ALLOCATE_ZT3D( ztmp5_device,JIU,JJU,JKU )
+iztmp6_device = MNH_ALLOCATE_ZT3D( ztmp6_device,JIU,JJU,JKU )
+iztmp7_device = MNH_ALLOCATE_ZT3D( ztmp7_device,JIU,JJU,JKU )
+iztmp8_device = MNH_ALLOCATE_ZT3D( ztmp8_device,JIU,JJU,JKU )
#endif
-!$acc data create( zflxz, zkeff, zf, zdfddtdz, zdfddrdz, zcoeff, &
+!$acc data present( zflxz, zkeff, zf, zdfddtdz, zdfddrdz, zcoeff, &
!$acc & ztmp1_device, ztmp2_device, ztmp3_device, ztmp4_device, &
!$acc & ztmp5_device, ztmp6_device, ztmp7_device, ztmp8_device )
@@ -551,8 +577,10 @@ END IF
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*ZTMP2_DEVICE(:,:,:)
- ZDFDDTDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZF (JI,JJ,JK) = XCTV*PLM(JI,JJ,JK)*PLEPS(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+ END DO
+ ZDFDDTDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
!$acc end kernels
#endif
!
@@ -685,14 +713,21 @@ END IF
! *DZM(PTHLP(:,:,:) - PTHLM(:,:,:)) / PDZZ(:,:,:) ) &
+ PIMPL * ZDFDDTDZ(:,:,:) * MZF(DZM(PTHLP(:,:,:) - PTHLM(:,:,:)) / PDZZ(:,:,:) )
#else
+ !$acc kernels
ZTMP1_DEVICE(:,:,:) = PTHLP(:,:,:) - PTHLM(:,:,:)
+ !$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
- ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP3_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ END DO
+ !$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE(:,:,:),ZTMP4_DEVICE(:,:,:) )
-
-!$acc kernels
- ZFLXZ(:,:,:) = ZF(:,:,:) &
- + PIMPL * ZDFDDTDZ(:,:,:) * ZTMP4_DEVICE(:,:,:)
+ !$acc kernels
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = ZF(JI,JJ,JK) &
+ + PIMPL * ZDFDDTDZ(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK)
+ END DO
#endif
!
! special case near the ground ( uncentred gradient )
@@ -808,8 +843,12 @@ END IF
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZF (JI,JJ,JK) = XCTV*PLM(JI,JJ,JK)*PLEPS(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+END DO
+!$acc end kernels
#endif
+!$acc kernels
ZDFDDTDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
ZDFDDRDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
!$acc end kernels
@@ -992,8 +1031,11 @@ END IF
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP4_DEVICE(:,:,:))
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
- ZTMP2_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) / PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP4_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ END DO
+
!$acc end kernels
CALL D_PHI3DTDZ_O_DDTDZ(PPHI3(:,:,:),PREDTH1(:,:,:),PREDR1(:,:,:),PRED2TH3(:,:,:),PRED2THR3(:,:,:), &
HTURBDIM,GUSERV,ZTMP3_DEVICE(:,:,:)) ! d(phi3*dthdz)/ddthdz term
@@ -1011,8 +1053,12 @@ END IF
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP8_DEVICE(:,:,:),ZTMP1_DEVICE(:,:,:))
!!!
!$acc kernels
- ZTMP7_DEVICE(:,:,:) = ( ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:)) * PDR_DZ(:,:,:) * ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:) &
- + ( ZTMP5_DEVICE(:,:,:) + ZTMP6_DEVICE(:,:,:)) * PDTH_DZ(:,:,:) * ZTMP1_DEVICE(:,:,:) / PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP7_DEVICE(JI,JJ,JK) = ( ZTMP3_DEVICE(JI,JJ,JK) + ZTMP4_DEVICE(JI,JJ,JK)) * PDR_DZ(JI,JJ,JK) &
+ * ZTMP2_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK) &
+ + ( ZTMP5_DEVICE(JI,JJ,JK) + ZTMP6_DEVICE(JI,JJ,JK)) * PDTH_DZ(JI,JJ,JK) &
+ * ZTMP1_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ END DO
!$acc end kernels
!!!
!$acc kernels
@@ -1022,18 +1068,22 @@ END IF
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP4_DEVICE(:,:,:))
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
- ZTMP2_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) /PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP4_DEVICE(JI,JJ,JK) /PDZZ(JI,JJ,JK)
+ END DO
!$acc end kernels
!!!
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP7_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:), ZTMP4_DEVICE(:,:,:) )
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:), ZTMP5_DEVICE(:,:,:) )
!$acc kernels
- ZFLXZ(:,:,:) = ZF(:,:,:) &
- + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:)*0.5 * ZTMP3_DEVICE(:,:,:) &
- + PIMPL * ZDFDDTDZ(:,:,:) * ZTMP4_DEVICE(:,:,:) &
- + PIMPL * ZDFDDRDZ(:,:,:) * ZTMP5_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = ZF(JI,JJ,JK) &
+ + PIMPL * XCTV*PLM(JI,JJ,JK)*PLEPS(JI,JJ,JK)*0.5 * ZTMP3_DEVICE(JI,JJ,JK) &
+ + PIMPL * ZDFDDTDZ(JI,JJ,JK) * ZTMP4_DEVICE(JI,JJ,JK) &
+ + PIMPL * ZDFDDRDZ(JI,JJ,JK) * ZTMP5_DEVICE(JI,JJ,JK)
+ END DO
#endif
!
! special case near the ground ( uncentred gradient )
@@ -1154,7 +1204,9 @@ END IF
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*ZTMP2_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZF (JI,JJ,JK) = XCTV*PLM(JI,JJ,JK)*PLEPS(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+ END DO
#endif
ZDFDDRDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
!$acc end kernels
@@ -1297,17 +1349,23 @@ END IF
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP3_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZFLXZ(:,:,:) = ZF(:,:,:) &
- + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:) * ZTMP1_DEVICE(:,:,:) &
- + PIMPL * ZDFDDRDZ(:,:,:) * ZTMP3_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = ZF(JI,JJ,JK) &
+ + PIMPL * XCTV*PLM(JI,JJ,JK)*PLEPS(JI,JJ,JK) * ZTMP1_DEVICE(JI,JJ,JK) &
+ + PIMPL * ZDFDDRDZ(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK)
+ END DO
#endif
!
! special case near the ground ( uncentred gradient )
@@ -1419,6 +1477,12 @@ end if
!$acc end data
+#ifdef MNH_OPENACC
+CALL MNH_REL_ZT3D(IZFLXZ,IZKEFF,IZF,IZDFDDTDZ,IZDFDDRDZ,IZCOEFF,&
+ IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE,IZTMP4_DEVICE,&
+ IZTMP5_DEVICE,IZTMP6_DEVICE,IZTMP7_DEVICE,IZTMP8_DEVICE )
+#endif
+
!$acc end data
!----------------------------------------------------------------------------
diff --git a/src/MNH/turb_ver_thermo_flux.f90 b/src/MNH/turb_ver_thermo_flux.f90
index 25dd18151..866cfd407 100644
--- a/src/MNH/turb_ver_thermo_flux.f90
+++ b/src/MNH/turb_ver_thermo_flux.f90
@@ -353,8 +353,11 @@ USE MODE_PRANDTL
!
USE MODI_SECOND_MNH
USE MODE_MPPDB
-
!
+#ifdef MNH_OPENACC
+USE MODE_MNH_ZWORK , ONLY : MNH_ALLOCATE_ZT3D , MNH_REL_ZT3D, MNH_ALLOCATE_GT3D , MNH_REL_GT3D
+#endif
+
IMPLICIT NONE
!
!* 0.1 declarations of arguments
@@ -458,7 +461,7 @@ LOGICAL :: GFR2 ! flag to use w'r'2
LOGICAL :: GFWR ! flag to use w'2r'
LOGICAL :: GFTHR ! flag to use w'th'r'
!
-REAL, DIMENSION(:,:,:), allocatable :: &
+REAL, DIMENSION(:,:,:), pointer , contiguous :: &
ZA, & ! work variable for wrc or LES computation
ZFLXZ, & ! vertical flux of the treated variable
ZSOURCE, & ! source of evolution for the treated variable
@@ -467,10 +470,16 @@ REAL, DIMENSION(:,:,:), allocatable :: &
ZDFDDTDZ, & ! dF/d(dTh/dz)
ZDFDDRDZ, & ! dF/d(dr/dz)
Z3RDMOMENT ! 3 order term in flux or variance equation
+INTEGER :: IZA,IZFLXZ,IZSOURCE,IZKEFF,IZF,IZDFDDTDZ,IZDFDDRDZ,IZ3RDMOMENT
#ifdef MNH_OPENACC
-REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE,ZTMP4_DEVICE
+REAL, DIMENSION(:,:,:), pointer , contiguous :: ZTMP1_DEVICE,ZTMP2_DEVICE,ZTMP3_DEVICE,ZTMP4_DEVICE
+INTEGER :: IZTMP1_DEVICE,IZTMP2_DEVICE,IZTMP3_DEVICE,IZTMP4_DEVICE
#endif
TYPE(TFIELDDATA) :: TZFIELD
+
+INTEGER :: JIU,JJU,JKU
+INTEGER :: JI,JJ
+
!----------------------------------------------------------------------------
!$acc data present( PDZZ, PDIRCOSZW, PZZ, &
@@ -532,23 +541,42 @@ if ( mppdb_initialized ) then
call Mppdb_check( prrs, "Turb_ver_thermo_flux beg:prrs" )
end if
-allocate( za (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zflxz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zsource (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zkeff (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zf (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zdfddtdz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( zdfddrdz (size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( z3rdmoment(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+JIU = size( pthlm, 1 )
+JJU = size( pthlm, 2 )
+JKU = size( pthlm, 3 )
+
+#ifndef MNH_OPENACC
+allocate( za (JIU,JJU,JKU ) )
+allocate( zflxz (JIU,JJU,JKU ) )
+allocate( zsource (JIU,JJU,JKU ) )
+allocate( zkeff (JIU,JJU,JKU ) )
+allocate( zf (JIU,JJU,JKU ) )
+allocate( zdfddtdz (JIU,JJU,JKU ) )
+allocate( zdfddrdz (JIU,JJU,JKU ) )
+allocate( z3rdmoment(JIU,JJU,JKU ) )
+#else
+iza = MNH_ALLOCATE_ZT3D( za ,JIU,JJU,JKU )
+izflxz = MNH_ALLOCATE_ZT3D( zflxz ,JIU,JJU,JKU )
+izsource = MNH_ALLOCATE_ZT3D( zsource ,JIU,JJU,JKU )
+izkeff = MNH_ALLOCATE_ZT3D( zkeff ,JIU,JJU,JKU )
+izf = MNH_ALLOCATE_ZT3D( zf ,JIU,JJU,JKU )
+izdfddtdz = MNH_ALLOCATE_ZT3D( zdfddtdz ,JIU,JJU,JKU )
+izdfddrdz = MNH_ALLOCATE_ZT3D( zdfddrdz ,JIU,JJU,JKU )
+iz3rdmoment = MNH_ALLOCATE_ZT3D( z3rdmoment,JIU,JJU,JKU )
+#endif
#ifdef MNH_OPENACC
-allocate( ztmp1_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp2_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp3_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
-allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
+!!$allocate( ztmp1_device(JIU,JJU,JKU ) )
+!!$allocate( ztmp2_device(JIU,JJU,JKU ) )
+!!$allocate( ztmp3_device(JIU,JJU,JKU ) )
+!!$allocate( ztmp4_device(JIU,JJU,JKU ) )
+iztmp1_device = MNH_ALLOCATE_ZT3D( ztmp1_device,JIU,JJU,JKU )
+iztmp2_device = MNH_ALLOCATE_ZT3D( ztmp2_device,JIU,JJU,JKU )
+iztmp3_device = MNH_ALLOCATE_ZT3D( ztmp3_device,JIU,JJU,JKU )
+iztmp4_device = MNH_ALLOCATE_ZT3D( ztmp4_device,JIU,JJU,JKU )
#endif
-!$acc data create( ZA, ZFLXZ, ZSOURCE, ZKEFF, ZF, ZDFDDTDZ, ZDFDDRDZ, Z3RDMOMENT, &
+!$acc data present( ZA, ZFLXZ, ZSOURCE, ZKEFF, ZF, ZDFDDTDZ, ZDFDDRDZ, Z3RDMOMENT, &
!$acc & ZTMP1_DEVICE, ZTMP2_DEVICE, ZTMP3_DEVICE, ZTMP4_DEVICE )
!
@@ -606,12 +634,16 @@ ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PR
#else
CALL DZM_DEVICE(KKA,KKU,KKL,PTHLM,ZTMP1_DEVICE)
!$acc kernels
-ZF (:,:,:) = -XCSHF*PPHI3(:,:,:)*ZKEFF(:,:,:)*ZTMP1_DEVICE(:,:,:)/PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZF (JI,JJ,JK) = -XCSHF*PPHI3(JI,JJ,JK)*ZKEFF(JI,JJ,JK)*ZTMP1_DEVICE(JI,JJ,JK)/PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
!
CALL D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV,ZTMP2_DEVICE)
!$acc kernels
-ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*ZTMP2_DEVICE(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZDFDDTDZ(JI,JJ,JK) = -XCSHF*ZKEFF(JI,JJ,JK)*ZTMP2_DEVICE(JI,JJ,JK)
+END DO
!$acc end kernels
#endif
!
@@ -783,9 +815,13 @@ ZTMP1_DEVICE(:,:,:) = PTHLP(:,:,:) - PTHLM(:,:,:)
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
-ZFLXZ(:,:,:) = ZF(:,:,:) + PIMPL * ZDFDDTDZ(:,:,:) * ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = ZF(JI,JJ,JK) + PIMPL * ZDFDDTDZ(JI,JJ,JK) * ZTMP2_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+END DO
+!$acc end kernels
#endif
!
+!$acc kernels
ZFLXZ(:,:,KKA) = ZFLXZ(:,:,IKB)
!
DO JK=IKTB+1,IKTE-1
@@ -826,7 +862,9 @@ END IF
IF (KRR /= 0) THEN
CALL MZM_DEVICE(PETHETA,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLXZ(JI,JJ,JK)
+END DO
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
@@ -878,7 +916,9 @@ IF ( KRRL >= 1 ) THEN
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)/PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)*ZFLXZ(JI,JJ,JK)/PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP3_DEVICE )
!$acc kernels
@@ -891,7 +931,9 @@ IF ( KRRL >= 1 ) THEN
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)/PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP1_DEVICE(JI,JJ,JK) = ZTMP2_DEVICE(JI,JJ,JK)*ZFLXZ(JI,JJ,JK)/PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP3_DEVICE )
!$acc kernels
@@ -1005,12 +1047,16 @@ IF (KRR /= 0) THEN
#else
CALL DZM_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),ZTMP1_DEVICE)
!$acc kernels
- ZF (:,:,:) = -XCSHF*PPSI3(:,:,:)*ZKEFF(:,:,:)*ZTMP1_DEVICE(:,:,:)/PDZZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZF (JI,JJ,JK) = -XCSHF*PPSI3(JI,JJ,JK)*ZKEFF(JI,JJ,JK)*ZTMP1_DEVICE(JI,JJ,JK)/PDZZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV,ZTMP1_DEVICE)
!CALL D_PHI3DRDZ_O_DDRDZ_DEVICE(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV,ZTMP1_DEVICE)
!$acc kernels
- ZDFDDRDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*ZTMP1_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZDFDDRDZ(JI,JJ,JK) = -XCSHF*ZKEFF(JI,JJ,JK)*ZTMP1_DEVICE(JI,JJ,JK)
+ END DO
!$acc end kernels
#endif
!
@@ -1181,7 +1227,9 @@ IF (KRR /= 0) THEN
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZFLXZ(:,:,:) = ZF(:,:,:) + PIMPL * ZDFDDRDZ(:,:,:) *ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
+DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZFLXZ(JI,JJ,JK) = ZF(JI,JJ,JK) + PIMPL * ZDFDDRDZ(JI,JJ,JK) *ZTMP2_DEVICE(JI,JJ,JK) / PDZZ(JI,JJ,JK)
+END DO
!$acc end kernels
#endif
!
@@ -1220,12 +1268,18 @@ IF (KRR /= 0) THEN
#else
CALL MZM_DEVICE(PEMOIST,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZTMP2_DEVICE(JI,JJ,JK) = ZTMP1_DEVICE(JI,JJ,JK) * ZFLXZ(JI,JJ,JK)
+ END DO
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZA(:,:,:) = PBETA(:,:,:) * ZTMP3_DEVICE(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ ZA(JI,JJ,JK) = PBETA(JI,JJ,JK) * ZTMP3_DEVICE(JI,JJ,JK)
+ END DO
+ !$acc end kernels
#endif
+ !$acc kernels
ZA(:,:,IKB) = PBETA(:,:,IKB) * PEMOIST(:,:,IKB) * &
0.5 * ( ZFLXZ (:,:,IKB) + ZFLXZ (:,:,IKB+KKL) )
PTP(:,:,:) = PTP(:,:,:) + ZA(:,:,:)
@@ -1238,8 +1292,12 @@ IF (KRR /= 0) THEN
#else
CALL MZM_DEVICE(PEMOIST,ZTMP1_DEVICE)
!$acc kernels
- PWTHV(:,:,:) = PWTHV(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
+ DO CONCURRENT ( JI=1:JIU,JJ=1:JJU,JK=1:JKU)
+ PWTHV(JI,JJ,JK) = PWTHV(JI,JJ,JK) + ZTMP1_DEVICE(JI,JJ,JK) * ZFLXZ(JI,JJ,JK)
+ END DO
+ !$acc end kernels
#endif
+ !$acc kernels
PWTHV(:,:,IKB) = PWTHV(:,:,IKB) + PEMOIST(:,:,IKB) * ZFLXZ(:,:,IKB)
!$acc end kernels
!
@@ -1455,6 +1513,11 @@ end if
!$acc end data
+#ifdef MNH_OPENACC
+CALL MNH_REL_ZT3D(IZA, IZFLXZ, IZSOURCE, IZKEFF, IZF, IZDFDDTDZ, IZDFDDRDZ, IZ3RDMOMENT, &
+ IZTMP1_DEVICE, IZTMP2_DEVICE, IZTMP3_DEVICE, IZTMP4_DEVICE)
+#endif
+
!$acc end data
!----------------------------------------------------------------------------
--
GitLab