diff --git a/src/MNH/advection_metsv.f90 b/src/MNH/advection_metsv.f90
index a6ca733c2cfc8334fa1f09b4423d5152e57adbe4..1f1fd7500428cee90002ec948c8dbf31e019f6da 100644
--- a/src/MNH/advection_metsv.f90
+++ b/src/MNH/advection_metsv.f90
@@ -23,16 +23,16 @@ USE MODD_TYPE_DATE, ONLY: DATE_TIME
LOGICAL, INTENT(IN) :: OCLOSE_OUT ! switch for syncronous
! file opening
TYPE(TFILEDATA), INTENT(IN) :: TPFILE ! Output file
-CHARACTER(LEN=6), INTENT(IN) :: HMET_ADV_SCHEME, & ! Control of the
- HSV_ADV_SCHEME, & ! scheme applied
+CHARACTER(LEN=6), INTENT(IN) :: HMET_ADV_SCHEME, & ! Control of the
+ HSV_ADV_SCHEME, & ! scheme applied
HUVW_ADV_SCHEME
-CHARACTER (LEN=4), INTENT(IN) :: HCLOUD ! Kind of cloud parameterization
+CHARACTER (LEN=4), INTENT(IN) :: HCLOUD ! Kind of cloud parameterization
!
INTEGER, INTENT(INOUT):: KSPLIT ! Number of time splitting
! for PPM advection
LOGICAL, INTENT(IN) :: OSPLIT_CFL ! flag to automatically chose number of iterations
REAL, INTENT(IN) :: PSPLIT_CFL ! maximum CFL to automatically chose number of iterations
-LOGICAL, INTENT(IN) :: OCFL_WRIT ! flag to write CFL fields in output files
+LOGICAL, INTENT(IN) :: OCFL_WRIT ! flag to write CFL fields in output files
!
CHARACTER(LEN=4),DIMENSION(2),INTENT(IN):: HLBCX, HLBCY ! X- and Y-direc LBC
!
@@ -44,7 +44,7 @@ REAL, INTENT(IN) :: PTSTEP
!
REAL, DIMENSION(:,:,:), INTENT(IN) :: PUT , PVT , PWT
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTHT, PTKET, PRHODJ
-REAL, DIMENSION(:,:,:), INTENT(IN) :: PPABST
+REAL, DIMENSION(:,:,:), INTENT(IN) :: PPABST
REAL, DIMENSION(:,:,:,:), INTENT(IN) :: PRT , PSVT
! Variables at t
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTHVREF ! Virtual Temperature
@@ -193,16 +193,16 @@ IMPLICIT NONE
LOGICAL, INTENT(IN) :: OCLOSE_OUT ! switch for synchronous
! file opening
TYPE(TFILEDATA), INTENT(IN) :: TPFILE ! Output file
-CHARACTER(LEN=6), INTENT(IN) :: HMET_ADV_SCHEME, & ! Control of the
- HSV_ADV_SCHEME, & ! scheme applied
+CHARACTER(LEN=6), INTENT(IN) :: HMET_ADV_SCHEME, & ! Control of the
+ HSV_ADV_SCHEME, & ! scheme applied
HUVW_ADV_SCHEME
-CHARACTER (LEN=4), INTENT(IN) :: HCLOUD ! Kind of cloud parameterization
+CHARACTER (LEN=4), INTENT(IN) :: HCLOUD ! Kind of cloud parameterization
!
INTEGER, INTENT(INOUT):: KSPLIT ! Number of time splitting
! for PPM advection
LOGICAL, INTENT(IN) :: OSPLIT_CFL ! flag to automatically chose number of iterations
REAL, INTENT(IN) :: PSPLIT_CFL ! maximum CFL to automatically chose number of iterations
-LOGICAL, INTENT(IN) :: OCFL_WRIT ! flag to write CFL fields in output files
+LOGICAL, INTENT(IN) :: OCFL_WRIT ! flag to write CFL fields in output files
!
CHARACTER(LEN=4),DIMENSION(2),INTENT(IN):: HLBCX, HLBCY ! X- and Y-direc LBC
!
@@ -418,8 +418,8 @@ IF(LBLOWSNOW) THEN ! Put 2D Canopy blowing snow variables into a 3D array for
#ifdef MNH_OPENACC
call Print_msg( NVERB_ERROR, 'GEN', 'ADVECTION_METSV', 'OpenACC: LBLOWSNOW not yet implemented' )
#endif
- ZSNWC_INIT = 0.
- ZRSNWCS = 0.
+ ZSNWC_INIT(:,:,:,:) = 0.
+ ZRSNWCS(:,:,:,:) = 0.
DO JSV=1,(NBLOWSNOW_2D)
ZSNWC_INIT(:,:,IKB,JSV) = XSNWCANO(:,:,JSV)
@@ -465,22 +465,22 @@ IF (.NOT. L1D) THEN
IF (.NOT. L2D) THEN
ZCFL(:,:,:) = SQRT(ZCFLU(:,:,:)**2+ZCFLV(:,:,:)**2+ZCFLW(:,:,:)**2)
ELSE
- ZCFL = SQRT(ZCFLU(:,:,:)**2+ZCFLW(:,:,:)**2)
+ ZCFL(:,:,:) = SQRT(ZCFLU(:,:,:)**2+ZCFLW(:,:,:)**2)
END IF
#else
IF (.NOT. L2D) THEN
ZCFL(:,:,:) = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLV(:,:,:))+BR_P2(ZCFLW(:,:,:)))
ELSE
- ZCFL = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLW(:,:,:)))
+ ZCFL(:,:,:) = SQRT(BR_P2(ZCFLU(:,:,:))+BR_P2(ZCFLW(:,:,:)))
END IF
#endif
ELSE
- ZCFLU = 0.0 ; ZCFLV = 0.0 ; ZCFLW = 0.0
+ ZCFLU(:,:,:) = 0.0 ; ZCFLV(:,:,:) = 0.0 ; ZCFLW(:,:,:) = 0.0
ZCFLW(IIB:IIE,IJB:IJE,:) = ABS(ZRWCPPM(IIB:IIE,IJB:IJE,:) * PTSTEP)
#ifndef MNH_BITREP
- ZCFL = SQRT(ZCFLW**2)
+ ZCFL(:,:,:) = SQRT(ZCFLW(:,:,:)**2)
#else
- ZCFL = SQRT(BR_P2(ZCFLW))
+ ZCFL(:,:,:) = SQRT(BR_P2(ZCFLW(:,:,:)))
#endif
END IF
!$acc end kernels
@@ -623,9 +623,9 @@ ZTSTEP_PPM = PTSTEP / REAL(KSPLIT)
!* 2.4 normalized contravariant components for splitted PPM time-step
!
!$acc kernels
-ZRUCPPM = ZRUCPPM*ZTSTEP_PPM
-ZRVCPPM = ZRVCPPM*ZTSTEP_PPM
-ZRWCPPM = ZRWCPPM*ZTSTEP_PPM
+ZRUCPPM(:,:,:) = ZRUCPPM(:,:,:)*ZTSTEP_PPM
+ZRVCPPM(:,:,:) = ZRVCPPM(:,:,:)*ZTSTEP_PPM
+ZRWCPPM(:,:,:) = ZRWCPPM(:,:,:)*ZTSTEP_PPM
!
!
!-------------------------------------------------------------------------------
@@ -648,7 +648,7 @@ DO JSV = 1, KSV
END DO
!$acc end kernels
IF(LBLOWSNOW) THEN
- DO JSV = 1, (NBLOWSNOW_2D)
+ DO JSV = 1, (NBLOWSNOW_2D)
ZRSNWCS_OTHER(:,:,:,JSV) = ZRSNWCS(:,:,:,JSV) - ZSNWC_INIT(:,:,:,JSV) * PRHODJ / PTSTEP
END DO
ENDIF
@@ -676,7 +676,7 @@ DO JSV = 1, KSV
END DO
#endif
IF(LBLOWSNOW) THEN
- DO JSV = 1, (NBLOWSNOW_2D)
+ DO JSV = 1, (NBLOWSNOW_2D)
CALL ADV_BOUNDARIES (HLBCX, HLBCY, ZRSNWCS_OTHER(:,:,:,JSV))
END DO
END IF
@@ -722,7 +722,7 @@ IF(LBLOWSNOW) THEN
ZSNWC(:,:,:,JSV) = ZRSNWCS(:,:,:,JSV)* PTSTEP/ PRHODJ
CALL ADV_BOUNDARIES (HLBCX, HLBCY, ZSNWC(:,:,:,JSV))
END DO
- ZSNWC_INIT=ZSNWC
+ ZSNWC_INIT(:,:,:,:)=ZSNWC(:,:,:,:)
ENDIF
!
!* time splitting loop
@@ -736,8 +736,8 @@ DO JSPL=1,KSPLIT
IF (LNEUTRAL) THEN
!Must be done in a kernels region
!$acc kernels
- ZTH=ZTH-PTHVREF !* To be removed with the new PPM scheme ?
- !$acc end kernels
+ ZTH(:,:,:)=ZTH(:,:,:)-PTHVREF(:,:,:) !* To be removed with the new PPM scheme ?
+!$acc end kernels
END IF
CALL PPM_MET (HLBCX,HLBCY, KRR, TPDTCUR, ZRUCPPM, ZRVCPPM, ZRWCPPM, PTSTEP,ZTSTEP_PPM, &
PRHODJ, ZRHOX1, ZRHOX2, ZRHOY1, ZRHOY2, ZRHOZ1, ZRHOZ2, &
@@ -745,8 +745,8 @@ DO JSPL=1,KSPLIT
IF (LNEUTRAL) THEN
!Must be done in a kernels region
!$acc kernels
- ZTH=ZTH+PTHVREF !* To be removed with the new PPM scheme ?
- !$acc end kernels
+ ZTH(:,:,:) = ZTH(:,:,:) + PTHVREF(:,:,:) !* To be removed with the new PPM scheme ?
+!$acc end kernels
END IF
!
CALL PPM_SCALAR (HLBCX,HLBCY, KSV, TPDTCUR, ZRUCPPM, ZRVCPPM, ZRWCPPM, PTSTEP, &
@@ -795,7 +795,7 @@ DO JSPL=1,KSPLIT
CALL ADV_BOUNDARIES (HLBCX, HLBCY, ZSV(:,:,:,JSV), PSVT(:,:,:,JSV))
END DO
#else
- CALL ADV_BOUNDARIES_DEVICE (HLBCX, HLBCY, ZTH, PTHT )
+ CALL ADV_BOUNDARIES_DEVICE (HLBCX, HLBCY, ZTH, PTHT )
IF (GTKE) CALL ADV_BOUNDARIES_DEVICE (HLBCX, HLBCY, ZTKE, PTKET)
DO JR = 1, KRR
CALL ADV_BOUNDARIES_DEVICE (HLBCX, HLBCY, ZR(:,:,:,JR), PRT(:,:,:,JR))
@@ -819,7 +819,7 @@ DO JSPL=1,KSPLIT
ZRSNWCS(:,:,:,:) = ZRSNWCS(:,:,:,:) + ZRSNWCS_PPM (:,:,:,:) / KSPLIT
! Guesses of the field inside the time splitting loop
DO JSV = 1, ( NBLOWSNOW_2D)
- ZSNWC(:,:,:,JSV) = ZSNWC(:,:,:,JSV) + ZRSNWCS_PPM(:,:,:,JSV)*ZTSTEP_PPM/ PRHODJ(:,:,:)
+ ZSNWC(:,:,:,JSV) = ZSNWC(:,:,:,JSV) + ZRSNWCS_PPM(:,:,:,JSV)*ZTSTEP_PPM/ PRHODJ(:,:,:)
END DO
! Top and bottom Boundaries and LBC for the guesses
@@ -864,7 +864,7 @@ END IF
!
IF(LBLOWSNOW) THEN
- DO JSV=1,(NBLOWSNOW_2D)
+ DO JSV=1,(NBLOWSNOW_2D)
DO JI=1,SIZE(PSVT,1)
DO JJ=1,SIZE(PSVT,2)
XRSNWCANOS(JI,JJ,JSV) = SUM(ZRSNWCS(JI,JJ,IKB:IKE,JSV))
diff --git a/src/MNH/gradient_u.f90 b/src/MNH/gradient_u.f90
index 8f1992b2cd25c2ce22fba2ec189bcd3022250292..0adafdab8283d6d583010b20bb6ae06f3507ae23 100644
--- a/src/MNH/gradient_u.f90
+++ b/src/MNH/gradient_u.f90
@@ -246,22 +246,22 @@ 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
+ ZTMP3_DEVICE(:,:,:) = PDZX(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE / PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KL,ZTMP3_DEVICE,ZTMP2_DEVICE)
CALL MXF_DEVICE(PDXX,ZTMP3_DEVICE)
!$acc kernels
- PGX_U_M_DEVICE(:,:,:)= ( ZTMP1_DEVICE - ZTMP2_DEVICE ) / ZTMP3_DEVICE
+ PGX_U_M_DEVICE(:,:,:)= ( ZTMP1_DEVICE(:,:,:) - ZTMP2_DEVICE(:,:,:) ) / ZTMP3_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL DXF_DEVICE(PA,ZTMP1_DEVICE)
CALL MXF_DEVICE(PDXX,ZTMP2_DEVICE)
!$acc kernels
- PGX_U_M_DEVICE(:,:,:)= ZTMP1_DEVICE / ZTMP2_DEVICE
+ PGX_U_M_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
@@ -423,24 +423,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
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYM_DEVICE(ZTMP3_DEVICE,ZTMP1_DEVICE)
CALL MXM_DEVICE(PDZY,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$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
+ PGY_U_UV_DEVICE(:,:,:)= ( ZTMP1_DEVICE(:,:,:) - ZTMP2_DEVICE(:,:,:) ) / ZTMP3_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL DYM_DEVICE(PA,ZTMP1_DEVICE)
CALL MXM_DEVICE(PDYY,ZTMP2_DEVICE)
!$acc kernels
- PGY_U_UV_DEVICE(:,:,:)= ZTMP1_DEVICE / ZTMP2_DEVICE
+ PGY_U_UV_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
@@ -582,7 +582,7 @@ allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP1_DEVICE)
CALL MXM_DEVICE(PDZZ,ZTMP2_DEVICE)
!$acc kernels
-PGZ_U_UW_DEVICE(:,:,:)= ZTMP1_DEVICE / ZTMP2_DEVICE
+PGZ_U_UW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
!$acc end data
diff --git a/src/MNH/gradient_v.f90 b/src/MNH/gradient_v.f90
index 95c3c0f07e294dffdb9ae6cdd733c6e57b47b200..40fefe5fe0879b3f03a19a1772ed70b02cea25fb 100644
--- a/src/MNH/gradient_v.f90
+++ b/src/MNH/gradient_v.f90
@@ -248,22 +248,22 @@ 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
+ ZTMP3_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE/PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)/PDZZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KL,ZTMP3_DEVICE,ZTMP2_DEVICE)
CALL MYF_DEVICE(PDYY,ZTMP3_DEVICE)
!$acc kernels
- PGY_V_M_DEVICE(:,:,:)= (ZTMP1_DEVICE - ZTMP2_DEVICE) / ZTMP3_DEVICE
+ PGY_V_M_DEVICE(:,:,:)= (ZTMP1_DEVICE(:,:,:) - ZTMP2_DEVICE(:,:,:)) / ZTMP3_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL DYF_DEVICE(PA,ZTMP1_DEVICE)
CALL MYF_DEVICE(PDYY,ZTMP2_DEVICE)
!$acc kernels
- PGY_V_M_DEVICE(:,:,:)= ZTMP1_DEVICE / ZTMP2_DEVICE
+ PGY_V_M_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
@@ -427,23 +427,23 @@ IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PDZZ,ZTMP2_DEVICE)
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP3_DEVICE)
!$acc kernels
- ZTMP4_DEVICE = ZTMP3_DEVICE / ZTMP2_DEVICE
+ ZTMP4_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXM_DEVICE(ZTMP4_DEVICE,ZTMP2_DEVICE)
CALL MYM_DEVICE(PDZX,ZTMP3_DEVICE)
!$acc kernels
- ZTMP4_DEVICE = ZTMP2_DEVICE *ZTMP3_DEVICE
+ ZTMP4_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) *ZTMP3_DEVICE(:,:,:)
!$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
+ PGX_V_UV_DEVICE(:,:,:)= ( ZTMP1_DEVICE(:,:,:) - ZTMP2_DEVICE(:,:,:) ) / ZTMP3_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL DXM_DEVICE(PA,ZTMP1_DEVICE)
CALL MYM_DEVICE(PDXX,ZTMP2_DEVICE)
!$acc kernels
- PGX_V_UV_DEVICE(:,:,:)= ZTMP1_DEVICE / ZTMP2_DEVICE
+ PGX_V_UV_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
@@ -585,7 +585,7 @@ allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
CALL DZM_DEVICE(KKA,KKU,KL,PA,ZTMP1_DEVICE)
CALL MYM_DEVICE(PDZZ,ZTMP2_DEVICE)
!$acc kernels
-PGZ_V_VW_DEVICE(:,:,:)= ZTMP1_DEVICE / ZTMP2_DEVICE
+PGZ_V_VW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)
!$acc end kernels
!$acc end data
diff --git a/src/MNH/gradient_w.f90 b/src/MNH/gradient_w.f90
index 70fda231043e16fb2b0c561c604c56dbd87d77e2..c73b40743e5947a3f826881c45bf3c94c8da2abb 100644
--- a/src/MNH/gradient_w.f90
+++ b/src/MNH/gradient_w.f90
@@ -222,7 +222,7 @@ allocate( ztmp2_device(size( pa, 1 ), size( pa, 2 ), size( pa, 3 ) ) )
CALL DZF_DEVICE(KKA,KKU,KL,PA(:,:,:),ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KL,PDZZ(:,:,:),ZTMP2_DEVICE)
!$acc kernels
-PGZ_W_M_DEVICE(:,:,:)= ZTMP1_DEVICE/ZTMP2_DEVICE
+PGZ_W_M_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:)
!$acc end kernels
!$acc end data
@@ -379,15 +379,15 @@ IF (.NOT. LFLAT) THEN
CALL MZM_DEVICE(PDXX(:,:,:),ZTMP4_DEVICE)
CALL MXM_DEVICE(PDZZ(:,:,:),ZTMP5_DEVICE)
!$acc kernels
- PGX_W_UW_DEVICE(:,:,:)= ZTMP1_DEVICE/ZTMP2_DEVICE &
- -ZTMP3_DEVICE*PDZX(:,:,:) &
- /( ZTMP4_DEVICE*ZTMP5_DEVICE )
+ PGX_W_UW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:) &
+ -ZTMP3_DEVICE(:,:,:)*PDZX(:,:,:) &
+ /( ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:) )
!$acc end kernels
ELSE
CALL DXM_DEVICE(PA(:,:,:),ZTMP1_DEVICE)
CALL MZM_DEVICE(PDXX(:,:,:),ZTMP2_DEVICE)
!$acc kernels
- PGX_W_UW_DEVICE(:,:,:)= ZTMP1_DEVICE/ZTMP2_DEVICE
+ PGX_W_UW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
@@ -545,15 +545,15 @@ IF (.NOT. LFLAT) THEN
CALL MZM_DEVICE(PDYY(:,:,:),ZTMP4_DEVICE)
CALL MYM_DEVICE(PDZZ(:,:,:),ZTMP5_DEVICE)
!$acc kernels
- PGY_W_VW_DEVICE(:,:,:)= ZTMP1_DEVICE/ZTMP2_DEVICE &
- -ZTMP3_DEVICE*PDZY(:,:,:) &
- /( ZTMP4_DEVICE*ZTMP5_DEVICE )
+ PGY_W_VW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:) &
+ -ZTMP3_DEVICE(:,:,:)*PDZY(:,:,:) &
+ /( ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:) )
!$acc end kernels
ELSE
CALL DYM_DEVICE(PA(:,:,:),ZTMP1_DEVICE)
CALL MZM_DEVICE(PDYY(:,:,:),ZTMP2_DEVICE)
!$acc kernels
- PGY_W_VW_DEVICE(:,:,:)= ZTMP1_DEVICE/ZTMP2_DEVICE
+ PGY_W_VW_DEVICE(:,:,:)= ZTMP1_DEVICE(:,:,:)/ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
diff --git a/src/MNH/modeln.f90 b/src/MNH/modeln.f90
index 54636764ba583fd27a551b26f06caed5a35390a7..e899bd8643c90b18400a35843c5a05231f528c84 100644
--- a/src/MNH/modeln.f90
+++ b/src/MNH/modeln.f90
@@ -1762,9 +1762,9 @@ IF (CCLOUD /= 'NONE' .AND. CELEC == 'NONE') THEN
ZWT_ACT_NUC(:,:,:) = 0.
END IF
!
- XRTHS_CLD = XRTHS
- XRRS_CLD = XRRS
- XRSVS_CLD = XRSVS
+ XRTHS_CLD(:, :, : ) = XRTHS(:, :, : )
+ XRRS_CLD (:, :, :, : ) = XRRS(:, :, :, : )
+ XRSVS_CLD(:, :, :, : ) = XRSVS(:, :, :, : )
!$acc data present(XRHODJ) &
!$acc & copyin (NRR, LSEDIC, CSUBG_AUCV, XTSTEP, KWARM, &
!$acc & XZZ, XRHODREF, XEXNREF, ZPABST, XTHT, XSIGS, VSIGQSAT, XMFCONV, XTHM, XPABSM, &
@@ -1823,9 +1823,9 @@ IF (CCLOUD /= 'NONE' .AND. CELEC == 'NONE') THEN
XINDEP, XSUPSAT, XNACT, XNPRO,XSSPRO, XRAINFR )
END IF
!$acc end data
- XRTHS_CLD = XRTHS - XRTHS_CLD
- XRRS_CLD = XRRS - XRRS_CLD
- XRSVS_CLD = XRSVS - XRSVS_CLD
+ XRTHS_CLD(:, :, : ) = XRTHS(:, :, : ) - XRTHS_CLD(:, :, : )
+ XRRS_CLD (:, :, :, : ) = XRRS (:, :, :, : ) - XRRS_CLD (:, :, :, : )
+ XRSVS_CLD(:, :, :, : ) = XRSVS(:, :, :, : ) - XRSVS_CLD(:, :, :, : )
!
IF (CCLOUD /= 'REVE' ) THEN
XACPRR = XACPRR + XINPRR * XTSTEP
diff --git a/src/MNH/tke_eps_sources.f90 b/src/MNH/tke_eps_sources.f90
index ea3497e30c3ee7b1d65ac7f8692e155a5db5933a..d56af95657364365e909ec206719181ede476157 100644
--- a/src/MNH/tke_eps_sources.f90
+++ b/src/MNH/tke_eps_sources.f90
@@ -340,9 +340,9 @@ ZKEFF(:,:,:) = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
! Complete the sources of TKE with the horizontal turbulent explicit transport
!
IF (HTURBDIM=='3DIM') THEN
- PTR=PTRH
+ PTR(:,:,:) = PTRH(:,:,:)
ELSE
- PTR=0.
+ PTR(:,:,:) = 0.
END IF
!
!
@@ -371,18 +371,18 @@ ZSOURCE(:,:,:) = PRTKES(:,:,:) / PRHODJ(:,:,:) + PRTKESM(:,:,:) / PRHODJ(:,:,:
#ifndef MNH_OPENACC
ZA(:,:,:) = - PTSTEP * XCET * &
#ifndef MNH_BITREP
- MZM(KKA,KKU,KKL,ZKEFF) * MZM(KKA,KKU,KKL,PRHODJ) / PDZZ**2
+ MZM(KKA,KKU,KKL,ZKEFF) * MZM(KKA,KKU,KKL,PRHODJ) / PDZZ(:,:,:)**2
#else
- MZM(KKA,KKU,KKL,ZKEFF) * MZM(KKA,KKU,KKL,PRHODJ) / BR_P2(PDZZ)
+ MZM(KKA,KKU,KKL,ZKEFF) * MZM(KKA,KKU,KKL,PRHODJ) / BR_P2(PDZZ(:,:,:))
#endif
#else
CALL MZM_DEVICE(ZKEFF, ZTMP1_DEVICE) !Warning: re-used later
CALL MZM_DEVICE(PRHODJ,ZTMP2_DEVICE) !Warning: re-used later
!$acc kernels
#ifndef MNH_BITREP
-ZA(:,:,:) = - PTSTEP * XCET * ZTMP1_DEVICE * ZTMP2_DEVICE / PDZZ**2
+ZA(:,:,:) = - PTSTEP * XCET * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)**2
#else
-ZA(:,:,:) = - PTSTEP * XCET * ZTMP1_DEVICE * ZTMP2_DEVICE / BR_P2(PDZZ)
+ZA(:,:,:) = - PTSTEP * XCET * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:) / BR_P2(PDZZ(:,:,:))
#endif
!$acc end kernels
#endif
@@ -395,7 +395,7 @@ CALL TRIDIAG_TKE(KKA,KKU,KKL,PTKEM,ZA,PTSTEP,PEXPL,PIMPL,PRHODJ,&
CALL GET_HALO(ZRES)
#else
!$acc kernels
-ZTMP3_DEVICE = PTSTEP*ZFLX
+ZTMP3_DEVICE(:,:,:) = PTSTEP*ZFLX(:,:,:)
!$acc end kernels
CALL TRIDIAG_TKE(KKA,KKU,KKL,PTKEM,ZA,PTSTEP,PEXPL,PIMPL,PRHODJ,&
& ZSOURCE,ZTMP3_DEVICE,ZRES)
@@ -431,14 +431,14 @@ IF ( LLES_CALL .OR. &
!
#ifndef MNH_OPENACC
ZFLX(:,:,:) = - XCET * MZM(KKA,KKU,KKL,ZKEFF) * &
- DZM(KKA,KKU,KKL,PIMPL * ZRES + PEXPL * PTKEM ) / PDZZ
+ DZM(KKA,KKU,KKL,PIMPL * ZRES + PEXPL * PTKEM ) / PDZZ(:,:,:)
#else
!$acc kernels
- ZTMP3_DEVICE = PIMPL * ZRES + PEXPL * PTKEM
+ ZTMP3_DEVICE(:,:,:) = PIMPL * ZRES(:,:,:) + PEXPL * PTKEM(:,:,:)
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZFLX(:,:,:) = - XCET * ZTMP1_DEVICE * ZTMP4_DEVICE / PDZZ !Re-use of ZTMP1_DEVICE
+ ZFLX(:,:,:) = - XCET * ZTMP1_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:) / PDZZ(:,:,:) !Re-use of ZTMP1_DEVICE
#endif
!
ZFLX(:,:,IKB) = 0.
@@ -449,11 +449,11 @@ IF ( LLES_CALL .OR. &
#ifndef MNH_OPENACC
PTR(:,:,:)= PTR - DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL,PRHODJ) * ZFLX / PDZZ ) /PRHODJ
#else
- ZTMP1_DEVICE = ZTMP2_DEVICE * ZFLX / PDZZ !Re-use of ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) * ZFLX(:,:,:) / PDZZ(:,:,:) !Re-use of ZTMP2_DEVICE
!$acc end kernels
CALL DZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- PTR(:,:,:)= PTR - ZTMP2_DEVICE / PRHODJ
+ PTR(:,:,:)= PTR(:,:,:) - ZTMP2_DEVICE(:,:,:) / PRHODJ(:,:,:)
!$acc end kernels
#endif
!
@@ -468,7 +468,7 @@ IF ( LLES_CALL .OR. &
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLX,ZTMP1_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WTke )
!$acc kernels
- ZTMP1_DEVICE = -PTR
+ ZTMP1_DEVICE(:,:,:) = -PTR(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ddz_WTke )
!$acc end data
diff --git a/src/MNH/turb.f90 b/src/MNH/turb.f90
index 8e7b61a10c55185dc3350f0974e3ea857f9bb3f0..3cf06ade78de9d27a03e5a00081163200e2b9a6d 100644
--- a/src/MNH/turb.f90
+++ b/src/MNH/turb.f90
@@ -765,7 +765,7 @@ SELECT CASE (HTURBLEN)
#ifdef MNH_OPENACC
call Print_msg( NVERB_FATAL, 'GEN', 'TURB', 'OpenACC: HTURBLEN=BL89 not yet implemented' )
#endif
- ZSHEAR=0.
+ ZSHEAR(:, :, : ) = 0.
CALL BL89(KKA,KKU,KKL,PZZ,PDZZ,PTHVREF,ZTHLM,KRR,ZRM,PTKET,ZSHEAR,PLEM)
!
!* 3.2 RM17 mixing length
@@ -1742,7 +1742,7 @@ ELSE
!* 3.1 BL89 mixing length
! ------------------
CASE ('BL89','RM17')
- ZSHEAR=0.
+ ZSHEAR(:, :, : ) = 0.
CALL BL89(KKA,KKU,KKL,PZZ,PDZZ,PTHVREF,ZTHLM,KRR,ZRM,PTKET,ZSHEAR,ZLM_CLOUD)
!
!* 3.2 Delta mixing length
diff --git a/src/MNH/turb_hor_thermo_corr.f90 b/src/MNH/turb_hor_thermo_corr.f90
index 4b26c5d5ad80b47e1114d825f145b095d9167554..19e163c6aaa7350c2c2d2dcce04e262b90024911 100644
--- a/src/MNH/turb_hor_thermo_corr.f90
+++ b/src/MNH/turb_hor_thermo_corr.f90
@@ -324,7 +324,7 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL GY_M_M_DEVICE(1,IKU,1,PTHLM,PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZFLX(:,:,:) = XCTV * PLM(:,:,:) * PLEPS(:,:,:) * ( ZTMP1_DEVICE**2 + ZTMP2_DEVICE**2 )
+ ZFLX(:,:,:) = XCTV * PLM(:,:,:) * PLEPS(:,:,:) * ( ZTMP1_DEVICE(:,:,:)**2 + ZTMP2_DEVICE(:,:,:)**2 )
#else
ZFLX(:,:,:) = XCTV * PLM(:,:,:) * PLEPS(:,:,:) * ( BR_P2(ZTMP1_DEVICE) + BR_P2(ZTMP2_DEVICE) )
#endif
@@ -333,7 +333,7 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL GX_M_M_DEVICE(1,IKU,1,PTHLM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZFLX(:,:,:) = XCTV * PLM(:,:,:) * PLEPS(:,:,:) * ZTMP1_DEVICE**2
+ ZFLX(:,:,:) = XCTV * PLM(:,:,:) * PLEPS(:,:,:) * ZTMP1_DEVICE(:,:,:)**2
#else
ZFLX(:,:,:) = XCTV * PLM(:,:,:) * PLEPS(:,:,:) * BR_P2(ZTMP1_DEVICE)
#endif
@@ -424,11 +424,11 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( ZFLX, X_LES_SUBGRID_Thl2, .TRUE. )
- CALL LES_MEAN_SUBGRID( MZF(1,IKU,1,PWM)*ZFLX, X_LES_RES_W_SBG_Thl2, .TRUE. )
- CALL LES_MEAN_SUBGRID( -2.*XCTD*SQRT(PTKEM)*ZFLX/PLEPS ,X_LES_SUBGRID_DISS_Thl2, .TRUE. )
+ CALL LES_MEAN_SUBGRID( MZF(1,IKU,1,PWM)*ZFLX(:,:,:), X_LES_RES_W_SBG_Thl2, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -2.*XCTD*SQRT(PTKEM(:,:,:))*ZFLX(:,:,:)/PLEPS(:,:,:) ,X_LES_SUBGRID_DISS_Thl2, .TRUE. )
ZA(:,:,:) = ETHETA(KRR,KRRI,PTHLM,PRM,PLOCPEXNM,PATHETA,PSRCM)
- CALL LES_MEAN_SUBGRID( ZA*ZFLX, X_LES_SUBGRID_ThlThv, .TRUE. )
- CALL LES_MEAN_SUBGRID( -XG/PTHVREF/3.*ZA*ZFLX, X_LES_SUBGRID_ThlPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_ThlThv, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_ThlPz, .TRUE. )
#else
!$acc data copy(X_LES_SUBGRID_Thl2,X_LES_RES_W_SBG_Thl2,X_LES_SUBGRID_DISS_Thl2, &
!$acc & X_LES_SUBGRID_ThlThv,X_LES_SUBGRID_ThlPz)
@@ -437,23 +437,23 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
!
CALL MZF_DEVICE(1,IKU,1,PWM, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_W_SBG_Thl2, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -2.*XCTD*SQRT(PTKEM)*ZFLX/PLEPS
+ ZTMP1_DEVICE(:,:,:) = -2.*XCTD*SQRT(PTKEM(:,:,:))*ZFLX(:,:,:)/PLEPS(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE ,X_LES_SUBGRID_DISS_Thl2, .TRUE. )
!
CALL ETHETA(KRR,KRRI,PTHLM,PRM,PLOCPEXNM,PATHETA,PSRCM, ZA(:,:,:))
!$acc kernels
- ZTMP1_DEVICE = ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlThv, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -XG/PTHVREF/3.*ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlPz, .TRUE. )
!
@@ -489,13 +489,13 @@ 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)
CALL GX_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP2_DEVICE)
!$acc kernels
- ZFLX(:,:,:)=PLM(:,:,:) * PLEPS(:,:,:) * (ZTMP1_DEVICE*ZTMP2_DEVICE) * (XCHT1+XCHT2)
+ ZFLX(:,:,:)=PLM(:,:,:) * PLEPS(:,:,:) * (ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)) * (XCHT1+XCHT2)
!$acc end kernels
END IF
#endif
@@ -622,13 +622,13 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( ZFLX, X_LES_SUBGRID_ThlRt, .TRUE. )
- CALL LES_MEAN_SUBGRID( MZF(1,IKU,1,PWM)*ZFLX, X_LES_RES_W_SBG_ThlRt, .TRUE. )
- CALL LES_MEAN_SUBGRID( -XCTD*SQRT(PTKEM)*ZFLX/PLEPS ,X_LES_SUBGRID_DISS_ThlRt, .TRUE. )
- CALL LES_MEAN_SUBGRID( ZA*ZFLX, X_LES_SUBGRID_RtThv, .TRUE. )
- CALL LES_MEAN_SUBGRID( -XG/PTHVREF/3.*ZA*ZFLX, X_LES_SUBGRID_RtPz,.TRUE.)
+ CALL LES_MEAN_SUBGRID( MZF(1,IKU,1,PWM)*ZFLX(:,:,:), X_LES_RES_W_SBG_ThlRt, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XCTD*SQRT(PTKEM(:,:,:))*ZFLX(:,:,:)/PLEPS(:,:,:) ,X_LES_SUBGRID_DISS_ThlRt, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_RtThv, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_RtPz,.TRUE.)
ZA(:,:,:) = EMOIST(KRR,KRRI,PTHLM,PRM,PLOCPEXNM,PAMOIST,PSRCM)
- CALL LES_MEAN_SUBGRID( ZA*ZFLX, X_LES_SUBGRID_ThlThv, .TRUE. )
- CALL LES_MEAN_SUBGRID( -XG/PTHVREF/3.*ZA*ZFLX, X_LES_SUBGRID_ThlPz,.TRUE.)
+ CALL LES_MEAN_SUBGRID( ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_ThlThv, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_ThlPz,.TRUE.)
#else
!$acc data copy(X_LES_SUBGRID_ThlRt,X_LES_RES_W_SBG_ThlRt,X_LES_SUBGRID_DISS_ThlRt, &
!$acc & X_LES_SUBGRID_RtThv,X_LES_SUBGRID_RtPz,X_LES_SUBGRID_ThlThv,X_LES_SUBGRID_ThlPz)
@@ -637,33 +637,33 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
!
CALL MZF_DEVICE(1,IKU,1,PWM,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_W_SBG_ThlRt, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -XCTD*SQRT(PTKEM)*ZFLX/PLEPS
+ ZTMP1_DEVICE(:,:,:) = -XCTD*SQRT(PTKEM(:,:,:))*ZFLX(:,:,:)/PLEPS(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE ,X_LES_SUBGRID_DISS_ThlRt, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtThv, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -XG/PTHVREF/3.*ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtPz,.TRUE.)
!
CALL EMOIST(KRR,KRRI,PTHLM,PRM,PLOCPEXNM,PAMOIST,PSRCM,ZA(:,:,:))
!$acc kernels
- ZTMP1_DEVICE = ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlThv, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -XG/PTHVREF/3.*ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlPz,.TRUE.)
!
@@ -700,7 +700,7 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL GY_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP2_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZFLX(:,:,:) = XCHV * PLM(:,:,:) * PLEPS(:,:,:) * ( ZTMP1_DEVICE**2 + ZTMP2_DEVICE**2 )
+ ZFLX(:,:,:) = XCHV * PLM(:,:,:) * PLEPS(:,:,:) * ( ZTMP1_DEVICE(:,:,:)**2 + ZTMP2_DEVICE(:,:,:)**2 )
#else
ZFLX(:,:,:) = XCHV * PLM(:,:,:) * PLEPS(:,:,:) * ( BR_P2(ZTMP1_DEVICE) + BR_P2(ZTMP2_DEVICE) )
#endif
@@ -709,7 +709,7 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL GX_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
- ZFLX(:,:,:) = XCHV * PLM(:,:,:) * PLEPS(:,:,:) * ZTMP1_DEVICE**2
+ ZFLX(:,:,:) = XCHV * PLM(:,:,:) * PLEPS(:,:,:) * ZTMP1_DEVICE(:,:,:)**2
#else
ZFLX(:,:,:) = XCHV * PLM(:,:,:) * PLEPS(:,:,:) * BR_P2(ZTMP1_DEVICE)
#endif
@@ -798,10 +798,10 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( ZFLX, X_LES_SUBGRID_Rt2, .TRUE. )
- CALL LES_MEAN_SUBGRID( MZF(1,IKU,1,PWM)*ZFLX, X_LES_RES_W_SBG_Rt2, .TRUE. )
- CALL LES_MEAN_SUBGRID( ZA*ZFLX, X_LES_SUBGRID_RtThv, .TRUE. )
- CALL LES_MEAN_SUBGRID( -XG/PTHVREF/3.*ZA*ZFLX, X_LES_SUBGRID_RtPz,.TRUE.)
- CALL LES_MEAN_SUBGRID( -2.*XCTD*SQRT(PTKEM)*ZFLX/PLEPS, X_LES_SUBGRID_DISS_Rt2, .TRUE. )
+ CALL LES_MEAN_SUBGRID( MZF(1,IKU,1,PWM)*ZFLX(:,:,:), X_LES_RES_W_SBG_Rt2, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_RtThv, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:), X_LES_SUBGRID_RtPz,.TRUE.)
+ CALL LES_MEAN_SUBGRID( -2.*XCTD*SQRT(PTKEM(:,:,:))*ZFLX(:,:,:)/PLEPS, X_LES_SUBGRID_DISS_Rt2, .TRUE. )
#else
!$acc data copy(X_LES_SUBGRID_Rt2,X_LES_RES_W_SBG_Rt2,X_LES_SUBGRID_RtThv, &
!$acc & X_LES_SUBGRID_RtPz,X_LES_SUBGRID_DISS_Rt2)
@@ -810,22 +810,22 @@ IF ( ( KRRL > 0 .AND. OSUBG_COND) .OR. ( OTURB_FLX .AND. OCLOSE_OUT ) &
!
CALL MZF_DEVICE(1,IKU,1,PWM,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_W_SBG_Rt2, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtThv, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -XG/PTHVREF/3.*ZA*ZFLX
+ ZTMP1_DEVICE(:,:,:) = -XG/PTHVREF(:,:,:)/3.*ZA(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtPz,.TRUE.)
!
!$acc kernels
- ZTMP1_DEVICE = -2.*XCTD*SQRT(PTKEM)*ZFLX/PLEPS
+ ZTMP1_DEVICE(:,:,:) = -2.*XCTD*SQRT(PTKEM(:,:,:))*ZFLX(:,:,:)/PLEPS(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_DISS_Rt2, .TRUE. )
!
diff --git a/src/MNH/turb_hor_thermo_flux.f90 b/src/MNH/turb_hor_thermo_flux.f90
index bdc9809ebdfe7c067bf301708d0eff81d295c254..80f98aea6e34cd47c5826f5421dd43272d253389 100644
--- a/src/MNH/turb_hor_thermo_flux.f90
+++ b/src/MNH/turb_hor_thermo_flux.f90
@@ -315,7 +315,7 @@ 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
+ZFLX(:,:,:) = -XCSHF * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
#endif
@@ -366,42 +366,42 @@ ZFLX(:,:,IKB-1:IKB-1) = 2. * MXM( SPREAD( PSFTHM(:,:)* PDIRCOSXW(:,:), 3,1) )
!
#ifndef MNH_OPENACC
IF (.NOT. LFLAT) THEN
- PRTHLS(:,:,:) = PRTHLS &
- - DXF( MXM(PRHODJ) * ZFLX * PINV_PDXX ) &
- + DZF(1,IKU,1, PMZM_PRHODJ *MXF(PDZX*(MZM(1,IKU,1,ZFLX * PINV_PDXX))) * PINV_PDZZ )
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) &
+ - DXF( MXM(PRHODJ) * ZFLX(:,:,:) * PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, PMZM_PRHODJ(:,:,:) *MXF(PDZX*(MZM(1,IKU,1,ZFLX(:,:,:) * PINV_PDXX(:,:,:)))) * PINV_PDZZ(:,:,:) )
ELSE
- PRTHLS(:,:,:) = PRTHLS - DXF( MXM(PRHODJ) * ZFLX * PINV_PDXX )
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) - DXF( MXM(PRHODJ) * ZFLX(:,:,:) * PINV_PDXX(:,:,:) )
END IF
#else
IF (.NOT. LFLAT) THEN
CALL MXM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDXX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE(ZTMP2_DEVICE, ZTMP3_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLX * PINV_PDXX
+ ZTMP2_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDXX(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PDZX*ZTMP4_DEVICE
+ ZTMP2_DEVICE(:,:,:) = PDZX(:,:,:)*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP2_DEVICE, ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PMZM_PRHODJ * ZTMP4_DEVICE * PINV_PDZZ
+ ZTMP2_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP4_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP2_DEVICE,ZTMP4_DEVICE )
!$acc kernels
- PRTHLS(:,:,:) = PRTHLS - ZTMP3_DEVICE + ZTMP4_DEVICE
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) - ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL MXM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDXX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE(ZTMP2_DEVICE, ZTMP3_DEVICE)
!$acc kernels
- PRTHLS(:,:,:) = PRTHLS - ZTMP3_DEVICE
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) - ZTMP3_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -411,38 +411,41 @@ END IF
#ifndef MNH_OPENACC
IF ( KRRL >= 1 ) THEN
IF (.NOT. LFLAT) THEN
- ZFLXC = 2.*( MXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX ) &
- +MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MXF( &
- PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) ) )&
+ ZFLXC(:,:,:) = 2.*( MXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:) ) &
+ +MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*MXF( &
+ PDZX*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) ) )&
)
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDXX ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MXF( PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) )&
- *PINV_PDZZ ) &
+ (- DXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )* &
+ MXF( PDZX*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * &
- (- DXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDXX ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MXF( PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) )&
- *PINV_PDZZ ) &
+ (- DXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )* &
+ MXF( PDZX*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDXX ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MXF( PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) )&
- *PINV_PDZZ ) &
+ (- DXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )* &
+ MXF( PDZX*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)
END IF
ELSE
- ZFLXC = 2.*MXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX )
+ ZFLXC(:,:,:) = 2.*MXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX )
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDXX )*(1.0-PFRAC_ICE(:,:,:))
+ DXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) )*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * &
- DXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDXX )*PFRAC_ICE(:,:,:)
+ DXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) )*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DXF( MXM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDXX )
+ DXF( MXM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) )
END IF
END IF
END IF
@@ -450,91 +453,91 @@ END IF
IF ( KRRL >= 1 ) THEN
IF (.NOT. LFLAT) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE( ZTMP1_DEVICE, ZTMP4_DEVICE )
CALL MXM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE *ZFLX
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) *ZFLX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = ZFLX*PINV_PDXX
+ ZTMP1_DEVICE(:,:,:) = ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL MZM_DEVICE( ZTMP1_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- ZTMP6_DEVICE = PDZX*ZTMP5_DEVICE
+ ZTMP6_DEVICE(:,:,:) = PDZX(:,:,:)*ZTMP5_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP6_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- ZTMP6_DEVICE = ZTMP4_DEVICE*ZTMP5_DEVICE
+ ZTMP6_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(1,IKU,1, ZTMP6_DEVICE,ZTMP7_DEVICE )
!$acc kernels
- ZFLXC = 2.*( ZTMP2_DEVICE +ZTMP7_DEVICE )
+ ZFLXC(:,:,:) = 2.*( ZTMP2_DEVICE(:,:,:) +ZTMP7_DEVICE(:,:,:) )
!$acc end kernels
IF ( KRRI >= 1 ) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MXM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP6_DEVICE = ZTMP2_DEVICE*ZFLX*PINV_PDXX
+ ZTMP6_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE( ZTMP6_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP4_DEVICE*ZTMP5_DEVICE*PINV_PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:)*PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP2_DEVICE + ZTMP4_DEVICE )*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * (- ZTMP2_DEVICE + ZTMP4_DEVICE )*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP2_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * (- ZTMP2_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MXM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE *ZFLX*PINV_PDXX
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) *ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE( ZTMP6_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP4_DEVICE*ZTMP5_DEVICE*PINV_PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:)*PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP2_DEVICE + ZTMP4_DEVICE )
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP2_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )
!$acc end kernels
END IF
ELSE
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MXM_DEVICE( ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLX
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZFLXC = 2.*ZTMP4_DEVICE
+ ZFLXC(:,:,:) = 2.*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
IF ( KRRI >= 1 ) THEN
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE*ZFLX*PINV_PDXX
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP2_DEVICE*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE(:,:,:)*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP2_DEVICE(:,:,:)*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE*ZFLX*PINV_PDXX
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -557,7 +560,7 @@ IF ( OCLOSE_OUT .AND. OTURB_FLX ) THEN
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
!$acc update self(ZFLX)
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -582,7 +585,7 @@ IF (KSPLT==1 .AND. LLES_CALL) THEN
CALL GX_W_UW_DEVICE(1,IKU,1,PWM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MZM_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP1_DEVICE)
CALL MZF_DEVICE(1,IKU,1,ZTMP1_DEVICE,ZTMP2_DEVICE)
@@ -591,14 +594,14 @@ IF (KSPLT==1 .AND. LLES_CALL) THEN
CALL GX_M_M_DEVICE(1,IKU,1,PTHLM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MXF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE,X_LES_RES_ddxa_Thl_SBG_UaThl , .TRUE. )
!
IF (KRR>=1) THEN
CALL GX_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE,X_LES_RES_ddxa_Rt_SBG_UaThl , .TRUE. )
END IF
@@ -635,49 +638,52 @@ IF (KRR/=0) THEN
!
IF (.NOT. LFLAT) THEN
PRRS(:,:,:,1) = PRRS(:,:,:,1) &
- - DXF( MXM(PRHODJ) * ZFLX * PINV_PDXX ) &
- + DZF(1,IKU,1, PMZM_PRHODJ *MXF(PDZX*(MZM(1,IKU,1,ZFLX * PINV_PDXX))) * PINV_PDZZ )
+ - DXF( MXM(PRHODJ) * ZFLX(:,:,:) * PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, PMZM_PRHODJ(:,:,:) *MXF(PDZX*(MZM(1,IKU,1,ZFLX * PINV_PDXX(:,:,:)))) * PINV_PDZZ(:,:,:) )
ELSE
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - DXF( MXM(PRHODJ) * ZFLX * PINV_PDXX )
+ PRRS(:,:,:,1) = PRRS(:,:,:,1) - DXF( MXM(PRHODJ) * ZFLX(:,:,:) * PINV_PDXX(:,:,:) )
END IF
!
! Compute the equivalent tendancy for Rc and Ri
!
IF ( KRRL >= 1 ) THEN
IF (.NOT. LFLAT) THEN
- ZFLXC = ZFLXC &
- + 2.*( MXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX ) &
- +MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MXF( &
- PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) ) )&
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) &
+ + 2.*( MXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:) ) &
+ +MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MXF( &
+ PDZX(:,:,:)*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) ) )&
)
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX*PINV_PDXX ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MXF( PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) )&
- *PINV_PDZZ ) &
+ (- DXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MXF( PDZX(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX*PINV_PDXX ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MXF( PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) )&
- *PINV_PDZZ ) &
+ (- DXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MXF( PDZX(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX*PINV_PDXX ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MXF( PDZX*(MZM(1,IKU,1, ZFLX*PINV_PDXX )) )&
- *PINV_PDZZ ) &
+ (- DXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MXF( PDZX(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDXX(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)
END IF
ELSE
- ZFLXC = ZFLXC + 2.*MXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX )
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) + 2.*MXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:) )
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX*PINV_PDXX )*(1.0-PFRAC_ICE(:,:,:))
+ DXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) )*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * &
- DXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX*PINV_PDXX )*PFRAC_ICE(:,:,:)
+ DXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) )*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DXF( MXM( PRHODJ*PAMOIST*PSRCM )*ZFLX*PINV_PDXX )
+ DXF( MXM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDXX(:,:,:) )
END IF
END IF
END IF
@@ -694,7 +700,7 @@ IF (KRR/=0) THEN
TZFIELD%NTYPE = TYPEREAL
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -723,7 +729,7 @@ 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
+ ZFLX(:,:,:) = -XCHF * ZTMP1_DEVICE * ZTMP2_DEVICE(:,:,:)
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
!
@@ -759,32 +765,32 @@ END IF
IF (.NOT. LFLAT) THEN
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDXX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = ZFLX * PINV_PDXX
+ ZTMP2_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDXX(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PDZX*ZTMP4_DEVICE
+ ZTMP2_DEVICE(:,:,:) = PDZX(:,:,:)*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP2_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = PMZM_PRHODJ * ZTMP4_DEVICE * PINV_PDZZ
+ ZTMP2_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP4_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP2_DEVICE, ZTMP4_DEVICE)
!$acc kernels
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE + ZTMP4_DEVICE
+ PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDXX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE
+ PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE(:,:,:)
!$acc end kernels
END IF
!
@@ -792,69 +798,69 @@ END IF
!
IF ( KRRL >= 1 ) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PAMOIST*PSRCM
- ZTMP2_DEVICE = ZFLX*PINV_PDXX
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:)
+ ZTMP2_DEVICE(:,:,:) = ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL MXM_DEVICE( ZTMP1_DEVICE, ZTMP8_DEVICE )
IF (.NOT. LFLAT) THEN
!$acc kernels
- ZTMP4_DEVICE = ZTMP8_DEVICE * ZFLX
+ ZTMP4_DEVICE(:,:,:) = ZTMP8_DEVICE(:,:,:) * ZFLX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP4_DEVICE, ZTMP3_DEVICE )
CALL MZM_DEVICE( ZTMP1_DEVICE, ZTMP4_DEVICE )
CALL MZM_DEVICE( ZTMP2_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- ZTMP6_DEVICE = PDZX*ZTMP5_DEVICE
+ ZTMP6_DEVICE(:,:,:) = PDZX(:,:,:)*ZTMP5_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP6_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- ZTMP6_DEVICE = ZTMP4_DEVICE*ZTMP5_DEVICE
+ ZTMP6_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(1,IKU,1, ZTMP6_DEVICE, ZTMP7_DEVICE )
!$acc kernels
- ZFLXC = ZFLXC + 2.*( ZTMP3_DEVICE + ZTMP7_DEVICE )
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) + 2.*( ZTMP3_DEVICE(:,:,:) + ZTMP7_DEVICE(:,:,:) )
!$acc end kernels
!
!
!$acc kernels
- ZTMP6_DEVICE = ZTMP4_DEVICE*ZTMP5_DEVICE*PINV_PDZZ
+ ZTMP6_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:)*PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP6_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP4_DEVICE = ZTMP8_DEVICE * ZFLX*PINV_PDXX
+ ZTMP4_DEVICE(:,:,:) = ZTMP8_DEVICE(:,:,:) * ZFLX(:,:,:)*PINV_PDXX(:,:,:)
!$acc end kernels
CALL DXF_DEVICE(ZTMP4_DEVICE, ZTMP5_DEVICE)
!
IF ( KRRI >= 1 ) THEN
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP5_DEVICE+ ZTMP3_DEVICE)*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP5_DEVICE+ ZTMP3_DEVICE)*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP5_DEVICE(:,:,:)+ ZTMP3_DEVICE(:,:,:))*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP5_DEVICE(:,:,:)+ ZTMP3_DEVICE(:,:,:))*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP5_DEVICE + ZTMP3_DEVICE)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP5_DEVICE(:,:,:) + ZTMP3_DEVICE(:,:,:))
!$acc end kernels
END IF
ELSE
!$acc kernels
- ZTMP4_DEVICE = ZTMP8_DEVICE*ZTMP2_DEVICE
+ ZTMP4_DEVICE(:,:,:) = ZTMP8_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL DXF_DEVICE(ZTMP4_DEVICE, ZTMP5_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP8_DEVICE*ZFLX
+ ZTMP3_DEVICE(:,:,:) = ZTMP8_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZFLXC = ZFLXC + 2.*ZTMP4_DEVICE
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) + 2.*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
IF ( KRRI >= 1 ) THEN
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP5_DEVICE*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP5_DEVICE*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP5_DEVICE(:,:,:)*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP5_DEVICE(:,:,:)*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP5_DEVICE
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP5_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -873,7 +879,7 @@ END IF
TZFIELD%NTYPE = TYPEREAL
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -888,7 +894,7 @@ END IF
CALL GX_W_UW_DEVICE(1,IKU,1,PWM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MZM_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL MZF_DEVICE(1,IKU,1,ZTMP4_DEVICE,ZTMP3_DEVICE)
@@ -897,14 +903,14 @@ END IF
CALL GX_M_M_DEVICE(1,IKU,1,PTHLM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MXF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaRt , .TRUE. )
!
CALL GX_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MXF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Rt_SBG_UaRt , .TRUE. )
!
@@ -995,11 +1001,11 @@ ZFLX(:,:,IKB-1:IKB-1) = 2. * MYM( SPREAD( PSFTHM(:,:)* PDIRCOSYW(:,:), 3,1) ) &
!
IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
- PRTHLS(:,:,:) = PRTHLS &
- - DYF( MYM(PRHODJ) * ZFLX * PINV_PDYY ) &
- + DZF(1,IKU,1, PMZM_PRHODJ *MYF(PDZY*(MZM(1,IKU,1,ZFLX * PINV_PDYY))) * PINV_PDZZ )
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) &
+ - DYF( MYM(PRHODJ) * ZFLX(:,:,:) * PINV_PDYY(:,:,:) ) &
+ + DZF(1,IKU,1, PMZM_PRHODJ *MYF(PDZY(:,:,:)*(MZM(1,IKU,1,ZFLX(:,:,:) * PINV_PDYY(:,:,:)))) * PINV_PDZZ(:,:,:) )
ELSE
- PRTHLS(:,:,:) = PRTHLS - DYF( MYM(PRHODJ) * ZFLX * PINV_PDYY )
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) - DYF( MYM(PRHODJ) * ZFLX(:,:,:) * PINV_PDYY(:,:,:) )
END IF
END IF
!
@@ -1008,38 +1014,41 @@ END IF
!IF ( OSUBG_COND .AND. KRRL > 0 .AND. .NOT. L2D) THEN
IF ( KRRL >= 1 .AND. .NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
- ZFLXC = 2.*( MYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX ) &
- +MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MYF( &
- PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) ) )&
+ ZFLXC(:,:,:) = 2.*( MYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:) ) &
+ +MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*MYF( &
+ PDZY(:,:,:)*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) ) )&
)
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDYY ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MYF( PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) )&
- *PINV_PDZZ ) &
+ (- DYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDYY(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*MYF( PDZY(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * &
- (- DYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDYY ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MYF( PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) )&
- *PINV_PDZZ ) &
+ (- DYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDYY(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*MYF( PDZY(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDYY ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PATHETA*PSRCM )*MYF( PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) )&
- *PINV_PDZZ ) &
+ (- DYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDYY(:,:,:) ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*MYF( PDZY(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) )&
+ *PINV_PDZZ(:,:,:) ) &
)
END IF
ELSE
- ZFLXC = 2.*MYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX )
+ ZFLXC(:,:,:) = 2.*MYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:) )
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDYY )*(1.0-PFRAC_ICE(:,:,:))
+ DYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDYY(:,:,:) )*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * &
- DYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDYY )*PFRAC_ICE(:,:,:)
+ DYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDYY(:,:,:) )*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DYF( MYM( PRHODJ*PATHETA*PSRCM )*ZFLX*PINV_PDYY )
+ DYF( MYM( PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)*PINV_PDYY(:,:,:) )
END IF
END IF
END IF
@@ -1059,7 +1068,7 @@ IF ( OCLOSE_OUT .AND. OTURB_FLX ) THEN
TZFIELD%NTYPE = TYPEREAL
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -1080,7 +1089,7 @@ 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
+ ZFLX(:,:,:) = -XCSHF * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
ELSE
@@ -1124,32 +1133,32 @@ IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDYY
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZFLX * PINV_PDYY
+ ZTMP1_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = PDZY*ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = PMZM_PRHODJ * ZTMP2_DEVICE * PINV_PDZZ
+ ZTMP1_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP2_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- PRTHLS(:,:,:) = PRTHLS - ZTMP3_DEVICE + ZTMP2_DEVICE
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) - ZTMP3_DEVICE(:,:,:) + ZTMP2_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDYY
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- PRTHLS(:,:,:) = PRTHLS - ZTMP3_DEVICE
+ PRTHLS(:,:,:) = PRTHLS(:,:,:) - ZTMP3_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -1160,80 +1169,80 @@ END IF
IF ( KRRL >= 1 .AND. .NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MYM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP4_DEVICE = ZTMP2_DEVICE*ZFLX
+ ZTMP4_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL MYF_DEVICE( ZTMP4_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP4_DEVICE = ZFLX*PINV_PDYY
+ ZTMP4_DEVICE(:,:,:) = ZFLX(:,:,:)*PINV_PDYY(:,:,:)
!$acc end kernels
CALL MZM_DEVICE( ZTMP4_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- ZTMP4_DEVICE = PDZY*ZTMP5_DEVICE
+ ZTMP4_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP5_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE( ZTMP4_DEVICE, ZTMP5_DEVICE)
CALL MZM_DEVICE( ZTMP1_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZTMP6_DEVICE = ZTMP4_DEVICE*ZTMP5_DEVICE
+ ZTMP6_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:)*ZTMP5_DEVICE(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(1,IKU,1, ZTMP6_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZFLXC = 2.*( ZTMP3_DEVICE + ZTMP4_DEVICE )
+ ZFLXC(:,:,:) = 2.*( ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )
!$acc end kernels
IF ( KRRI >= 1 ) THEN
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLX*PINV_PDYY
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)*PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP6_DEVICE*PINV_PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP6_DEVICE(:,:,:)*PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP3_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP4_DEVICE + ZTMP5_DEVICE )*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * (- ZTMP4_DEVICE + ZTMP5_DEVICE )*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP4_DEVICE(:,:,:) + ZTMP5_DEVICE(:,:,:) )*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * (- ZTMP4_DEVICE(:,:,:) + ZTMP5_DEVICE(:,:,:) )*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLX*PINV_PDYY
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)*PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP6_DEVICE*PINV_PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP6_DEVICE(:,:,:)*PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP3_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP4_DEVICE + ZTMP5_DEVICE )
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP4_DEVICE(:,:,:) + ZTMP5_DEVICE(:,:,:) )
!$acc end kernels
END IF
ELSE
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MYM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE*ZFLX
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL MYF_DEVICE( ZTMP1_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZFLXC = 2.*ZTMP3_DEVICE
+ ZFLXC(:,:,:) = 2.*ZTMP3_DEVICE(:,:,:)
!$acc end kernels
!
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE*ZFLX*PINV_PDYY
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)*PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
IF ( KRRI >= 1 ) THEN
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP2_DEVICE*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE(:,:,:)*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP2_DEVICE(:,:,:)*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -1254,7 +1263,7 @@ IF ( OCLOSE_OUT .AND. OTURB_FLX ) THEN
TZFIELD%NTYPE = TYPEREAL
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -1268,7 +1277,7 @@ IF (KSPLT==1 .AND. LLES_CALL) THEN
CALL GY_W_VW_DEVICE(1,IKU,1,PWM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MZM_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE, ZTMP4_DEVICE)
CALL MZF_DEVICE(1,IKU,1,ZTMP4_DEVICE, ZTMP1_DEVICE)
@@ -1277,7 +1286,7 @@ IF (KSPLT==1 .AND. LLES_CALL) THEN
CALL GY_M_M_DEVICE(1,IKU,1,PTHLM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MYF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaThl , .TRUE. )
!
@@ -1288,7 +1297,7 @@ IF (KSPLT==1 .AND. LLES_CALL) THEN
CALL GY_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MYF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE,X_LES_RES_ddxa_Rt_SBG_UaThl , .TRUE. )
!$acc end data
@@ -1333,11 +1342,11 @@ IF (KRR/=0) THEN
IF (.NOT. L2D) THEN
IF (.NOT. LFLAT) THEN
PRRS(:,:,:,1) = PRRS(:,:,:,1) &
- - DYF( MYM(PRHODJ) * ZFLX * PINV_PDYY ) &
-
- + DZF(1,IKU,1, PMZM_PRHODJ *MYF(PDZY*(MZM(1,IKU,1,ZFLX * PINV_PDYY))) * PINV_PDZZ )
+ - DYF( MYM(PRHODJ) * ZFLX(:,:,:) * PINV_PDYY(:,:,:) ) &
+ + DZF(1,IKU,1, PMZM_PRHODJ(:,:,:) *MYF(PDZY(:,:,:)* &
+ (MZM(1,IKU,1,ZFLX(:,:,:) * PINV_PDYY(:,:,:)))) * PINV_PDZZ(:,:,:) )
ELSE
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - DYF( MYM(PRHODJ) * ZFLX * PINV_PDYY )
+ PRRS(:,:,:,1) = PRRS(:,:,:,1) - DYF( MYM(PRHODJ) * ZFLX(:,:,:) * PINV_PDYY(:,:,:) )
END IF
END IF
!
@@ -1345,39 +1354,42 @@ IF (KRR/=0) THEN
!
IF ( KRRL >= 1 .AND. .NOT. L2D) THEN ! Sub-grid condensation
IF (.NOT. LFLAT) THEN
- ZFLXC = ZFLXC &
- + 2.*( MXF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX ) &
- + MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MYF( &
- PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) ) )&
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) &
+ + 2.*( MXF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:) ) &
+ + MZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MYF( &
+ PDZY(:,:,:)*(MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) ) )&
)
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DYF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX/PDYY ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MYF( PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) )&
- * PINV_PDZZ ) &
+ (- DYF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)/PDYY ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MYF( PDZY(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) )&
+ * PINV_PDZZ(:,:,:) ) &
)*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * &
- (- DYF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX/PDYY ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MYF( PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) )&
- * PINV_PDZZ ) &
+ (- DYF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)/PDYY ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MYF( PDZY(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) )&
+ * PINV_PDZZ(:,:,:) ) &
)*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * &
- (- DYF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX/PDYY ) &
- + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ*PAMOIST*PSRCM )*MYF( PDZY*(MZM(1,IKU,1, ZFLX*PINV_PDYY )) )&
- * PINV_PDZZ ) &
+ (- DYF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)/PDYY ) &
+ + DZF(1,IKU,1, MZM(1,IKU,1, PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*MYF( PDZY(:,:,:)* &
+ (MZM(1,IKU,1, ZFLX(:,:,:)*PINV_PDYY(:,:,:) )) )&
+ * PINV_PDZZ(:,:,:) ) &
)
END IF
ELSE
- ZFLXC = ZFLXC + 2.*MXF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX )
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) + 2.*MXF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX )
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DYF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX/PDYY )*(1.0-PFRAC_ICE(:,:,:))
+ DYF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)/PDYY )*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * &
- DYF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX/PDYY )*PFRAC_ICE(:,:,:)
+ DYF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)/PDYY )*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * &
- DYF( MYM( PRHODJ*PAMOIST*PSRCM )*ZFLX/PDYY )
+ DYF( MYM( PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:) )*ZFLX(:,:,:)/PDYY )
END IF
END IF
END IF
@@ -1394,7 +1406,7 @@ IF (KRR/=0) THEN
TZFIELD%NTYPE = TYPEREAL
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -1426,7 +1438,7 @@ 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
+ ZFLX(:,:,:) = -XCHF * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
ZFLX(:,:,IKE+1) = ZFLX(:,:,IKE)
!$acc end kernels
ELSE
@@ -1469,34 +1481,34 @@ IF (KRR/=0) THEN
IF (.NOT. LFLAT) THEN
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDYY
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!
!$acc kernels
- ZTMP1_DEVICE = ZFLX * PINV_PDYY
+ ZTMP1_DEVICE(:,:,:) = ZFLX(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = PDZY*ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP1_DEVICE = PMZM_PRHODJ * ZTMP2_DEVICE * PINV_PDZZ
+ ZTMP1_DEVICE(:,:,:) = PMZM_PRHODJ(:,:,:) * ZTMP2_DEVICE(:,:,:) * PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1,ZTMP1_DEVICE,ZTMP2_DEVICE )
!
!$acc kernels
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE + ZTMP2_DEVICE
+ PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE(:,:,:) + ZTMP2_DEVICE(:,:,:)
!$acc end kernels
ELSE
CALL MYM_DEVICE(PRHODJ, ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLX * PINV_PDYY
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLX(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE
+ PRRS(:,:,:,1) = PRRS(:,:,:,1) - ZTMP3_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -1506,72 +1518,72 @@ IF (KRR/=0) THEN
IF ( KRRL >= 1 .AND. .NOT. L2D) THEN ! Sub-grid condensation
IF (.NOT. LFLAT) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PAMOIST*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MYM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLX
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP3_DEVICE, ZTMP4_DEVICE )
CALL MZM_DEVICE( ZTMP1_DEVICE, ZTMP5_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZFLX*PINV_PDYY
+ ZTMP1_DEVICE(:,:,:) = ZFLX(:,:,:)*PINV_PDYY(:,:,:)
!$acc end kernels
CALL MZM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = PDZY*ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = PDZY(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZTMP5_DEVICE*ZTMP2_DEVICE
+ ZTMP1_DEVICE(:,:,:) = ZTMP5_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(1,IKU,1, ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZFLXC = ZFLXC + 2.*( ZTMP4_DEVICE + ZTMP2_DEVICE )
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) + 2.*( ZTMP4_DEVICE(:,:,:) + ZTMP2_DEVICE(:,:,:) )
!$acc end kernels
IF ( KRRI >= 1 ) THEN
!$acc kernels
- ZTMP2_DEVICE = ZTMP3_DEVICE/PDYY
+ ZTMP2_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) * PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE* PINV_PDZZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)* PINV_PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(1,IKU,1, ZTMP2_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP3_DEVICE + ZTMP4_DEVICE )*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * (- ZTMP3_DEVICE + ZTMP4_DEVICE )*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) + 2. * (- ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP3_DEVICE + ZTMP4_DEVICE )
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) + 2. * (- ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:) )
!$acc end kernels
END IF
ELSE
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PAMOIST*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PAMOIST(:,:,:)*PSRCM(:,:,:)
!$acc end kernels
CALL MYM_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLX
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZFLXC = ZFLXC + 2.*ZTMP4_DEVICE
+ ZFLXC(:,:,:) = ZFLXC(:,:,:) + 2.*ZTMP4_DEVICE(:,:,:)
!$acc end kernels
!
!$acc kernels
- ZTMP1_DEVICE = ZTMP3_DEVICE/PDYY
+ ZTMP1_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:)* PINV_PDYY(:,:,:)
!$acc end kernels
CALL DYF_DEVICE( ZTMP1_DEVICE, ZTMP2_DEVICE )
IF ( KRRI >= 1 ) THEN
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE*(1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP2_DEVICE*PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE(:,:,:)*(1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) - 2. * ZTMP2_DEVICE(:,:,:)*PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - 2. * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -1590,7 +1602,7 @@ IF (KRR/=0) THEN
TZFIELD%NTYPE = TYPEREAL
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLX)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLX(:,:,:))
END IF
!
IF (KSPLT==1 .AND. LLES_CALL) THEN
@@ -1605,7 +1617,7 @@ IF (KRR/=0) THEN
CALL GY_W_VW_DEVICE(1,IKU,1,PWM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MZM_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE, ZTMP4_DEVICE)
CALL MZF_DEVICE(1,IKU,1,ZTMP4_DEVICE,ZTMP1_DEVICE)
@@ -1614,14 +1626,14 @@ IF (KRR/=0) THEN
CALL GY_M_M_DEVICE(1,IKU,1,PTHLM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MYF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaRt , .TRUE. )
!
CALL GY_M_M_DEVICE(1,IKU,1,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MYF_DEVICE(ZFLX,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Rt_SBG_UaRt , .TRUE. )
!
diff --git a/src/MNH/turb_ver.f90 b/src/MNH/turb_ver.f90
index afbe862078bfd754f9190356e6799c9de684ad27..80fd1717f9f254de4b37931eba63e759135c9faa 100644
--- a/src/MNH/turb_ver.f90
+++ b/src/MNH/turb_ver.f90
@@ -605,28 +605,28 @@ CALL PRANDTL(KKA,KKU,KKL,KRR,KRRI,OCLOSE_OUT,OTURB_FLX, &
! Buoyancy coefficient
!
!$acc kernels
-ZBETA = XG/PTHVREF
+ZBETA(:,:,:) = XG/PTHVREF(:,:,:)
!
! Square root of Tke
!
-ZSQRT_TKE = SQRT(PTKEM)
+ZSQRT_TKE(:,:,:) = SQRT(PTKEM(:,:,:))
!$acc end kernels
!
! gradients of mean quantities at previous time-step
!
#ifndef MNH_OPENACC
-ZDTH_DZ = GZ_M_W(KKA,KKU,KKL,PTHLM(:,:,:),PDZZ)
-ZDR_DZ = 0.
+ZDTH_DZ(:,:,:) = GZ_M_W(KKA,KKU,KKL,PTHLM(:,:,:),PDZZ(:,:,:))
+ZDR_DZ(:,:,:) = 0.
IF (KRR>0) THEN
-ZDR_DZ = GZ_M_W(KKA,KKU,KKL,PRM(:,:,:,1),PDZZ)
+ZDR_DZ(:,:,:) = GZ_M_W(KKA,KKU,KKL,PRM(:,:,:,1),PDZZ(:,:,:))
ENDIF
#else
-CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PTHLM(:,:,:),PDZZ,ZDTH_DZ)
+CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PTHLM(:,:,:),PDZZ(:,:,:),ZDTH_DZ(:,:,:))
!$acc kernels
-ZDR_DZ = 0.
+ZDR_DZ(:,:,:) = 0.
!$acc end kernels
IF (KRR>0) THEN
-CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDZZ,ZDR_DZ)
+CALL GZ_M_W_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDZZ(:,:,:),ZDR_DZ(:,:,:))
ENDIF
#endif
!
@@ -634,7 +634,7 @@ ENDIF
! Denominator factor in 3rd order terms
!
!$acc kernels
-ZD(:,:,:) = (1.+ZREDTH1+ZREDR1) * (1.+0.5*(ZREDTH1+ZREDR1))
+ZD(:,:,:) = (1.+ZREDTH1(:,:,:)+ZREDR1(:,:,:)) * (1.+0.5*(ZREDTH1(:,:,:)+ZREDR1(:,:,:)))
!$acc end kernels
!
! Phi3 and Psi3 Prandtl numbers
@@ -642,9 +642,9 @@ ZD(:,:,:) = (1.+ZREDTH1+ZREDR1) * (1.+0.5*(ZREDTH1+ZREDR1))
GUSERV = KRR/=0
!
#ifndef MNH_OPENACC
-ZPHI3 = PHI3(ZREDTH1,ZREDR1,ZRED2TH3,ZRED2R3,ZRED2THR3,HTURBDIM,GUSERV)
+ZPHI3(:,:,:) = PHI3(ZREDTH1,ZREDR1,ZRED2TH3,ZRED2R3,ZRED2THR3,HTURBDIM,GUSERV)
IF(KRR/=0) THEN
-ZPSI3 = PSI3(ZREDR1,ZREDTH1,ZRED2R3,ZRED2TH3,ZRED2THR3,HTURBDIM,GUSERV)
+ZPSI3(:,:,:) = PSI3(ZREDR1,ZREDTH1,ZRED2R3,ZRED2TH3,ZRED2THR3,HTURBDIM,GUSERV)
ENDIF
#else
CALL PHI3(ZREDTH1,ZREDR1,ZRED2TH3,ZRED2R3,ZRED2THR3,HTURBDIM,GUSERV,ZPHI3)
@@ -658,7 +658,7 @@ ENDIF
! Prandtl numbers for scalars
!
#ifndef MNH_OPENACC
-ZPSI_SV = PSI_SV(ZREDTH1,ZREDR1,ZREDS1,ZRED2THS,ZRED2RS,ZPHI3,ZPSI3)
+ZPSI_SV(:,:,:,:) = PSI_SV(ZREDTH1,ZREDR1,ZREDS1,ZRED2THS,ZRED2RS,ZPHI3,ZPSI3)
#else
CALL PSI_SV(ZREDTH1,ZREDR1,ZREDS1,ZRED2THS,ZRED2RS,ZPHI3,ZPSI3,ZPSI_SV)
#endif
diff --git a/src/MNH/turb_ver_dyn_flux.f90 b/src/MNH/turb_ver_dyn_flux.f90
index 36919afe8039a7d09fcef3630363a163040d3fec..15f1e793cf88319b5d579d333d190de87b26c061 100644
--- a/src/MNH/turb_ver_dyn_flux.f90
+++ b/src/MNH/turb_ver_dyn_flux.f90
@@ -477,8 +477,6 @@ allocate( ztmp4_device(size( pthlm, 1 ), size( pthlm, 2 ), size( pthlm, 3 ) ) )
!
!* 1. PRELIMINARIES
! -------------
-ZA=XUNDEF
-PDP=XUNDEF
!
IIU=SIZE(PUM,1)
IJU=SIZE(PUM,2)
@@ -490,6 +488,8 @@ IKTB=1+JPVEXT_TURB
IKTE=IKT-JPVEXT_TURB
!
!$acc kernels
+ZA(:,:,:) = XUNDEF
+PDP(:,:,:) = XUNDEF
ZSOURCE(:,:,:) = 0.
!
#ifndef MNH_BITREP
@@ -503,7 +503,7 @@ ZDIRSINZW(:,:) = SQRT(1.-BR_P2(PDIRCOSZW(:,:)))
#ifndef MNH_OPENACC
ZKEFF(:,:,:) = MZM(KKA,KKU,KKL, PLM(:,:,:) * SQRT(PTKEM(:,:,:)) )
#else
-ZTMP1_DEVICE = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
+ZTMP1_DEVICE(:,:,:) = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZKEFF)
#endif
@@ -538,9 +538,9 @@ CALL MXM_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL MXM_DEVICE( PDZZ, ZTMP4_DEVICE )
!$acc kernels
#ifndef MNH_BITREP
-ZA(:,:,:) = -PTSTEP * XCMFS * ZTMP1_DEVICE * ZTMP3_DEVICE / ZTMP4_DEVICE**2
+ZA(:,:,:) = -PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / ZTMP4_DEVICE(:,:,:)**2
#else
-ZA(:,:,:) = -PTSTEP * XCMFS * ZTMP1_DEVICE * ZTMP3_DEVICE / BR_P2(ZTMP4_DEVICE)
+ZA(:,:,:) = -PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / BR_P2(ZTMP4_DEVICE(:,:,:))
#endif
!$acc end kernels
#endif
@@ -627,7 +627,7 @@ CALL TRIDIAG_WIND(KKA,KKU,KKL,PUM,ZA,ZCOEFS(:,:,1),PTSTEP,PEXPL,PIMPL, &
PRUS(:,:,:)=PRUS(:,:,:)+MXM(PRHODJ(:,:,:))*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
#else
!$acc kernels
-PRUS(:,:,:)=PRUS(:,:,:)+ZTMP1_DEVICE*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
+PRUS(:,:,:)=PRUS(:,:,:)+ZTMP1_DEVICE(:,:,:)*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
#endif
!
!
@@ -637,15 +637,15 @@ PRUS(:,:,:)=PRUS(:,:,:)+ZTMP1_DEVICE*(ZRES(:,:,:)-PUM(:,:,:))/PTSTEP
!
#ifndef MNH_OPENACC
ZFLXZ(:,:,:) = -XCMFS * MXM(ZKEFF) * &
- DZM (KKA,KKU,KKL,PIMPL*ZRES + PEXPL*PUM) / MXM(PDZZ)
+ DZM (KKA,KKU,KKL,PIMPL*ZRES(:,:,:) + PEXPL*PUM(:,:,:)) / MXM(PDZZ)
#else
-ZTMP2_DEVICE = PIMPL*ZRES + PEXPL*PUM
+ZTMP2_DEVICE(:,:,:) = PIMPL*ZRES(:,:,:) + PEXPL*PUM(:,:,:)
!$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
+ZFLXZ(:,:,:) = -XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / ZTMP4_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -696,16 +696,16 @@ PWU(:,:,:) = ZFLXZ(:,:,:)
! compute the dynamic production at the mass point
!
#ifndef MNH_OPENACC
-PDP(:,:,:) = - MZF(KKA,KKU,KKL, MXF ( ZFLXZ * GZ_U_UW(KKA,KKU,KKL,PUM,PDZZ) ) )
+PDP(:,:,:) = - MZF(KKA,KKU,KKL, MXF ( ZFLXZ(:,:,:) * GZ_U_UW(KKA,KKU,KKL,PUM,PDZZ) ) )
#else
CALL GZ_U_UW_DEVICE(KKA,KKU,KKL,PUM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE = ZFLXZ * ZTMP1_DEVICE
+ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP2_DEVICE,ZTMP3_DEVICE )
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
-PDP(:,:,:) = - ZTMP4_DEVICE
+PDP(:,:,:) = - ZTMP4_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -734,8 +734,8 @@ IF (LLES_CALL) THEN
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MXF(ZFLXZ)), X_LES_SUBGRID_WU )
CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MXF(GZ_U_UW(KKA,KKU,KKL,PUM,PDZZ) &
- & *ZFLXZ)), X_LES_RES_ddxa_U_SBG_UaU )
- CALL LES_MEAN_SUBGRID( XCMFS * ZKEFF, X_LES_SUBGRID_Km )
+ & *ZFLXZ(:,:,:))), X_LES_RES_ddxa_U_SBG_UaU )
+ CALL LES_MEAN_SUBGRID( XCMFS * ZKEFF(:,:,:), X_LES_SUBGRID_Km )
#else
!$acc data copy(X_LES_SUBGRID_WU,X_LES_RES_ddxa_U_SBG_UaU,X_LES_SUBGRID_Km)
!
@@ -745,14 +745,14 @@ IF (LLES_CALL) THEN
!
CALL GZ_U_UW_DEVICE(KKA,KKU,KKL,PUM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP2_DEVICE, ZTMP3_DEVICE )
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP4_DEVICE, X_LES_RES_ddxa_U_SBG_UaU )
!
!$acc kernels
- ZTMP1_DEVICE = XCMFS * ZKEFF
+ ZTMP1_DEVICE(:,:,:) = XCMFS * ZKEFF(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_Km )
!
@@ -775,43 +775,43 @@ IF(HTURBDIM=='3DIM') THEN
#ifndef MNH_OPENACC
IF (.NOT. LFLAT) THEN
PRWS(:,:,:)= PRWS &
- -DXF( MZM(KKA,KKU,KKL, MXM(PRHODJ) /PDXX ) * ZFLXZ ) &
+ -DXF( MZM(KKA,KKU,KKL, MXM(PRHODJ) /PDXX(:,:,:) ) * ZFLXZ(:,:,:) ) &
+DZM(KKA,KKU,KKL, PRHODJ / MZF(KKA,KKU,KKL,PDZZ ) * &
- MXF( MZF(KKA,KKU,KKL, ZFLXZ*PDZX ) / PDXX ) &
+ MXF( MZF(KKA,KKU,KKL, ZFLXZ(:,:,:)*PDZX(:,:,:) ) / PDXX(:,:,:) ) &
)
ELSE
- PRWS(:,:,:)= PRWS -DXF( MZM(KKA,KKU,KKL, MXM(PRHODJ) /PDXX ) * ZFLXZ )
+ PRWS(:,:,:)= PRWS(:,:,:) -DXF( MZM(KKA,KKU,KKL, MXM(PRHODJ) /PDXX(:,:,:) ) * ZFLXZ(:,:,:) )
END IF
#else
CALL MXM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE /PDXX
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) /PDXX(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE )
!$acc kernels
- ZTMP2_DEVICE = ZTMP3_DEVICE * ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) * ZFLXZ(:,:,:)
!$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
+ ZTMP3_DEVICE(:,:,:) = ZFLXZ(:,:,:)*PDZX(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE,ZTMP4_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP4_DEVICE / PDXX
+ ZTMP3_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) / PDXX(:,:,:)
!$acc end kernels
CALL MXF_DEVICE( ZTMP3_DEVICE,ZTMP4_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = PRHODJ / ZTMP2_DEVICE * ZTMP4_DEVICE
+ ZTMP3_DEVICE(:,:,:) = PRHODJ(:,:,:) / ZTMP2_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:)
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- PRWS(:,:,:)= PRWS - ZTMP1_DEVICE + ZTMP2_DEVICE
+ PRWS(:,:,:)= PRWS(:,:,:) - ZTMP1_DEVICE(:,:,:) + ZTMP2_DEVICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRWS(:,:,:)= PRWS -ZTMP1_DEVICE
+ PRWS(:,:,:)= PRWS(:,:,:) -ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -819,16 +819,16 @@ IF(HTURBDIM=='3DIM') THEN
! Complete the Dynamical production with the W wind component
!
#ifndef MNH_OPENACC
- ZA(:,:,:)=-MZF(KKA,KKU,KKL, MXF ( ZFLXZ * GX_W_UW(KKA,KKU,KKL, PWM,PDXX,PDZZ,PDZX) ) )
+ ZA(:,:,:)=-MZF(KKA,KKU,KKL, MXF ( ZFLXZ(:,:,:) * GX_W_UW(KKA,KKU,KKL, PWM,PDXX,PDZZ,PDZX) ) )
#else
CALL GX_W_UW_DEVICE(KKA,KKU,KKL, PWM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLXZ * ZTMP1_DEVICE
+ ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$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
+ ZA(:,:,:)=-ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -874,7 +874,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MXF(GX_W_UW(KKA,KKU,KKL,PWM,PDXX,&
- PDZZ,PDZX)*ZFLXZ)), X_LES_RES_ddxa_W_SBG_UaW )
+ PDZZ,PDZX)*ZFLXZ(:,:,:))), X_LES_RES_ddxa_W_SBG_UaW )
CALL LES_MEAN_SUBGRID( MXF(GX_M_U(KKA,KKU,KKL,PTHLM,PDXX,PDZZ,PDZX)&
* MZF(KKA,KKU,KKL,ZFLXZ)), X_LES_RES_ddxa_Thl_SBG_UaW )
IF (KRR>=1) THEN
@@ -891,7 +891,7 @@ IF(HTURBDIM=='3DIM') THEN
!
CALL GX_W_UW_DEVICE(KKA,KKU,KKL,PWM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
@@ -900,7 +900,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL GX_M_U_DEVICE(KKA,KKU,KKL,PTHLM,PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP4_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaW )
@@ -909,7 +909,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL GX_U_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID(ZTMP4_DEVICE,X_LES_RES_ddxa_Rt_SBG_UaW )
@@ -919,7 +919,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL GX_U_M_DEVICE(KKA,KKU,KKL,PSVM(:,:,:,JSV),PDXX,PDZZ,PDZX,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MXF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP4_DEVICE,X_LES_RES_ddxa_Sv_SBG_UaW(:,:,:,JSV) )
@@ -957,9 +957,9 @@ CALL MZM_DEVICE(PRHODJ, ZTMP3_DEVICE )
CALL MYM_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
-ZA(:,:,:) = - PTSTEP * XCMFS * ZTMP1_DEVICE * ZTMP4_DEVICE / ZTMP2_DEVICE**2
+ZA(:,:,:) = - PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:) / ZTMP2_DEVICE(:,:,:)**2
#else
-ZA(:,:,:) = - PTSTEP * XCMFS * ZTMP1_DEVICE * ZTMP4_DEVICE / BR_P2(ZTMP2_DEVICE)
+ZA(:,:,:) = - PTSTEP * XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:) / BR_P2(ZTMP2_DEVICE(:,:,:))
#endif
#endif
!
@@ -1063,13 +1063,13 @@ 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
+ZTMP1_DEVICE(:,:,:) = PIMPL*ZRES(:,:,:) + PEXPL*PVM(:,:,:)
!$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
+ZFLXZ(:,:,:) = -XCMFS * ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:) / ZTMP3_DEVICE(:,:,:)
!$acc end kernels
!
CALL MYM_DEVICE(PDZZ(:,:,IKB:IKB),ZTMP1_DEVICE(:,:,1:1))
@@ -1115,12 +1115,12 @@ ZA(:,:,:) = - MZF(KKA,KKU,KKL, MYF ( ZFLXZ * GZ_V_VW(KKA,KKU,KKL,PVM,PDZZ) ) )
#else
CALL GZ_V_VW_DEVICE(KKA,KKU,KKL,PVM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
-ZTMP2_DEVICE = ZFLXZ * ZTMP1_DEVICE
+ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$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
+ZA(:,:,:) = - ZTMP1_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -1161,7 +1161,7 @@ IF (LLES_CALL) THEN
!
CALL GZ_V_VW_DEVICE(KKA,KKU,KKL,PVM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
@@ -1198,33 +1198,33 @@ IF(HTURBDIM=='3DIM') THEN
IF (.NOT. L2D) THEN
CALL MYM_DEVICE(PRHODJ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE /PDYY
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) /PDYY(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
!$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
+ ZTMP3_DEVICE(:,:,:) = ZFLXZ(:,:,:)*PDZY(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP4_DEVICE / PDYY
+ ZTMP3_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) / PDYY(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = PRHODJ / ZTMP2_DEVICE * ZTMP4_DEVICE
+ ZTMP3_DEVICE(:,:,:) = PRHODJ(:,:,:) / ZTMP2_DEVICE(:,:,:) * ZTMP4_DEVICE(:,:,:)
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE, ZTMP4_DEVICE)
!$acc kernels
- PRWS(:,:,:)= PRWS(:,:,:) - ZTMP1_DEVICE + ZTMP4_DEVICE
+ PRWS(:,:,:)= PRWS(:,:,:) - ZTMP1_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- PRWS(:,:,:)= PRWS(:,:,:) - ZTMP1_DEVICE
+ PRWS(:,:,:)= PRWS(:,:,:) - ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -1233,16 +1233,16 @@ IF(HTURBDIM=='3DIM') THEN
! Complete the Dynamical production with the W wind component
IF (.NOT. L2D) THEN
#ifndef MNH_OPENACC
- ZA(:,:,:) = - MZF(KKA,KKU,KKL, MYF ( ZFLXZ * GY_W_VW(KKA,KKU,KKL, PWM,PDYY,PDZZ,PDZY) ) )
+ ZA(:,:,:) = - MZF(KKA,KKU,KKL, MYF ( ZFLXZ(:,:,:) * GY_W_VW(KKA,KKU,KKL, PWM,PDYY,PDZZ,PDZY) ) )
#else
CALL GY_W_VW_DEVICE(KKA,KKU,KKL, PWM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZFLXZ * ZTMP1_DEVICE
+ ZTMP2_DEVICE(:,:,:) = ZFLXZ(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$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
+ ZA(:,:,:) = - ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -1289,7 +1289,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MYF(GY_W_VW(KKA,KKU,KKL,PWM,PDYY,&
- PDZZ,PDZY)*ZFLXZ)), X_LES_RES_ddxa_W_SBG_UaW , .TRUE. )
+ PDZZ,PDZY)*ZFLXZ(:,:,:))), X_LES_RES_ddxa_W_SBG_UaW , .TRUE. )
CALL LES_MEAN_SUBGRID( MYF(GY_M_V(KKA,KKU,KKL,PTHLM,PDYY,PDZZ,PDZY)&
*MZF(KKA,KKU,KKL,ZFLXZ)), X_LES_RES_ddxa_Thl_SBG_UaW , .TRUE. )
IF (KRR>=1) THEN
@@ -1301,7 +1301,7 @@ IF(HTURBDIM=='3DIM') THEN
!
CALL GY_W_VW_DEVICE(KKA,KKU,KKL,PWM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
@@ -1310,7 +1310,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL GY_M_V_DEVICE(KKA,KKU,KKL,PTHLM,PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP4_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaW , .TRUE. )
@@ -1319,7 +1319,7 @@ IF(HTURBDIM=='3DIM') THEN
CALL GY_V_M_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),PDYY,PDZZ,PDZY,ZTMP1_DEVICE)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE*ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL MYF_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP4_DEVICE,X_LES_RES_ddxa_Rt_SBG_UaW , .TRUE. )
@@ -1347,7 +1347,7 @@ IF ( OTURB_FLX .AND. OCLOSE_OUT .AND. HTURBDIM == '1DIM') THEN
CALL GZ_W_M_DEVICE(KKA,KKU,KKL,PWM,PDZZ,ZTMP1_DEVICE)
!$acc kernels
ZFLXZ(:,:,:)= (2./3.) * PTKEM(:,:,:) &
- -XCMFS*PLM(:,:,:)*SQRT(PTKEM(:,:,:))*ZTMP1_DEVICE
+ -XCMFS*PLM(:,:,:)*SQRT(PTKEM(:,:,:))*ZTMP1_DEVICE(:,:,:)
!$acc end kernels
#endif
! stores the W variance
@@ -1362,7 +1362,7 @@ IF ( OTURB_FLX .AND. OCLOSE_OUT .AND. HTURBDIM == '1DIM') THEN
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
!$acc update self(ZFLXZ)
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ(:,:,:))
END IF
if ( mppdb_initialized ) then
diff --git a/src/MNH/turb_ver_thermo_corr.f90 b/src/MNH/turb_ver_thermo_corr.f90
index 8c5ac0d9cfa67c8c5effcbbd5d24c92054758e35..cf0d494c96c6308239eef36d7f8099e852571abc 100644
--- a/src/MNH/turb_ver_thermo_corr.f90
+++ b/src/MNH/turb_ver_thermo_corr.f90
@@ -507,9 +507,9 @@ ZCOEFF(:,:,IKB)= - (PDZZ(:,:,IKB+2*KKL)+2.*PDZZ(:,:,IKB+KKL)) / &
#ifndef MNH_OPENACC
ZKEFF(:,:,:) = MZM(KKA,KKU,KKL, PLM(:,:,:) * SQRT(PTKEM(:,:,:)) )
#else
-ZTMP1_DEVICE = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
+ZTMP1_DEVICE(:,:,:) = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
!$acc end kernels
-CALL MZM_DEVICE(ZTMP1_DEVICE, ZKEFF)
+CALL MZM_DEVICE(ZTMP1_DEVICE(:,:,:), ZKEFF(:,:,:))
#endif
!
! Flags for 3rd order quantities
@@ -521,11 +521,11 @@ GFWTH = .FALSE.
GFWR = .FALSE.
!
IF (HTOM/='NONE') THEN
- GFTH2 = ANY(PFTH2/=0.)
- GFR2 = ANY(PFR2 /=0.) .AND. GUSERV
- GFTHR = ANY(PFTHR/=0.) .AND. GUSERV
- GFWTH = ANY(PFWTH/=0.)
- GFWR = ANY(PFWR /=0.) .AND. GUSERV
+ GFTH2 = ANY(PFTH2(:,:,:)/=0.)
+ GFR2 = ANY(PFR2(:,:,:) /=0.) .AND. GUSERV
+ GFTHR = ANY(PFTHR(:,:,:)/=0.) .AND. GUSERV
+ GFWTH = ANY(PFWTH(:,:,:)/=0.)
+ GFWR = ANY(PFWR(:,:,:) /=0.) .AND. GUSERV
END IF
!----------------------------------------------------------------------------
!
@@ -539,22 +539,22 @@ END IF
! Compute the turbulent variance F and F' at time t-dt.
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- ZF (:,:,:) = XCTV*PLM*PLEPS*MZF(KKA,KKU,KKL,PPHI3*PDTH_DZ**2)
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*MZF(KKA,KKU,KKL,PPHI3(:,:,:)*PDTH_DZ(:,:,:)**2)
#else
- ZF (:,:,:) = XCTV*PLM*PLEPS*MZF(KKA,KKU,KKL,PPHI3*BR_P2(PDTH_DZ))
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*MZF(KKA,KKU,KKL,PPHI3(:,:,:)*BR_P2(PDTH_DZ(:,:,:)))
#endif
ZDFDDTDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
#else
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = PPHI3*PDTH_DZ**2
+ ZTMP1_DEVICE(:,:,:) = PPHI3(:,:,:)*PDTH_DZ(:,:,:)**2
#else
- ZTMP1_DEVICE = PPHI3*BR_P2(PDTH_DZ)
+ ZTMP1_DEVICE(:,:,:) = PPHI3(:,:,:)*BR_P2(PDTH_DZ(:,:,:))
#endif
!$acc end kernels
- CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF (:,:,:) = XCTV*PLM*PLEPS*ZTMP2_DEVICE
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*ZTMP2_DEVICE(:,:,:)
ZDFDDTDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
!$acc end kernels
#endif
@@ -564,21 +564,21 @@ END IF
! d(w'th'2)/dz
#ifndef MNH_OPENACC
IF (GFTH2) THEN
- ZF = ZF + M3_TH2_WTH2(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,&
- & PSQRT_TKE) * PFTH2
- ZDFDDTDZ = ZDFDDTDZ + D_M3_TH2_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA) * PFTH2
+ ZF(:,:,:) = ZF(:,:,:) + M3_TH2_WTH2(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:)) * PFTH2(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_TH2_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:)) * PFTH2(:,:,:)
END IF
#else
IF (GFTH2) THEN
- CALL M3_TH2_WTH2(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,ZTMP1_DEVICE)
+ CALL M3_TH2_WTH2(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFTH2
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
- CALL D_M3_TH2_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,ZTMP2_DEVICE)
+ CALL D_M3_TH2_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP2_DEVICE * PFTH2
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
END IF
#endif
@@ -586,23 +586,23 @@ END IF
! d(w'2th')/dz
#ifndef MNH_OPENACC
IF (GFWTH) THEN
- ZF = ZF + M3_TH2_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PDTH_DZ,&
- & PLM,PLEPS,PTKEM) * MZF(KKA,KKU,KKL,PFWTH)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_TH2_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
- & PLM,PLEPS,PTKEM,GUSERV) * MZF(KKA,KKU,KKL,PFWTH)
+ ZF(:,:,:) = ZF(:,:,:) + M3_TH2_W2TH(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),PDTH_DZ(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:)) * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_TH2_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),GUSERV) * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
END IF
#else
IF (GFWTH) THEN
- CALL MZF_DEVICE(KKA,KKU,KKL,PFWTH,ZTMP1_DEVICE)
- CALL M3_TH2_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PDTH_DZ,&
- & PLM,PLEPS,PTKEM,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PFWTH(:,:,:),ZTMP1_DEVICE(:,:,:))
+ CALL M3_TH2_W2TH(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),PDTH_DZ(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_TH2_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
- & PLM,PLEPS,PTKEM,GUSERV,ZTMP2_DEVICE)
+ CALL D_M3_TH2_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),GUSERV,ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -611,22 +611,22 @@ END IF
! d(w'r'2)/dz
#ifndef MNH_OPENACC
IF (GFR2) THEN
- ZF = ZF + M3_TH2_WR2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,PBLL_O_E,&
- & PEMOIST,PDTH_DZ) * PFR2
- ZDFDDTDZ = ZDFDDTDZ + D_M3_TH2_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
- & PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTH_DZ) * PFR2
+ ZF(:,:,:) = ZF(:,:,:) + M3_TH2_WR2(KKA,KKU,KKL,PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),&
+ & PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * PFR2(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_TH2_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),&
+ & PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * PFR2(:,:,:)
END IF
#else
IF (GFR2) THEN
- CALL M3_TH2_WR2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,PBLL_O_E,&
- & PEMOIST,PDTH_DZ,ZTMP1_DEVICE)
+ CALL M3_TH2_WR2(KKA,KKU,KKL,PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),&
+ & PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFR2
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
- CALL D_M3_TH2_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
- & PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP2_DEVICE)
+ CALL D_M3_TH2_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),&
+ & PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP2_DEVICE * PFR2
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
END IF
#endif
@@ -634,23 +634,23 @@ END IF
! d(w'2r')/dz
#ifndef MNH_OPENACC
IF (GFWR) THEN
- ZF = ZF + M3_TH2_W2R(KKA,KKU,KKL,PD,PLM,PLEPS,PTKEM,PBLL_O_E,&
- & PEMOIST,PDTH_DZ) * MZF(KKA,KKU,KKL,PFWR)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_TH2_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
- & PLM,PLEPS,PTKEM,PBLL_O_E,PEMOIST,PDTH_DZ) * MZF(KKA,KKU,KKL,PFWR)
+ ZF(:,:,:) = ZF(:,:,:) + M3_TH2_W2R(KKA,KKU,KKL,PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),&
+ & PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_TH2_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
END IF
#else
IF (GFWR) THEN
- CALL MZF_DEVICE(KKA,KKU,KKL,PFWR,ZTMP1_DEVICE)
- CALL M3_TH2_W2R(KKA,KKU,KKL,PD,PLM,PLEPS,PTKEM,PBLL_O_E,&
- & PEMOIST,PDTH_DZ,ZTMP2_DEVICE)
- CALL D_M3_TH2_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
- & PLM,PLEPS,PTKEM,PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP3_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PFWR(:,:,:),ZTMP1_DEVICE(:,:,:))
+ CALL M3_TH2_W2R(KKA,KKU,KKL,PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),&
+ & PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
+ CALL D_M3_TH2_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP3_DEVICE * ZTMP1_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP3_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -658,22 +658,22 @@ END IF
! d(w'th'r')/dz
#ifndef MNH_OPENACC
IF (GFTHR) THEN
- ZF = ZF + M3_TH2_WTHR(KKA,KKU,KKL,PREDR1,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PEMOIST,PDTH_DZ) * PFTHR
- ZDFDDTDZ = ZDFDDTDZ + D_M3_TH2_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTH_DZ) * PFTHR
+ ZF(:,:,:) = ZF(:,:,:) + M3_TH2_WTHR(KKA,KKU,KKL,PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * PFTHR(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_TH2_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * PFTHR(:,:,:)
END IF
#else
IF (GFTHR) THEN
- CALL M3_TH2_WTHR(KKA,KKU,KKL,PREDR1,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP1_DEVICE)
+ CALL M3_TH2_WTHR(KKA,KKU,KKL,PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFTHR
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
- CALL D_M3_TH2_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP2_DEVICE)
+ CALL D_M3_TH2_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP2_DEVICE * PFTHR
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
END IF
#endif
@@ -681,20 +681,21 @@ END IF
END IF
!
#ifndef MNH_OPENACC
- ZFLXZ(:,:,:) = ZF &
- ! + PIMPL * XCTV*PLM*PLEPS &
- ! *MZF(KKA,KKU,KKL,D_PHI3DTDZ2_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,PDTH_DZ,HTURBDIM,GUSERV) &
- ! *DZM(KKA,KKU,KKL,PTHLP - PTHLM) / PDZZ ) &
- + PIMPL * ZDFDDTDZ * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PTHLP - PTHLM) / PDZZ )
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ ! + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:) &
+ ! *MZF(KKA,KKU,KKL,D_PHI3DTDZ2_O_DDTDZ(PPHI3(:,:,:),PREDTH1(:,:,:),PREDR1(:,:,:),PRED2TH3(:,:,:),&
+ ! PRED2THR3(:,:,:),PDTH_DZ(:,:,:),HTURBDIM,GUSERV) &
+ ! *DZM(KKA,KKU,KKL,PTHLP(:,:,:) - PTHLM(:,:,:)) / PDZZ(:,:,:) ) &
+ + PIMPL * ZDFDDTDZ(:,:,:) * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PTHLP(:,:,:) - PTHLM(:,:,:)) / PDZZ(:,:,:) )
#else
- ZTMP1_DEVICE = PTHLP - PTHLM
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
- ZTMP3_DEVICE = ZTMP2_DEVICE / PDZZ
- CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE )
+ ZTMP1_DEVICE(:,:,:) = PTHLP(:,:,:) - PTHLM(:,:,:)
+ CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
+ CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE(:,:,:),ZTMP4_DEVICE(:,:,:) )
!$acc kernels
- ZFLXZ(:,:,:) = ZF &
- + PIMPL * ZDFDDTDZ * ZTMP4_DEVICE
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * ZDFDDTDZ(:,:,:) * ZTMP4_DEVICE(:,:,:)
#endif
!
! special case near the ground ( uncentred gradient )
@@ -726,7 +727,7 @@ END IF
!
ZFLXZ(:,:,KKA) = ZFLXZ(:,:,IKB)
!
- ZFLXZ = MAX(0., ZFLXZ)
+ ZFLXZ(:,:,:) = MAX(0., ZFLXZ(:,:,:))
!
IF (KRRL > 0) THEN
#ifndef MNH_BITREP
@@ -751,7 +752,7 @@ END IF
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
!$acc update self(ZFLXZ)
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ(:,:,:))
END IF
!
! and we store in LES configuration
@@ -759,36 +760,36 @@ END IF
IF (LLES_CALL) THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
- CALL LES_MEAN_SUBGRID( ZFLXZ, X_LES_SUBGRID_Thl2 )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM)*ZFLXZ, X_LES_RES_W_SBG_Thl2 )
- CALL LES_MEAN_SUBGRID( -2.*XCTD*PSQRT_TKE*ZFLXZ/PLEPS, X_LES_SUBGRID_DISS_Thl2 )
- CALL LES_MEAN_SUBGRID( PETHETA*ZFLXZ, X_LES_SUBGRID_ThlThv )
- CALL LES_MEAN_SUBGRID( -XA3*PBETA*PETHETA*ZFLXZ, X_LES_SUBGRID_ThlPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZFLXZ(:,:,:), X_LES_SUBGRID_Thl2 )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM(:,:,:))*ZFLXZ(:,:,:), X_LES_RES_W_SBG_Thl2 )
+ CALL LES_MEAN_SUBGRID( -2.*XCTD*PSQRT_TKE(:,:,:)*ZFLXZ(:,:,:)/PLEPS(:,:,:), X_LES_SUBGRID_DISS_Thl2 )
+ CALL LES_MEAN_SUBGRID( PETHETA(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_ThlThv )
+ CALL LES_MEAN_SUBGRID( -XA3*PBETA(:,:,:)*PETHETA(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_ThlPz, .TRUE. )
#else
!$acc data copy(X_LES_SUBGRID_Thl2,X_LES_RES_W_SBG_Thl2,X_LES_SUBGRID_DISS_Thl2, &
!$acc & X_LES_SUBGRID_ThlThv,X_LES_SUBGRID_ThlPz)
- CALL LES_MEAN_SUBGRID( ZFLXZ, X_LES_SUBGRID_Thl2 )
+ CALL LES_MEAN_SUBGRID( ZFLXZ(:,:,:), X_LES_SUBGRID_Thl2 )
!
- CALL MZF_DEVICE(KKA,KKU,KKL,PWM,ZTMP1_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PWM(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_W_SBG_Thl2 )
+ CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE(:,:,:), X_LES_RES_W_SBG_Thl2 )
!
!$acc kernels
- ZTMP1_DEVICE = -2.*XCTD*PSQRT_TKE*ZFLXZ/PLEPS
+ ZTMP1_DEVICE(:,:,:) = -2.*XCTD*PSQRT_TKE(:,:,:)*ZFLXZ(:,:,:)/PLEPS(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_DISS_Thl2 )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_DISS_Thl2 )
!
!$acc kernels
- ZTMP1_DEVICE = PETHETA*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PETHETA(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlThv )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_ThlThv )
!
!$acc kernels
- ZTMP1_DEVICE = -XA3*PBETA*PETHETA*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = -XA3*PBETA(:,:,:)*PETHETA(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_ThlPz, .TRUE. )
!
!$acc end data
#endif
@@ -803,14 +804,14 @@ END IF
!
! Compute the turbulent variance F and F' at time t-dt.
#ifndef MNH_OPENACC
- ZF (:,:,:) = XCTV*PLM*PLEPS*MZF(KKA,KKU,KKL,0.5*(PPHI3+PPSI3)*PDTH_DZ*PDR_DZ)
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*MZF(KKA,KKU,KKL,0.5*(PPHI3(:,:,:)+PPSI3(:,:,:))*PDTH_DZ(:,:,:)*PDR_DZ(:,:,:))
#else
!$acc kernels
- ZTMP1_DEVICE = 0.5*(PPHI3+PPSI3)*PDTH_DZ*PDR_DZ
+ ZTMP1_DEVICE(:,:,:) = 0.5*(PPHI3(:,:,:)+PPSI3(:,:,:))*PDTH_DZ(:,:,:)*PDR_DZ(:,:,:)
!$acc end kernels
- CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF (:,:,:) = XCTV*PLM*PLEPS*ZTMP2_DEVICE
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*ZTMP2_DEVICE(:,:,:)
#endif
ZDFDDTDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
ZDFDDRDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
@@ -821,29 +822,29 @@ END IF
! d(w'th'2)/dz
#ifndef MNH_OPENACC
IF (GFTH2) THEN
- ZF = ZF + M3_THR_WTH2(KKA,KKU,KKL,PREDR1,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PETHETA,PDR_DZ) * PFTH2
- ZDFDDTDZ = ZDFDDTDZ + D_M3_THR_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ) * PFTH2
- ZDFDDRDZ = ZDFDDRDZ + D_M3_THR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA) * PFTH2
+ ZF(:,:,:) = ZF(:,:,:) + M3_THR_WTH2(KKA,KKU,KKL,PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * PFTH2(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_THR_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * PFTH2(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_THR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:)) * PFTH2(:,:,:)
END IF
#else
IF (GFTH2) THEN
- CALL M3_THR_WTH2(KKA,KKU,KKL,PREDR1,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PETHETA,PDR_DZ,ZTMP1_DEVICE)
+ CALL M3_THR_WTH2(KKA,KKU,KKL,PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFTH2
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
- CALL D_M3_THR_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ,ZTMP1_DEVICE)
+ CALL D_M3_THR_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * PFTH2
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
- CALL D_M3_THR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,ZTMP1_DEVICE)
+ CALL D_M3_THR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * PFTH2
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
END IF
#endif
@@ -851,30 +852,30 @@ END IF
! d(w'2th')/dz
#ifndef MNH_OPENACC
IF (GFWTH) THEN
- ZF = ZF + M3_THR_W2TH(KKA,KKU,KKL,PREDR1,PD,PLM,PLEPS,PTKEM,&
- & PDR_DZ) * MZF(KKA,KKU,KKL,PFWTH)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_THR_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLM,PLEPS,PTKEM,PBLL_O_E,PDR_DZ,PETHETA) * MZF(KKA,KKU,KKL,PFWTH)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_THR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLM,PLEPS,PTKEM) * MZF(KKA,KKU,KKL,PFWTH)
+ ZF(:,:,:) = ZF(:,:,:) + M3_THR_W2TH(KKA,KKU,KKL,PREDR1(:,:,:),PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),&
+ PDR_DZ(:,:,:)) * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_THR_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PDR_DZ(:,:,:),PETHETA(:,:,:)) * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_THR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:)) * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
END IF
#else
IF (GFWTH) THEN
- CALL M3_THR_W2TH(KKA,KKU,KKL,PREDR1,PD,PLM,PLEPS,PTKEM,&
- & PDR_DZ,ZTMP1_DEVICE)
- CALL MZF_DEVICE(KKA,KKU,KKL,PFWTH,ZTMP2_DEVICE)
+ CALL M3_THR_W2TH(KKA,KKU,KKL,PREDR1(:,:,:),PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),&
+ & PDR_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
+ CALL MZF_DEVICE(KKA,KKU,KKL,PFWTH(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_THR_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLM,PLEPS,PTKEM,PBLL_O_E,PDR_DZ,PETHETA,ZTMP1_DEVICE)
+ CALL D_M3_THR_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PDR_DZ(:,:,:),PETHETA(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_THR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLM,PLEPS,PTKEM,ZTMP1_DEVICE)
+ CALL D_M3_THR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -882,29 +883,29 @@ END IF
! d(w'r'2)/dz
#ifndef MNH_OPENACC
IF (GFR2) THEN
- ZF = ZF + M3_THR_WR2(KKA,KKU,KKL,PREDTH1,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PEMOIST,PDTH_DZ) * PFR2
- ZDFDDTDZ = ZDFDDTDZ + D_M3_THR_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST) * PFR2
- ZDFDDRDZ = ZDFDDRDZ + D_M3_THR_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTH_DZ) * PFR2
+ ZF(:,:,:) = ZF(:,:,:) + M3_THR_WR2(KKA,KKU,KKL,PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * PFR2(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_THR_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:)) * PFR2(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_THR_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:)) * PFR2(:,:,:)
END IF
#else
IF (GFR2) THEN
- CALL M3_THR_WR2(KKA,KKU,KKL,PREDTH1,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP1_DEVICE)
+ CALL M3_THR_WR2(KKA,KKU,KKL,PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFR2
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
- CALL D_M3_THR_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,ZTMP1_DEVICE)
+ CALL D_M3_THR_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * PFR2
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
- CALL D_M3_THR_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP1_DEVICE)
+ CALL D_M3_THR_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),PDTH_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * PFR2
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
END IF
#endif
@@ -912,30 +913,30 @@ END IF
! d(w'2r')/dz
#ifndef MNH_OPENACC
IF (GFWR) THEN
- ZF = ZF + M3_THR_W2R(KKA,KKU,KKL,PREDTH1,PD,PLM,PLEPS,PTKEM,&
- & PDTH_DZ) * MZF(KKA,KKU,KKL,PFWR)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_THR_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLM,PLEPS,PTKEM) * MZF(KKA,KKU,KKL,PFWR)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_THR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLM,PLEPS,PTKEM,PBLL_O_E,PDTH_DZ,PEMOIST) * MZF(KKA,KKU,KKL,PFWR)
+ ZF(:,:,:) = ZF(:,:,:) + M3_THR_W2R(KKA,KKU,KKL,PREDTH1(:,:,:),PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),&
+ & PDTH_DZ(:,:,:)) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_THR_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:)) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_THR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PDTH_DZ(:,:,:),PEMOIST(:,:,:)) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
END IF
#else
IF (GFWR) THEN
- CALL MZF_DEVICE(KKA,KKU,KKL,PFWR,ZTMP1_DEVICE)
- CALL M3_THR_W2R(KKA,KKU,KKL,PREDTH1,PD,PLM,PLEPS,PTKEM,&
- & PDTH_DZ,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PFWR(:,:,:),ZTMP1_DEVICE(:,:,:))
+ CALL M3_THR_W2R(KKA,KKU,KKL,PREDTH1(:,:,:),PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),&
+ & PDTH_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_THR_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLM,PLEPS,PTKEM,ZTMP2_DEVICE)
+ CALL D_M3_THR_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_THR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PLM,PLEPS,PTKEM,PBLL_O_E,PDTH_DZ,PEMOIST,ZTMP2_DEVICE)
+ CALL D_M3_THR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PDTH_DZ(:,:,:),PEMOIST(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -943,91 +944,99 @@ END IF
! d(w'th'r')/dz
#ifndef MNH_OPENACC
IF (GFTHR) THEN
- ZF = ZF + M3_THR_WTHR(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,&
- & PSQRT_TKE) * PFTHR
- ZDFDDTDZ = ZDFDDTDZ + D_M3_THR_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA) * PFTHR
- ZDFDDRDZ = ZDFDDRDZ + D_M3_THR_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST) * PFTHR
+ ZF(:,:,:) = ZF(:,:,:) + M3_THR_WTHR(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:)) * PFTHR(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_THR_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:)) * PFTHR(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_THR_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:)) * PFTHR(:,:,:)
END IF
#else
IF (GFTHR) THEN
- CALL M3_THR_WTHR(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,&
- & PSQRT_TKE,ZTMP1_DEVICE)
+ CALL M3_THR_WTHR(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFTHR
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
- CALL D_M3_THR_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,ZTMP1_DEVICE)
+ CALL D_M3_THR_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1(:,:,:),PREDR1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * PFTHR
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
- CALL D_M3_THR_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,ZTMP1_DEVICE)
+ CALL D_M3_THR_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * PFTHR
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
END IF
#endif
!
#ifndef MNH_OPENACC
- ZFLXZ(:,:,:) = ZF &
- + PIMPL * XCTV*PLM*PLEPS*0.5 &
- * MZF(KKA,KKU,KKL, ( D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV) & ! d(phi3*dthdz)/ddthdz term
- +D_PSI3DTDZ_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV) & ! d(psi3*dthdz)/ddthdz term
- ) *PDR_DZ *DZM(KKA,KKU,KKL,PTHLP - PTHLM ) / PDZZ &
- +( D_PHI3DRDZ_O_DDRDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV) & ! d(phi3*drdz )/ddrdz term
- +D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV) & ! d(psi3*drdz )/ddrdz term
- ) *PDTH_DZ *DZM(KKA,KKU,KKL,PRP - PRM(:,:,:,1)) / PDZZ &
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:)*0.5 &
+ * MZF(KKA,KKU,KKL, ( D_PHI3DTDZ_O_DDTDZ(PPHI3(:,:,:),PREDTH1(:,:,:),PREDR1(:,:,:), &
+ PRED2TH3(:,:,:),PRED2THR3(:,:,:),HTURBDIM,GUSERV) & ! d(phi3*dthdz)/ddthdz term
+ +D_PSI3DTDZ_O_DDTDZ(PPSI3(:,:,:),PREDR1(:,:,:),PREDTH1(:,:,:),PRED2R3(:,:,:), &
+ PRED2THR3(:,:,:),HTURBDIM,GUSERV) & ! d(psi3*dthdz)/ddthdz term
+ ) *PDR_DZ(:,:,:) *DZM(KKA,KKU,KKL,PTHLP(:,:,:) - PTHLM(:,:,:) ) / PDZZ(:,:,:) &
+ +( D_PHI3DRDZ_O_DDRDZ(PPHI3(:,:,:),PREDTH1(:,:,:),PREDR1(:,:,:),PRED2TH3(:,:,:), &
+ PRED2THR3(:,:,:),HTURBDIM,GUSERV) & ! d(phi3*drdz )/ddrdz term
+ +D_PSI3DRDZ_O_DDRDZ(PPSI3(:,:,:),PREDR1(:,:,:),PREDTH1(:,:,:),PRED2R3(:,:,:), &
+ PRED2THR3(:,:,:),HTURBDIM,GUSERV) & ! d(psi3*drdz )/ddrdz term
+ ) *PDTH_DZ(:,:,:) *DZM(KKA,KKU,KKL,PRP(:,:,:) - PRM(:,:,:,1)) / PDZZ(:,:,:) &
) &
- + PIMPL * ZDFDDTDZ * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PTHLP - PTHLM(:,:,:)) / PDZZ ) &
- + PIMPL * ZDFDDRDZ * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PRP - PRM(:,:,:,1)) / PDZZ )
+ + PIMPL * ZDFDDTDZ(:,:,:) * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PTHLP(:,:,:) - PTHLM(:,:,:)) / PDZZ(:,:,:) ) &
+ + PIMPL * ZDFDDRDZ(:,:,:) * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PRP(:,:,:) - PRM(:,:,:,1)) / PDZZ(:,:,:) )
#else
!$acc kernels
- ZTMP1_DEVICE = PTHLP - PTHLM
- ZTMP2_DEVICE = PRP - PRM(:,:,:,1)
+ ZTMP1_DEVICE(:,:,:) = PTHLP(:,:,:) - PTHLM(:,:,:)
+ ZTMP2_DEVICE(:,:,:) = PRP(:,:,:) - PRM(:,:,:,1)
!$acc end kernels
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP3_DEVICE)
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP4_DEVICE)
+ 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
+ ZTMP1_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
+ ZTMP2_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) / PDZZ(:,:,:)
!$acc end kernels
- CALL D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV,ZTMP3_DEVICE) ! d(phi3*dthdz)/ddthdz term
- CALL D_PSI3DTDZ_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV,ZTMP4_DEVICE) ! d(psi3*dthdz)/ddthdz term
- CALL D_PHI3DRDZ_O_DDRDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV,ZTMP5_DEVICE) ! d(phi3*drdz )/ddrdz term
- CALL D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV,ZTMP6_DEVICE) ! d(psi3*drdz )/ddrdz term
+ CALL D_PHI3DTDZ_O_DDTDZ(PPHI3(:,:,:),PREDTH1(:,:,:),PREDR1(:,:,:),PRED2TH3(:,:,:),PRED2THR3(:,:,:), &
+ HTURBDIM,GUSERV,ZTMP3_DEVICE(:,:,:)) ! d(phi3*dthdz)/ddthdz term
+ CALL D_PSI3DTDZ_O_DDTDZ(PPSI3(:,:,:),PREDR1(:,:,:),PREDTH1(:,:,:),PRED2R3(:,:,:),PRED2THR3(:,:,:), &
+ HTURBDIM,GUSERV,ZTMP4_DEVICE(:,:,:)) ! d(psi3*dthdz)/ddthdz term
+ CALL D_PHI3DRDZ_O_DDRDZ(PPHI3(:,:,:),PREDTH1(:,:,:),PREDR1(:,:,:),PRED2TH3(:,:,:),PRED2THR3(:,:,:), &
+ HTURBDIM,GUSERV,ZTMP5_DEVICE(:,:,:)) ! d(phi3*drdz )/ddrdz term
+ CALL D_PSI3DRDZ_O_DDRDZ(PPSI3(:,:,:),PREDR1(:,:,:),PREDTH1(:,:,:),PRED2R3(:,:,:),PRED2THR3(:,:,:), &
+ HTURBDIM,GUSERV,ZTMP6_DEVICE(:,:,:)) ! d(psi3*drdz )/ddrdz term
!$acc kernels
- ZTMP1_DEVICE = PTHLP - PTHLM
- ZTMP8_DEVICE = PRP - PRM(:,:,:,1)
+ ZTMP1_DEVICE(:,:,:) = PTHLP(:,:,:) - PTHLM(:,:,:)
+ ZTMP8_DEVICE(:,:,:) = PRP(:,:,:) - PRM(:,:,:,1)
!$acc end kernels
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP8_DEVICE,ZTMP1_DEVICE)
+ CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
+ 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
+ ZTMP7_DEVICE(:,:,:) = ( ZTMP3_DEVICE(:,:,:) + ZTMP4_DEVICE(:,:,:)) * PDR_DZ(:,:,:) * ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:) &
+ + ( ZTMP5_DEVICE(:,:,:) + ZTMP6_DEVICE(:,:,:)) * PDTH_DZ(:,:,:) * ZTMP1_DEVICE(:,:,:) / PDZZ(:,:,:)
!$acc end kernels
!!!
!$acc kernels
- ZTMP1_DEVICE = PTHLP - PTHLM
- ZTMP2_DEVICE = PRP - PRM(:,:,:,1)
+ ZTMP1_DEVICE(:,:,:) = PTHLP(:,:,:) - PTHLM(:,:,:)
+ ZTMP2_DEVICE(:,:,:) = PRP(:,:,:) - PRM(:,:,:,1)
!$acc end kernels
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP3_DEVICE)
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP4_DEVICE)
+ 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
+ ZTMP1_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
+ ZTMP2_DEVICE(:,:,:) = ZTMP4_DEVICE(:,:,:) /PDZZ(:,:,:)
!$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 )
+ 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
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:)*0.5 * ZTMP3_DEVICE(:,:,:) &
+ + PIMPL * ZDFDDTDZ(:,:,:) * ZTMP4_DEVICE(:,:,:) &
+ + PIMPL * ZDFDDRDZ(:,:,:) * ZTMP5_DEVICE(:,:,:)
#endif
!
! special case near the ground ( uncentred gradient )
@@ -1069,7 +1078,7 @@ END IF
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
!$acc update self(ZFLXZ)
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ(:,:,:))
END IF
!
! and we store in LES configuration
@@ -1077,49 +1086,49 @@ END IF
IF (LLES_CALL) THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
- CALL LES_MEAN_SUBGRID( ZFLXZ, X_LES_SUBGRID_THlRt )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM)*ZFLXZ, X_LES_RES_W_SBG_ThlRt )
- CALL LES_MEAN_SUBGRID( -2.*XCTD*PSQRT_TKE*ZFLXZ/PLEPS, X_LES_SUBGRID_DISS_ThlRt )
- CALL LES_MEAN_SUBGRID( PETHETA*ZFLXZ, X_LES_SUBGRID_RtThv )
- CALL LES_MEAN_SUBGRID( -XA3*PBETA*PETHETA*ZFLXZ, X_LES_SUBGRID_RtPz, .TRUE. )
- CALL LES_MEAN_SUBGRID( PEMOIST*ZFLXZ, X_LES_SUBGRID_ThlThv , .TRUE. )
- CALL LES_MEAN_SUBGRID( -XA3*PBETA*PEMOIST*ZFLXZ, X_LES_SUBGRID_ThlPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZFLXZ(:,:,:), X_LES_SUBGRID_THlRt )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM(:,:,:))*ZFLXZ(:,:,:), X_LES_RES_W_SBG_ThlRt )
+ CALL LES_MEAN_SUBGRID( -2.*XCTD*PSQRT_TKE(:,:,:)*ZFLXZ(:,:,:)/PLEPS(:,:,:), X_LES_SUBGRID_DISS_ThlRt )
+ CALL LES_MEAN_SUBGRID( PETHETA(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_RtThv )
+ CALL LES_MEAN_SUBGRID( -XA3*PBETA(:,:,:)*PETHETA(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_RtPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( PEMOIST(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_ThlThv , .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XA3*PBETA(:,:,:)*PEMOIST(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_ThlPz, .TRUE. )
#else
!$acc data copy(X_LES_SUBGRID_THlRt,X_LES_RES_W_SBG_ThlRt,X_LES_SUBGRID_DISS_ThlRt, &
!$acc & X_LES_SUBGRID_RtThv,X_LES_SUBGRID_RtPz,X_LES_SUBGRID_ThlThv,X_LES_SUBGRID_ThlPz)
!
- CALL LES_MEAN_SUBGRID( ZFLXZ, X_LES_SUBGRID_THlRt )
+ CALL LES_MEAN_SUBGRID( ZFLXZ(:,:,:), X_LES_SUBGRID_THlRt )
!
- CALL MZF_DEVICE(KKA,KKU,KKL,PWM,ZTMP1_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PWM(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_W_SBG_ThlRt )
+ CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE(:,:,:), X_LES_RES_W_SBG_ThlRt )
!
!$acc kernels
- ZTMP1_DEVICE = -2.*XCTD*PSQRT_TKE*ZFLXZ/PLEPS
+ ZTMP1_DEVICE(:,:,:) = -2.*XCTD*PSQRT_TKE(:,:,:)*ZFLXZ(:,:,:)/PLEPS(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_DISS_ThlRt )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_DISS_ThlRt )
!
!$acc kernels
- ZTMP1_DEVICE = PETHETA*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PETHETA(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtThv )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_RtThv )
!
!$acc kernels
- ZTMP1_DEVICE = -XA3*PBETA*PETHETA*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = -XA3*PBETA(:,:,:)*PETHETA(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_RtPz, .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = PEMOIST*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PEMOIST(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlThv , .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_ThlThv , .TRUE. )
!
!$acc kernels
- ZTMP1_DEVICE = -XA3*PBETA*PEMOIST*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = -XA3*PBETA(:,:,:)*PEMOIST(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_ThlPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_ThlPz, .TRUE. )
!
!$acc end data
#endif
@@ -1134,21 +1143,21 @@ END IF
! Compute the turbulent variance F and F' at time t-dt.
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
- ZF (:,:,:) = XCTV*PLM*PLEPS*MZF(KKA,KKU,KKL,PPSI3*PDR_DZ**2)
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*MZF(KKA,KKU,KKL,PPSI3(:,:,:)*PDR_DZ(:,:,:)**2)
#else
- ZF (:,:,:) = XCTV*PLM*PLEPS*MZF(KKA,KKU,KKL,PPSI3*BR_P2(PDR_DZ))
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*MZF(KKA,KKU,KKL,PPSI3(:,:,:)*BR_P2(PDR_DZ(:,:,:)))
#endif
#else
!$acc kernels
#ifndef MNH_BITREP
- ZTMP1_DEVICE = PPSI3*PDR_DZ**2
+ ZTMP1_DEVICE(:,:,:) = PPSI3(:,:,:)*PDR_DZ(:,:,:)**2
#else
- ZTMP1_DEVICE = PPSI3*BR_P2(PDR_DZ)
+ ZTMP1_DEVICE(:,:,:) = PPSI3(:,:,:)*BR_P2(PDR_DZ(:,:,:))
#endif
!$acc end kernels
- CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF (:,:,:) = XCTV*PLM*PLEPS*ZTMP2_DEVICE
+ ZF (:,:,:) = XCTV*PLM(:,:,:)*PLEPS(:,:,:)*ZTMP2_DEVICE(:,:,:)
#endif
ZDFDDRDZ(:,:,:) = 0. ! this term, because of discretization, is treated separately
!$acc end kernels
@@ -1158,22 +1167,22 @@ END IF
! d(w'r'2)/dz
#ifndef MNH_OPENACC
IF (GFR2) THEN
- ZF = ZF + M3_R2_WR2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,&
- & PSQRT_TKE) * PFR2
- ZDFDDRDZ = ZDFDDRDZ + D_M3_R2_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST) * PFR2
+ ZF(:,:,:) = ZF(:,:,:) + M3_R2_WR2(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:)) * PFR2(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_R2_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:)) * PFR2(:,:,:)
END IF
#else
IF (GFR2) THEN
- CALL M3_R2_WR2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,&
- & PSQRT_TKE,ZTMP1_DEVICE)
+ CALL M3_R2_WR2(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFR2
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
- CALL D_M3_R2_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,ZTMP1_DEVICE)
+ CALL D_M3_R2_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PEMOIST(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * PFR2
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFR2(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1181,23 +1190,23 @@ END IF
! d(w'2r')/dz
#ifndef MNH_OPENACC
IF (GFWR) THEN
- ZF = ZF + M3_R2_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PDR_DZ,&
- & PLM,PLEPS,PTKEM) * MZF(KKA,KKU,KKL,PFWR)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_R2_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLM,PLEPS,PTKEM,GUSERV) * MZF(KKA,KKU,KKL,PFWR)
+ ZF(:,:,:) = ZF(:,:,:) + M3_R2_W2R(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),PDR_DZ(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:)) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_R2_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),GUSERV) * MZF(KKA,KKU,KKL,PFWR(:,:,:))
END IF
#else
IF (GFWR) THEN
- CALL MZF_DEVICE(KKA,KKU,KKL,PFWR,ZTMP1_DEVICE)
- CALL M3_R2_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PDR_DZ,&
- & PLM,PLEPS,PTKEM,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PFWR(:,:,:),ZTMP1_DEVICE(:,:,:))
+ CALL M3_R2_W2R(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),PD(:,:,:),PDR_DZ(:,:,:),&
+ & PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_R2_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLM,PLEPS,PTKEM,GUSERV,ZTMP3_DEVICE)
+ CALL D_M3_R2_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),GUSERV,ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP3_DEVICE * ZTMP1_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP3_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1206,22 +1215,22 @@ END IF
! d(w'r'2)/dz
#ifndef MNH_OPENACC
IF (GFTH2) THEN
- ZF = ZF + M3_R2_WTH2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PETHETA,PDR_DZ) * PFTH2
- ZDFDDRDZ = ZDFDDRDZ + D_M3_R2_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,&
- & PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ) * PFTH2
+ ZF(:,:,:) = ZF(:,:,:) + M3_R2_WTH2(KKA,KKU,KKL,PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * PFTH2(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_R2_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),&
+ & PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * PFTH2(:,:,:)
END IF
#else
IF (GFTH2) THEN
- CALL M3_R2_WTH2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,&
- & PBLL_O_E,PETHETA,PDR_DZ,ZTMP1_DEVICE)
+ CALL M3_R2_WTH2(KKA,KKU,KKL,PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),&
+ & PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFTH2
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
- CALL D_M3_R2_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,&
- & PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ,ZTMP2_DEVICE)
+ CALL D_M3_R2_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),&
+ & PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP2_DEVICE * PFTH2
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * PFTH2(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1229,23 +1238,24 @@ END IF
! d(w'2r')/dz
#ifndef MNH_OPENACC
IF (GFWTH) THEN
- ZF = ZF + M3_R2_W2TH(KKA,KKU,KKL,PD,PLM,PLEPS,PTKEM,&
- & PBLL_O_E,PETHETA,PDR_DZ) * MZF(KKA,KKU,KKL,PFWTH)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_R2_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLM,PLEPS,PTKEM,PBLL_O_E,PETHETA,PDR_DZ) * MZF(KKA,KKU,KKL,PFWTH)
+ ZF(:,:,:) = ZF(:,:,:) + M3_R2_W2TH(KKA,KKU,KKL,PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),&
+ PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_R2_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) &
+ * MZF(KKA,KKU,KKL,PFWTH(:,:,:))
END IF
#else
IF (GFWTH) THEN
- CALL MZF_DEVICE(KKA,KKU,KKL,PFWTH,ZTMP1_DEVICE)
- CALL M3_R2_W2TH(KKA,KKU,KKL,PD,PLM,PLEPS,PTKEM,&
- & PBLL_O_E,PETHETA,PDR_DZ,ZTMP2_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,PFWTH(:,:,:),ZTMP1_DEVICE(:,:,:))
+ CALL M3_R2_W2TH(KKA,KKU,KKL,PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),&
+ & PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
- CALL D_M3_R2_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLM,PLEPS,PTKEM,PBLL_O_E,PETHETA,PDR_DZ,ZTMP3_DEVICE)
+ CALL D_M3_R2_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLM(:,:,:),PLEPS(:,:,:),PTKEM(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP3_DEVICE * ZTMP1_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP3_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1253,22 +1263,22 @@ END IF
! d(w'th'r')/dz
#ifndef MNH_OPENACC
IF (GFTHR) THEN
- ZF = ZF + M3_R2_WTHR(KKA,KKU,KKL,PREDTH1,PD,PLEPS,&
- & PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ) * PFTHR
- ZDFDDRDZ = ZDFDDRDZ + D_M3_R2_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ) * PFTHR
+ ZF(:,:,:) = ZF(:,:,:) + M3_R2_WTHR(KKA,KKU,KKL,PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * PFTHR(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_R2_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:)) * PFTHR(:,:,:)
END IF
#else
IF (GFTHR) THEN
- CALL M3_R2_WTHR(KKA,KKU,KKL,PREDTH1,PD,PLEPS,&
- & PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ,ZTMP1_DEVICE)
+ CALL M3_R2_WTHR(KKA,KKU,KKL,PREDTH1(:,:,:),PD(:,:,:),PLEPS(:,:,:),&
+ & PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFTHR
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
- CALL D_M3_R2_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDR_DZ,ZTMP2_DEVICE)
+ CALL D_M3_R2_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1(:,:,:),PREDTH1(:,:,:),&
+ & PD(:,:,:),PLEPS(:,:,:),PSQRT_TKE(:,:,:),PBLL_O_E(:,:,:),PETHETA(:,:,:),PDR_DZ(:,:,:),ZTMP2_DEVICE(:,:,:))
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP2_DEVICE * PFTHR
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * PFTHR(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1276,29 +1286,31 @@ END IF
END IF
!
#ifndef MNH_OPENACC
- ZFLXZ(:,:,:) = ZF &
- + PIMPL * XCTV*PLM*PLEPS &
- *MZF(KKA,KKU,KKL,D_PSI3DRDZ2_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,PDR_DZ,HTURBDIM,GUSERV) &
- *DZM(KKA,KKU,KKL,PRP - PRM(:,:,:,1)) / PDZZ ) &
- + PIMPL * ZDFDDRDZ * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PRP - PRM(:,:,:,1)) / PDZZ )
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:) &
+ *MZF(KKA,KKU,KKL,D_PSI3DRDZ2_O_DDRDZ(PPSI3(:,:,:),PREDR1(:,:,:),PREDTH1(:,:,:),PRED2R3(:,:,:),PRED2THR3(:,:,:), &
+ PDR_DZ(:,:,:),HTURBDIM,GUSERV) &
+ *DZM(KKA,KKU,KKL,PRP(:,:,:) - PRM(:,:,:,1)) / PDZZ(:,:,:) ) &
+ + PIMPL * ZDFDDRDZ(:,:,:) * MZF(KKA,KKU,KKL,DZM(KKA,KKU,KKL,PRP(:,:,:) - PRM(:,:,:,1)) / PDZZ(:,:,:) )
#else
- CALL D_PSI3DRDZ2_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,PDR_DZ,HTURBDIM,GUSERV,ZTMP1_DEVICE)
+ CALL D_PSI3DRDZ2_O_DDRDZ(PPSI3(:,:,:),PREDR1(:,:,:),PREDTH1(:,:,:),PRED2R3(:,:,:),PRED2THR3(:,:,:),PDR_DZ(:,:,:), &
+ HTURBDIM,GUSERV,ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE = PRP - PRM(:,:,:,1)
+ ZTMP2_DEVICE(:,:,:) = PRP(:,:,:) - PRM(:,:,:,1)
!$acc end kernels
- CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
+ CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZTMP3_DEVICE / PDZZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
!$acc end kernels
- CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP1_DEVICE(:,:,:))
!$acc kernels
- ZTMP2_DEVICE = ZTMP3_DEVICE / PDZZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP3_DEVICE(:,:,:) / PDZZ(:,:,:)
!$acc end kernels
- CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
+ CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE(:,:,:),ZTMP3_DEVICE(:,:,:))
!$acc kernels
- ZFLXZ(:,:,:) = ZF &
- + PIMPL * XCTV*PLM*PLEPS * ZTMP1_DEVICE &
- + PIMPL * ZDFDDRDZ * ZTMP3_DEVICE
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * XCTV*PLM(:,:,:)*PLEPS(:,:,:) * ZTMP1_DEVICE(:,:,:) &
+ + PIMPL * ZDFDDRDZ(:,:,:) * ZTMP3_DEVICE(:,:,:)
#endif
!
! special case near the ground ( uncentred gradient )
@@ -1351,7 +1363,7 @@ END IF
TZFIELD%NDIMS = 3
TZFIELD%LTIMEDEP = .TRUE.
!$acc update self(ZFLXZ)
- CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ)
+ CALL IO_Field_write(TPFILE,TZFIELD,ZFLXZ(:,:,:))
END IF
!
! and we store in LES configuration
@@ -1359,29 +1371,29 @@ END IF
IF (LLES_CALL) THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
- CALL LES_MEAN_SUBGRID( ZFLXZ, X_LES_SUBGRID_Rt2 )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM)*ZFLXZ, X_LES_RES_W_SBG_Rt2 )
- CALL LES_MEAN_SUBGRID( PEMOIST*ZFLXZ, X_LES_SUBGRID_RtThv , .TRUE. )
- CALL LES_MEAN_SUBGRID( -XA3*PBETA*PEMOIST*ZFLXZ, X_LES_SUBGRID_RtPz, .TRUE. )
- CALL LES_MEAN_SUBGRID( -2.*XCTD*PSQRT_TKE*ZFLXZ/PLEPS, X_LES_SUBGRID_DISS_Rt2 )
+ CALL LES_MEAN_SUBGRID( ZFLXZ(:,:,:), X_LES_SUBGRID_Rt2 )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM(:,:,:))*ZFLXZ(:,:,:), X_LES_RES_W_SBG_Rt2 )
+ CALL LES_MEAN_SUBGRID( PEMOIST(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_RtThv , .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XA3*PBETA(:,:,:)*PEMOIST(:,:,:)*ZFLXZ(:,:,:), X_LES_SUBGRID_RtPz, .TRUE. )
+ CALL LES_MEAN_SUBGRID( -2.*XCTD*PSQRT_TKE(:,:,:)*ZFLXZ(:,:,:)/PLEPS(:,:,:), X_LES_SUBGRID_DISS_Rt2 )
#else
!$acc data copy(X_LES_SUBGRID_Rt2,X_LES_RES_W_SBG_Rt2,X_LES_SUBGRID_RtThv, &
!$acc & X_LES_SUBGRID_RtPz,X_LES_SUBGRID_DISS_Rt2)
!
- CALL LES_MEAN_SUBGRID( ZFLXZ, X_LES_SUBGRID_Rt2 )
+ CALL LES_MEAN_SUBGRID( ZFLXZ(:,:,:), X_LES_SUBGRID_Rt2 )
!
- CALL MZF_DEVICE(KKA,KKU,KKL,PWM,ZTMP1_DEVICE)
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLXZ
- CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_W_SBG_Rt2 )
+ CALL MZF_DEVICE(KKA,KKU,KKL,PWM(:,:,:),ZTMP1_DEVICE(:,:,:))
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
+ CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE(:,:,:), X_LES_RES_W_SBG_Rt2 )
!
- ZTMP1_DEVICE = PEMOIST*ZFLXZ
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtThv , .TRUE. )
+ ZTMP1_DEVICE(:,:,:) = PEMOIST(:,:,:)*ZFLXZ(:,:,:)
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_RtThv , .TRUE. )
!
- ZTMP1_DEVICE = -XA3*PBETA*PEMOIST*ZFLXZ
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_RtPz, .TRUE. )
+ ZTMP1_DEVICE(:,:,:) = -XA3*PBETA(:,:,:)*PEMOIST(:,:,:)*ZFLXZ(:,:,:)
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_RtPz, .TRUE. )
!
- ZTMP1_DEVICE = -2.*XCTD*PSQRT_TKE*ZFLXZ/PLEPS
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_DISS_Rt2 )
+ ZTMP1_DEVICE(:,:,:) = -2.*XCTD*PSQRT_TKE(:,:,:)*ZFLXZ(:,:,:)/PLEPS(:,:,:)
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE(:,:,:), X_LES_SUBGRID_DISS_Rt2 )
!
!$acc end data
#endif
diff --git a/src/MNH/turb_ver_thermo_flux.f90 b/src/MNH/turb_ver_thermo_flux.f90
index 7334345af5b12804f7b76195bd821923aa578a0b..b5b7355cea1e24394b3623be1c1258a5b18d18a7 100644
--- a/src/MNH/turb_ver_thermo_flux.f90
+++ b/src/MNH/turb_ver_thermo_flux.f90
@@ -570,7 +570,7 @@ GUSERV = (KRR/=0)
ZKEFF(:,:,:) = MZM(KKA,KKU,KKL, PLM(:,:,:) * SQRT(PTKEM(:,:,:)) )
#else
!$acc kernels
-ZTMP1_DEVICE = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
+ZTMP1_DEVICE(:,:,:) = PLM(:,:,:) * SQRT(PTKEM(:,:,:))
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE, ZKEFF)
#endif
@@ -584,11 +584,11 @@ GFWTH = .FALSE.
GFWR = .FALSE.
!
IF (HTOM/='NONE') THEN
- GFTH2 = ANY(PFTH2/=0.)
- GFR2 = ANY(PFR2 /=0.) .AND. GUSERV
- GFTHR = ANY(PFTHR/=0.) .AND. GUSERV
- GFWTH = ANY(PFWTH/=0.)
- GFWR = ANY(PFWR /=0.) .AND. GUSERV
+ GFTH2 = ANY(PFTH2(:,:,:)/=0.)
+ GFR2 = ANY(PFR2 (:,:,:)/=0.) .AND. GUSERV
+ GFTHR = ANY(PFTHR(:,:,:)/=0.) .AND. GUSERV
+ GFWTH = ANY(PFWTH(:,:,:)/=0.)
+ GFWR = ANY(PFWR (:,:,:)/=0.) .AND. GUSERV
END IF
!----------------------------------------------------------------------------
!
@@ -601,17 +601,17 @@ END IF
! Compute the turbulent flux F and F' at time t-dt.
!
#ifndef MNH_OPENACC
-ZF (:,:,:) = -XCSHF*PPHI3*ZKEFF*DZM(KKA,KKU,KKL,PTHLM)/PDZZ
-ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF*D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV)
+ZF (:,:,:) = -XCSHF*PPHI3(:,:,:)*ZKEFF(:,:,:)*DZM(KKA,KKU,KKL,PTHLM)/PDZZ(:,:,:)
+ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV)
#else
CALL DZM_DEVICE(KKA,KKU,KKL,PTHLM,ZTMP1_DEVICE)
!$acc kernels
-ZF (:,:,:) = -XCSHF*PPHI3*ZKEFF*ZTMP1_DEVICE/PDZZ
+ZF (:,:,:) = -XCSHF*PPHI3(:,:,:)*ZKEFF(:,:,:)*ZTMP1_DEVICE(:,:,:)/PDZZ(:,:,:)
!$acc end kernels
!
CALL D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,GUSERV,ZTMP2_DEVICE)
!$acc kernels
-ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF*ZTMP2_DEVICE
+ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*ZTMP2_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -620,23 +620,23 @@ ZDFDDTDZ(:,:,:) = -XCSHF*ZKEFF*ZTMP2_DEVICE
! d(w'2th')/dz
#ifndef MNH_OPENACC
IF (GFWTH) THEN
- Z3RDMOMENT= M3_WTH_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,PTKEM)
+ Z3RDMOMENT(:,:,:)= M3_WTH_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,PTKEM)
!
- ZF = ZF + Z3RDMOMENT * PFWTH
- ZDFDDTDZ = ZDFDDTDZ + D_M3_WTH_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,PBLL_O_E,PETHETA,ZKEFF,PTKEM) * PFWTH
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * PFWTH(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_WTH_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
+ & PD,PBLL_O_E,PETHETA,ZKEFF,PTKEM) * PFWTH(:,:,:)
END IF
#else
IF (GFWTH) THEN
CALL M3_WTH_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,PTKEM,Z3RDMOMENT)
!
!$acc kernels
- ZF = ZF + Z3RDMOMENT * PFWTH
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * PFWTH(:,:,:)
!$acc end kernels
CALL D_M3_WTH_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
& PD,PBLL_O_E,PETHETA,ZKEFF,PTKEM,ZTMP1_DEVICE)
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * PFWTH
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFWTH(:,:,:)
!$acc end kernels
END IF
#endif
@@ -644,10 +644,10 @@ END IF
! d(w'th'2)/dz
#ifndef MNH_OPENACC
IF (GFTH2) THEN
- Z3RDMOMENT= M3_WTH_WTH2(PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA)
+ Z3RDMOMENT(:,:,:)= M3_WTH_WTH2(PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA)
!
- ZF = ZF + Z3RDMOMENT * MZM(KKA,KKU,KKL,PFTH2)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_WTH_WTH2_O_DDTDZ(Z3RDMOMENT,PREDTH1,PREDR1,&
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * MZM(KKA,KKU,KKL,PFTH2)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_WTH_WTH2_O_DDTDZ(Z3RDMOMENT,PREDTH1,PREDR1,&
& PD,PBLL_O_E,PETHETA) * MZM(KKA,KKU,KKL,PFTH2)
END IF
#else
@@ -656,13 +656,13 @@ IF (GFTH2) THEN
!
CALL MZM_DEVICE(PFTH2,ZTMP1_DEVICE)
!$acc kernels
- ZF = ZF + Z3RDMOMENT * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL D_M3_WTH_WTH2_O_DDTDZ(Z3RDMOMENT,PREDTH1,PREDR1,&
& PD,PBLL_O_E,PETHETA,ZTMP1_DEVICE)
CALL MZM_DEVICE(PFTH2,ZTMP2_DEVICE)
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -670,22 +670,22 @@ END IF
! d(w'2r')/dz
#ifndef MNH_OPENACC
IF (GFWR) THEN
- ZF = ZF + M3_WTH_W2R(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,&
- & PTKEM,PBLL_O_E,PEMOIST,PDTH_DZ) * PFWR
- ZDFDDTDZ = ZDFDDTDZ + D_M3_WTH_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
- & PD,ZKEFF,PTKEM,PBLL_O_E,PEMOIST) * PFWR
+ ZF(:,:,:) = ZF(:,:,:) + M3_WTH_W2R(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,&
+ & PTKEM,PBLL_O_E,PEMOIST,PDTH_DZ) * PFWR(:,:,:)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_WTH_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
+ & PD,ZKEFF,PTKEM,PBLL_O_E,PEMOIST) * PFWR(:,:,:)
END IF
#else
IF (GFWR) THEN
CALL M3_WTH_W2R(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,&
& PTKEM,PBLL_O_E,PEMOIST,PDTH_DZ,ZTMP1_DEVICE)
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFWR
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFWR(:,:,:)
!$acc end kernels
CALL D_M3_WTH_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,&
& PD,ZKEFF,PTKEM,PBLL_O_E,PEMOIST,ZTMP2_DEVICE)
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP2_DEVICE * PFWR
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * PFWR(:,:,:)
!$acc end kernels
END IF
#endif
@@ -693,9 +693,9 @@ END IF
! d(w'r'2)/dz
#ifndef MNH_OPENACC
IF (GFR2) THEN
- ZF = ZF + M3_WTH_WR2(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,PTKEM,&
+ ZF(:,:,:) = ZF(:,:,:) + M3_WTH_WR2(KKA,KKU,KKL,PREDTH1,PREDR1,PD,ZKEFF,PTKEM,&
& PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST,PDTH_DZ) * MZM(KKA,KKU,KKL,PFR2)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_WTH_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_WTH_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
& ZKEFF,PTKEM,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST) * MZM(KKA,KKU,KKL,PFR2)
END IF
#else
@@ -704,13 +704,13 @@ IF (GFR2) THEN
& PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST,PDTH_DZ,ZTMP1_DEVICE)
CALL MZM_DEVICE(PFR2,ZTMP2_DEVICE)
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL D_M3_WTH_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,&
& ZKEFF,PTKEM,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST,ZTMP1_DEVICE)
CALL MZM_DEVICE(PFR2,ZTMP2_DEVICE)
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -718,10 +718,10 @@ END IF
! d(w'th'r')/dz
#ifndef MNH_OPENACC
IF (GFTHR) THEN
- Z3RDMOMENT= M3_WTH_WTHR(KKA,KKU,KKL,PREDR1,PD,ZKEFF,PTKEM,PSQRT_TKE,PBETA,PLEPS,PEMOIST)
+ Z3RDMOMENT(:,:,:)= M3_WTH_WTHR(KKA,KKU,KKL,PREDR1,PD,ZKEFF,PTKEM,PSQRT_TKE,PBETA,PLEPS,PEMOIST)
!
- ZF = ZF + Z3RDMOMENT * MZM(KKA,KKU,KKL,PFTHR)
- ZDFDDTDZ = ZDFDDTDZ + D_M3_WTH_WTHR_O_DDTDZ(Z3RDMOMENT,PREDTH1,&
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * MZM(KKA,KKU,KKL,PFTHR)
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + D_M3_WTH_WTHR_O_DDTDZ(Z3RDMOMENT,PREDTH1,&
& PREDR1,PD,PBLL_O_E,PETHETA) * MZM(KKA,KKU,KKL,PFTHR)
END IF
#else
@@ -731,12 +731,12 @@ IF (GFTHR) THEN
!
CALL MZM_DEVICE(PFTHR,ZTMP1_DEVICE)
!$acc kernels
- ZF = ZF + Z3RDMOMENT * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL D_M3_WTH_WTHR_O_DDTDZ(Z3RDMOMENT,PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA,ZTMP1_DEVICE)
CALL MZM_DEVICE(PFTHR,ZTMP2_DEVICE)
!$acc kernels
- ZDFDDTDZ = ZDFDDTDZ + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZDFDDTDZ(:,:,:) = ZDFDDTDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -775,15 +775,15 @@ PRTHLS(:,:,:)= PRTHLS(:,:,:) + &
! Conservative potential temperature flux :
!
#ifndef MNH_OPENACC
-ZFLXZ(:,:,:) = ZF &
- + PIMPL * ZDFDDTDZ * DZM(KKA,KKU,KKL,PTHLP - PTHLM) / PDZZ
+ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * ZDFDDTDZ(:,:,:) * DZM(KKA,KKU,KKL,PTHLP - PTHLM(:,:,:)) / PDZZ(:,:,:)
#else
!$acc kernels
-ZTMP1_DEVICE = PTHLP - PTHLM
+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
+ZFLXZ(:,:,:) = ZF(:,:,:) + PIMPL * ZDFDDTDZ(:,:,:) * ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
#endif
!
ZFLXZ(:,:,KKA) = ZFLXZ(:,:,IKB)
@@ -815,28 +815,28 @@ END IF
! Contribution of the conservative temperature flux to the buoyancy flux
#ifndef MNH_OPENACC
IF (KRR /= 0) THEN
- PTP(:,:,:) = PBETA * MZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL,PETHETA) * ZFLXZ )
+ PTP(:,:,:) = PBETA(:,:,:) * MZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL,PETHETA) * ZFLXZ(:,:,:) )
PTP(:,:,IKB)= PBETA(:,:,IKB) * PETHETA(:,:,IKB) * &
- 0.5 * ( ZFLXZ (:,:,IKB) + ZFLXZ (:,:,IKB+KKL) )
+ 0.5 * ( ZFLXZ(:,:,IKB) + ZFLXZ(:,:,IKB+KKL) )
ELSE
- PTP(:,:,:)= PBETA * MZF(KKA,KKU,KKL, ZFLXZ )
+ PTP(:,:,:)= PBETA(:,:,:) * MZF(KKA,KKU,KKL, ZFLXZ )
END IF
#else
IF (KRR /= 0) THEN
CALL MZM_DEVICE(PETHETA,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP2_DEVICE,ZTMP3_DEVICE)
!$acc kernels
- PTP(:,:,:) = PBETA * ZTMP3_DEVICE
+ PTP(:,:,:) = PBETA(:,:,:) * ZTMP3_DEVICE(:,:,:)
PTP(:,:,IKB)= PBETA(:,:,IKB) * PETHETA(:,:,IKB) * &
- 0.5 * ( ZFLXZ (:,:,IKB) + ZFLXZ (:,:,IKB+KKL) )
+ 0.5 * ( ZFLXZ(:,:,IKB) + ZFLXZ(:,:,IKB+KKL) )
!$acc end kernels
ELSE
CALL MZF_DEVICE(KKA,KKU,KKL, ZFLXZ,ZTMP1_DEVICE)
!$acc kernels
- PTP(:,:,:)= PBETA * ZTMP1_DEVICE
+ PTP(:,:,:)= PBETA(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -844,11 +844,11 @@ END IF
! Buoyancy flux at flux points
!
#ifndef MNH_OPENACC
-PWTHV = MZM(KKA,KKU,KKL,PETHETA) * ZFLXZ
+PWTHV(:,:,:) = MZM(KKA,KKU,KKL,PETHETA) * ZFLXZ(:,:,:)
#else
CALL MZM_DEVICE(PETHETA,ZTMP1_DEVICE)
!$acc kernels
-PWTHV = ZTMP1_DEVICE * ZFLXZ
+PWTHV(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
#endif
PWTHV(:,:,IKB) = PETHETA(:,:,IKB) * ZFLXZ(:,:,IKB)
!$acc end kernels
@@ -859,42 +859,42 @@ PWTHV(:,:,IKB) = PETHETA(:,:,IKB) * ZFLXZ(:,:,IKB)
IF ( KRRL >= 1 ) THEN
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) - &
- DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ*PATHETA*2.*PSRCM )*ZFLXZ/PDZZ ) &
+ DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ(:,:,:)*PATHETA(:,:,:)*2.*PSRCM(:,:,:) )*ZFLXZ(:,:,:)/PDZZ(:,:,:) ) &
*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) - &
- DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ*PATHETA*2.*PSRCM )*ZFLXZ/PDZZ ) &
+ DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ(:,:,:)*PATHETA(:,:,:)*2.*PSRCM(:,:,:) )*ZFLXZ(:,:,:)/PDZZ(:,:,:) ) &
*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) - &
- DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ*PATHETA*2.*PSRCM )*ZFLXZ/PDZZ )
+ DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ(:,:,:)*PATHETA(:,:,:)*2.*PSRCM(:,:,:) )*ZFLXZ(:,:,:)/PDZZ(:,:,:) )
END IF
END IF
#else
IF ( KRRL >= 1 ) THEN
IF ( KRRI >= 1 ) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*2.*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*2.*PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE*ZFLXZ/PDZZ
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)/PDZZ(:,:,:)
!$acc end kernels
- CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP3_DEVICE )
+ CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP3_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP3_DEVICE * (1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) - ZTMP3_DEVICE * PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP3_DEVICE(:,:,:) * (1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) - ZTMP3_DEVICE(:,:,:) * PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PATHETA*2.*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PATHETA(:,:,:)*2.*PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE,ZTMP2_DEVICE )
!$acc kernels
- ZTMP1_DEVICE = ZTMP2_DEVICE*ZFLXZ/PDZZ
+ ZTMP1_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)/PDZZ(:,:,:)
!$acc end kernels
- CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP3_DEVICE )
+ CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP1_DEVICE,ZTMP3_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP3_DEVICE
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP3_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -906,58 +906,58 @@ IF (LLES_CALL) THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,ZFLXZ), X_LES_SUBGRID_WThl )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM*ZFLXZ), X_LES_RES_W_SBG_WThl )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM(:,:,:)*ZFLXZ(:,:,:)), X_LES_RES_W_SBG_WThl )
CALL LES_MEAN_SUBGRID( GZ_W_M(KKA,KKU,KKL,PWM,PDZZ)*MZF(KKA,KKU,KKL,ZFLXZ),&
& X_LES_RES_ddxa_W_SBG_UaThl )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDTH_DZ*ZFLXZ), X_LES_RES_ddxa_Thl_SBG_UaThl )
- CALL LES_MEAN_SUBGRID( -XCTP*PSQRT_TKE/PLM*MZF(KKA,KKU,KKL,ZFLXZ), X_LES_SUBGRID_ThlPz )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MZM(KKA,KKU,KKL,PETHETA)*ZFLXZ), X_LES_SUBGRID_WThv )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDTH_DZ(:,:,:)*ZFLXZ(:,:,:)), X_LES_RES_ddxa_Thl_SBG_UaThl )
+ CALL LES_MEAN_SUBGRID( -XCTP*PSQRT_TKE(:,:,:)/PLM(:,:,:)*MZF(KKA,KKU,KKL,ZFLXZ), X_LES_SUBGRID_ThlPz )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MZM(KKA,KKU,KKL,PETHETA)*ZFLXZ(:,:,:)), X_LES_SUBGRID_WThv )
IF (KRR>=1) THEN
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDR_DZ*ZFLXZ), X_LES_RES_ddxa_Rt_SBG_UaThl )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDR_DZ(:,:,:)*ZFLXZ(:,:,:)), X_LES_RES_ddxa_Rt_SBG_UaThl )
END IF
!* diagnostic of mixing coefficient for heat
- ZA = DZM(KKA,KKU,KKL,PTHLP)
- WHERE (ZA==0.) ZA=1.E-6
- ZA = - ZFLXZ / ZA * PDZZ
+ ZA(:,:,:) = DZM(KKA,KKU,KKL,PTHLP)
+ WHERE (ZA(:,:,:)==0.) ZA(:,:,:)=1.E-6
+ ZA(:,:,:) = - ZFLXZ(:,:,:) / ZA(:,:,:) * PDZZ(:,:,:)
ZA(:,:,IKB) = XCSHF*PPHI3(:,:,IKB)*ZKEFF(:,:,IKB)
- ZA = MZF(KKA,KKU,KKL, ZA )
- ZA = MIN(MAX(ZA,-1000.),1000.)
+ ZA(:,:,:) = MZF(KKA,KKU,KKL, ZA )
+ ZA(:,:,:) = MIN(MAX(ZA(:,:,:),-1000.),1000.)
CALL LES_MEAN_SUBGRID( ZA, X_LES_SUBGRID_Kh )
#else
!$acc data copy(X_LES_SUBGRID_WThl,X_LES_RES_W_SBG_WThl,X_LES_RES_ddxa_W_SBG_UaThl,X_LES_RES_ddxa_Thl_SBG_UaThl,&
!$acc & X_LES_SUBGRID_ThlPz,X_LES_SUBGRID_WThv,X_LES_RES_ddxa_Rt_SBG_UaThl,X_LES_SUBGRID_Kh)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ, ZTMP1_DEVICE)
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WThl )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WThl )
!$acc kernels
- ZTMP1_DEVICE = PWM*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PWM(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE, ZTMP2_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_RES_W_SBG_WThl )
CALL GZ_W_M_DEVICE(KKA,KKU,KKL,PWM,PDZZ,ZTMP1_DEVICE )
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_W_SBG_UaThl )
!$acc kernels
- ZTMP1_DEVICE = PDTH_DZ*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PDTH_DZ(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaThl )
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = -XCTP*PSQRT_TKE/PLM*ZTMP1_DEVICE
+ ZTMP2_DEVICE(:,:,:) = -XCTP*PSQRT_TKE(:,:,:)/PLM(:,:,:)*ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_SUBGRID_ThlPz )
CALL MZM_DEVICE(PETHETA,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_SUBGRID_WThv )
IF (KRR>=1) THEN
!$acc kernels
- ZTMP1_DEVICE = PDR_DZ*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PDR_DZ(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_RES_ddxa_Rt_SBG_UaThl )
@@ -965,13 +965,13 @@ IF (LLES_CALL) THEN
!* diagnostic of mixing coefficient for heat
CALL DZM_DEVICE(KKA,KKU,KKL,PTHLP,ZA)
!$acc kernels
- WHERE (ZA==0.) ZA=1.E-6
- ZA = - ZFLXZ / ZA * PDZZ
+ WHERE (ZA(:,:,:)==0.) ZA(:,:,:)=1.E-6
+ ZA(:,:,:) = - ZFLXZ(:,:,:) / ZA(:,:,:) * PDZZ(:,:,:)
ZA(:,:,IKB) = XCSHF*PPHI3(:,:,IKB)*ZKEFF(:,:,IKB)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZA, ZA )
!$acc kernels
- ZA = MIN(MAX(ZA,-1000.),1000.)
+ ZA(:,:,:) = MIN(MAX(ZA(:,:,:),-1000.),1000.)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZA, X_LES_SUBGRID_Kh )
!$acc end data
@@ -999,17 +999,17 @@ IF (KRR /= 0) THEN
! Compute the turbulent flux F and F' at time t-dt.
!
#ifndef MNH_OPENACC
- ZF (:,:,:) = -XCSHF*PPSI3*ZKEFF*DZM(KKA,KKU,KKL,PRM(:,:,:,1))/PDZZ
- ZDFDDRDZ(:,:,:) = -XCSHF*ZKEFF*D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV)
+ ZF (:,:,:) = -XCSHF*PPSI3(:,:,:)*ZKEFF(:,:,:)*DZM(KKA,KKU,KKL,PRM(:,:,:,1))/PDZZ(:,:,:)
+ ZDFDDRDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,GUSERV)
#else
CALL DZM_DEVICE(KKA,KKU,KKL,PRM(:,:,:,1),ZTMP1_DEVICE)
!$acc kernels
- ZF (:,:,:) = -XCSHF*PPSI3*ZKEFF*ZTMP1_DEVICE/PDZZ
+ ZF (:,:,:) = -XCSHF*PPSI3(:,:,:)*ZKEFF(:,:,:)*ZTMP1_DEVICE(:,:,:)/PDZZ(:,:,:)
!$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
+ ZDFDDRDZ(:,:,:) = -XCSHF*ZKEFF(:,:,:)*ZTMP1_DEVICE(:,:,:)
!$acc end kernels
#endif
!
@@ -1018,23 +1018,23 @@ IF (KRR /= 0) THEN
! d(w'2r')/dz
#ifndef MNH_OPENACC
IF (GFWR) THEN
- Z3RDMOMENT= M3_WR_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,PTKEM)
+ Z3RDMOMENT(:,:,:)= M3_WR_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,PTKEM)
!
- ZF = ZF + Z3RDMOMENT * PFWR
- ZDFDDRDZ = ZDFDDRDZ + D_M3_WR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
- & PBLL_O_E,PEMOIST,ZKEFF,PTKEM) * PFWR
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * PFWR(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_WR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
+ & PBLL_O_E,PEMOIST,ZKEFF,PTKEM) * PFWR(:,:,:)
END IF
#else
IF (GFWR) THEN
CALL M3_WR_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,PTKEM,Z3RDMOMENT)
!
!$acc kernels
- ZF = ZF + Z3RDMOMENT * PFWR
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * PFWR(:,:,:)
!$acc end kernels
CALL D_M3_WR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
& PBLL_O_E,PEMOIST,ZKEFF,PTKEM,ZTMP1_DEVICE)
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * PFWR
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFWR(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1042,10 +1042,10 @@ IF (KRR /= 0) THEN
! d(w'r'2)/dz
#ifndef MNH_OPENACC
IF (GFR2) THEN
- Z3RDMOMENT= M3_WR_WR2(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST)
+ Z3RDMOMENT(:,:,:)= M3_WR_WR2(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST)
!
- ZF = ZF + Z3RDMOMENT * MZM(KKA,KKU,KKL,PFR2)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_WR_WR2_O_DDRDZ(Z3RDMOMENT,PREDR1,&
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * MZM(KKA,KKU,KKL,PFR2)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_WR_WR2_O_DDRDZ(Z3RDMOMENT,PREDR1,&
& PREDTH1,PD,PBLL_O_E,PEMOIST) * MZM(KKA,KKU,KKL,PFR2)
END IF
#else
@@ -1054,12 +1054,12 @@ IF (KRR /= 0) THEN
!
CALL MZM_DEVICE(PFR2,ZTMP1_DEVICE)
!$acc kernels
- ZF = ZF + Z3RDMOMENT * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL D_M3_WR_WR2_O_DDRDZ(Z3RDMOMENT,PREDR1,&
& PREDTH1,PD,PBLL_O_E,PEMOIST,ZTMP2_DEVICE)
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1067,22 +1067,22 @@ IF (KRR /= 0) THEN
! d(w'2th')/dz
#ifndef MNH_OPENACC
IF (GFWTH) THEN
- ZF = ZF + M3_WR_W2TH(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,&
- & PTKEM,PBLL_O_E,PETHETA,PDR_DZ) * PFWTH
- ZDFDDRDZ = ZDFDDRDZ + D_M3_WR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
- & PD,ZKEFF,PTKEM,PBLL_O_E,PETHETA) * PFWTH
+ ZF(:,:,:) = ZF(:,:,:) + M3_WR_W2TH(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,&
+ & PTKEM,PBLL_O_E,PETHETA,PDR_DZ) * PFWTH(:,:,:)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_WR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
+ & PD,ZKEFF,PTKEM,PBLL_O_E,PETHETA) * PFWTH(:,:,:)
END IF
#else
IF (GFWTH) THEN
CALL M3_WR_W2TH(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,&
& PTKEM,PBLL_O_E,PETHETA,PDR_DZ,ZTMP1_DEVICE)
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * PFWTH
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFWTH(:,:,:)
!$acc end kernels
CALL D_M3_WR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,&
& PD,ZKEFF,PTKEM,PBLL_O_E,PETHETA,ZTMP1_DEVICE)
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * PFWTH
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * PFWTH(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1090,9 +1090,9 @@ IF (KRR /= 0) THEN
! d(w'th'2)/dz
#ifndef MNH_OPENACC
IF (GFTH2) THEN
- ZF = ZF + M3_WR_WTH2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,PTKEM,&
+ ZF(:,:,:) = ZF(:,:,:) + M3_WR_WTH2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,ZKEFF,PTKEM,&
& PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PDR_DZ) * MZM(KKA,KKU,KKL,PFTH2)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_WR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_WR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
&ZKEFF,PTKEM,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA) * MZM(KKA,KKU,KKL,PFTH2)
END IF
#else
@@ -1101,12 +1101,12 @@ IF (KRR /= 0) THEN
& PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PDR_DZ,ZTMP1_DEVICE)
CALL MZM_DEVICE(PFTH2,ZTMP2_DEVICE)
!$acc kernels
- ZF = ZF + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
CALL D_M3_WR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,&
&ZKEFF,PTKEM,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,ZTMP1_DEVICE)
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP1_DEVICE * ZTMP2_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZTMP2_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1114,11 +1114,11 @@ IF (KRR /= 0) THEN
! d(w'th'r')/dz
#ifndef MNH_OPENACC
IF (GFTHR) THEN
- Z3RDMOMENT= M3_WR_WTHR(KKA,KKU,KKL,PREDTH1,PD,ZKEFF,PTKEM,PSQRT_TKE,PBETA,&
+ Z3RDMOMENT(:,:,:)= M3_WR_WTHR(KKA,KKU,KKL,PREDTH1,PD,ZKEFF,PTKEM,PSQRT_TKE,PBETA,&
& PLEPS,PETHETA)
!
- ZF = ZF + Z3RDMOMENT * MZM(KKA,KKU,KKL,PFTHR)
- ZDFDDRDZ = ZDFDDRDZ + D_M3_WR_WTHR_O_DDRDZ(KKA,KKU,KKL,Z3RDMOMENT,PREDR1, &
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * MZM(KKA,KKU,KKL,PFTHR)
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + D_M3_WR_WTHR_O_DDRDZ(KKA,KKU,KKL,Z3RDMOMENT,PREDR1, &
& PREDTH1,PD,PBLL_O_E,PEMOIST) * MZM(KKA,KKU,KKL,PFTHR)
END IF
#else
@@ -1128,12 +1128,12 @@ IF (KRR /= 0) THEN
!
CALL MZM_DEVICE(PFTHR,ZTMP1_DEVICE)
!$acc kernels
- ZF = ZF + Z3RDMOMENT * ZTMP1_DEVICE
+ ZF(:,:,:) = ZF(:,:,:) + Z3RDMOMENT(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL D_M3_WR_WTHR_O_DDRDZ(KKA,KKU,KKL,Z3RDMOMENT,PREDR1, &
& PREDTH1,PD,PBLL_O_E,PEMOIST,ZTMP2_DEVICE)
!$acc kernels
- ZDFDDRDZ = ZDFDDRDZ + ZTMP2_DEVICE * ZTMP1_DEVICE
+ ZDFDDRDZ(:,:,:) = ZDFDDRDZ(:,:,:) + ZTMP2_DEVICE(:,:,:) * ZTMP1_DEVICE(:,:,:)
!$acc end kernels
END IF
#endif
@@ -1172,15 +1172,15 @@ IF (KRR /= 0) THEN
! cons. mixing ratio flux :
!
#ifndef MNH_OPENACC
- ZFLXZ(:,:,:) = ZF &
- + PIMPL * ZDFDDRDZ * DZM(KKA,KKU,KKL,PRP - PRM(:,:,:,1)) / PDZZ
+ ZFLXZ(:,:,:) = ZF(:,:,:) &
+ + PIMPL * ZDFDDRDZ(:,:,:) * DZM(KKA,KKU,KKL,PRP - PRM(:,:,:,1)) / PDZZ(:,:,:)
#else
!$acc kernels
- ZTMP1_DEVICE = PRP - PRM(:,:,:,1)
+ ZTMP1_DEVICE(:,:,:) = PRP(:,:,:) - PRM(:,:,:,1)
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZFLXZ(:,:,:) = ZF + PIMPL * ZDFDDRDZ *ZTMP2_DEVICE / PDZZ
+ ZFLXZ(:,:,:) = ZF(:,:,:) + PIMPL * ZDFDDRDZ(:,:,:) *ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:)
!$acc end kernels
#endif
!
@@ -1214,15 +1214,15 @@ IF (KRR /= 0) THEN
!
! Contribution of the conservative water flux to the Buoyancy flux
#ifndef MNH_OPENACC
- ZA(:,:,:) = PBETA * MZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL,PEMOIST) * ZFLXZ )
+ ZA(:,:,:) = PBETA(:,:,:) * MZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL,PEMOIST) * ZFLXZ(:,:,:) )
#else
CALL MZM_DEVICE(PEMOIST,ZTMP1_DEVICE)
!$acc kernels
- ZTMP2_DEVICE = ZTMP1_DEVICE * ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP2_DEVICE, ZTMP3_DEVICE )
!$acc kernels
- ZA(:,:,:) = PBETA * ZTMP3_DEVICE
+ ZA(:,:,:) = PBETA(:,:,:) * ZTMP3_DEVICE(:,:,:)
#endif
ZA(:,:,IKB) = PBETA(:,:,IKB) * PEMOIST(:,:,IKB) * &
0.5 * ( ZFLXZ (:,:,IKB) + ZFLXZ (:,:,IKB+KKL) )
@@ -1232,11 +1232,11 @@ IF (KRR /= 0) THEN
! Buoyancy flux at flux points
!
#ifndef MNH_OPENACC
- PWTHV = PWTHV + MZM(KKA,KKU,KKL,PEMOIST) * ZFLXZ
+ PWTHV(:,:,:) = PWTHV(:,:,:) + MZM(KKA,KKU,KKL,PEMOIST) * ZFLXZ(:,:,:)
#else
CALL MZM_DEVICE(PEMOIST,ZTMP1_DEVICE)
!$acc kernels
- PWTHV = PWTHV + ZTMP1_DEVICE * ZFLXZ
+ PWTHV(:,:,:) = PWTHV(:,:,:) + ZTMP1_DEVICE(:,:,:) * ZFLXZ(:,:,:)
#endif
PWTHV(:,:,IKB) = PWTHV(:,:,IKB) + PEMOIST(:,:,IKB) * ZFLXZ(:,:,IKB)
!$acc end kernels
@@ -1247,42 +1247,42 @@ IF (KRR /= 0) THEN
IF ( KRRL >= 1 ) THEN
IF ( KRRI >= 1 ) THEN
PRRS(:,:,:,2) = PRRS(:,:,:,2) - &
- DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ*PAMOIST*2.*PSRCM )*ZFLXZ/PDZZ ) &
+ DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ(:,:,:)*PAMOIST(:,:,:)*2.*PSRCM(:,:,:) )*ZFLXZ(:,:,:)/PDZZ(:,:,:) ) &
*(1.0-PFRAC_ICE(:,:,:))
PRRS(:,:,:,4) = PRRS(:,:,:,4) - &
- DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ*PAMOIST*2.*PSRCM )*ZFLXZ/PDZZ ) &
+ DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ(:,:,:)*PAMOIST(:,:,:)*2.*PSRCM(:,:,:) )*ZFLXZ(:,:,:)/PDZZ(:,:,:) ) &
*PFRAC_ICE(:,:,:)
ELSE
PRRS(:,:,:,2) = PRRS(:,:,:,2) - &
- DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ*PAMOIST*2.*PSRCM )*ZFLXZ/PDZZ )
+ DZF(KKA,KKU,KKL, MZM(KKA,KKU,KKL, PRHODJ(:,:,:)*PAMOIST(:,:,:)*2.*PSRCM(:,:,:) )*ZFLXZ(:,:,:)/PDZZ(:,:,:) )
END IF
END IF
#else
IF ( KRRL >= 1 ) THEN
IF ( KRRI >= 1 ) THEN
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PAMOIST*2.*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PAMOIST(:,:,:)*2.*PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLXZ/PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)/PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP4_DEVICE * (1.0-PFRAC_ICE(:,:,:))
- PRRS(:,:,:,4) = PRRS(:,:,:,4) - ZTMP4_DEVICE * PFRAC_ICE(:,:,:)
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP4_DEVICE(:,:,:) * (1.0-PFRAC_ICE(:,:,:))
+ PRRS(:,:,:,4) = PRRS(:,:,:,4) - ZTMP4_DEVICE(:,:,:) * PFRAC_ICE(:,:,:)
!$acc end kernels
ELSE
!$acc kernels
- ZTMP1_DEVICE = PRHODJ*PAMOIST*2.*PSRCM
+ ZTMP1_DEVICE(:,:,:) = PRHODJ(:,:,:)*PAMOIST(:,:,:)*2.*PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLXZ/PDZZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)/PDZZ(:,:,:)
!$acc end kernels
CALL DZF_DEVICE(KKA,KKU,KKL, ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP4_DEVICE
+ PRRS(:,:,:,2) = PRRS(:,:,:,2) - ZTMP4_DEVICE(:,:,:)
!$acc end kernels
END IF
END IF
@@ -1294,55 +1294,55 @@ IF (KRR /= 0) THEN
CALL SECOND_MNH(ZTIME1)
#ifndef MNH_OPENACC
CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,ZFLXZ), X_LES_SUBGRID_WRt )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM*ZFLXZ), X_LES_RES_W_SBG_WRt )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PWM(:,:,:)*ZFLXZ(:,:,:)), X_LES_RES_W_SBG_WRt )
CALL LES_MEAN_SUBGRID( GZ_W_M(KKA,KKU,KKL,PWM,PDZZ)*MZF(KKA,KKU,KKL,ZFLXZ),&
& X_LES_RES_ddxa_W_SBG_UaRt )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDTH_DZ*ZFLXZ), X_LES_RES_ddxa_Thl_SBG_UaRt )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDR_DZ*ZFLXZ), X_LES_RES_ddxa_Rt_SBG_UaRt )
- CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MZM(KKA,KKU,KKL,PEMOIST)*ZFLXZ), X_LES_SUBGRID_WThv , .TRUE. )
- CALL LES_MEAN_SUBGRID( -XCTP*PSQRT_TKE/PLM*MZF(KKA,KKU,KKL,ZFLXZ), X_LES_SUBGRID_RtPz )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDTH_DZ(:,:,:)*ZFLXZ(:,:,:)), X_LES_RES_ddxa_Thl_SBG_UaRt )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,PDR_DZ(:,:,:)*ZFLXZ(:,:,:)), X_LES_RES_ddxa_Rt_SBG_UaRt )
+ CALL LES_MEAN_SUBGRID( MZF(KKA,KKU,KKL,MZM(KKA,KKU,KKL,PEMOIST)*ZFLXZ(:,:,:)), X_LES_SUBGRID_WThv , .TRUE. )
+ CALL LES_MEAN_SUBGRID( -XCTP*PSQRT_TKE(:,:,:)/PLM(:,:,:)*MZF(KKA,KKU,KKL,ZFLXZ), X_LES_SUBGRID_RtPz )
#else
!$acc data copy(X_LES_SUBGRID_WRt,X_LES_RES_W_SBG_WRt,X_LES_RES_ddxa_W_SBG_UaRt,X_LES_RES_ddxa_Thl_SBG_UaRt,&
!$acc & X_LES_RES_ddxa_Rt_SBG_UaRt,X_LES_SUBGRID_WThv,X_LES_SUBGRID_RtPz)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP1_DEVICE)
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WRt )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WRt )
!
!$acc kernels
- ZTMP2_DEVICE = PWM*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = PWM(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_W_SBG_WRt )
!
!$acc kernels
- ZTMP1_DEVICE = PWM*ZFLXZ
+ ZTMP1_DEVICE(:,:,:) = PWM(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL GZ_W_M_DEVICE(KKA,KKU,KKL,PWM,PDZZ,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZTMP1_DEVICE
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_W_SBG_UaRt )
!
!$acc kernels
- ZTMP2_DEVICE = PDTH_DZ*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = PDTH_DZ(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Thl_SBG_UaRt )
!
!$acc kernels
- ZTMP2_DEVICE = PDR_DZ*ZFLXZ
+ ZTMP2_DEVICE(:,:,:) = PDR_DZ(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP3_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP3_DEVICE, X_LES_RES_ddxa_Rt_SBG_UaRt )
!
CALL MZM_DEVICE(PEMOIST,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = ZTMP2_DEVICE*ZFLXZ
+ ZTMP3_DEVICE(:,:,:) = ZTMP2_DEVICE(:,:,:)*ZFLXZ(:,:,:)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP3_DEVICE,ZTMP4_DEVICE)
CALL LES_MEAN_SUBGRID( ZTMP4_DEVICE, X_LES_SUBGRID_WThv , .TRUE. )
!
!$acc kernels
- ZTMP2_DEVICE = -XCTP*PSQRT_TKE/PLM*ZTMP1_DEVICE
+ ZTMP2_DEVICE(:,:,:) = -XCTP*PSQRT_TKE(:,:,:)/PLM(:,:,:)*ZTMP1_DEVICE(:,:,:)
!$acc end kernels
CALL LES_MEAN_SUBGRID( ZTMP2_DEVICE, X_LES_SUBGRID_RtPz )
!$acc end data
@@ -1366,39 +1366,39 @@ IF ( ((OTURB_FLX .AND. OCLOSE_OUT) .OR. LLES_CALL) .AND. (KRRL > 0) ) THEN
!
! recover the Conservative potential temperature flux :
#ifndef MNH_OPENACC
- ZA(:,:,:) = DZM(KKA,KKU,KKL,PIMPL * PTHLP + PEXPL * PTHLM) / PDZZ * &
- (-PPHI3*MZM(KKA,KKU,KKL,PLM*PSQRT_TKE)) * XCSHF
+ ZA(:,:,:) = DZM(KKA,KKU,KKL,PIMPL * PTHLP(:,:,:) + PEXPL * PTHLM(:,:,:)) / PDZZ(:,:,:) * &
+ (-PPHI3(:,:,:)*MZM(KKA,KKU,KKL,PLM(:,:,:)*PSQRT_TKE(:,:,:))) * XCSHF
#else
!$acc kernels
- ZTMP1_DEVICE = PIMPL * PTHLP + PEXPL * PTHLM
+ ZTMP1_DEVICE(:,:,:) = PIMPL * PTHLP(:,:,:) + PEXPL * PTHLM(:,:,:)
!$acc end kernels
CALL DZM_DEVICE(KKA,KKU,KKL,ZTMP1_DEVICE,ZTMP2_DEVICE)
!$acc kernels
- ZTMP3_DEVICE = PLM*PSQRT_TKE
+ ZTMP3_DEVICE(:,:,:) = PLM(:,:,:)*PSQRT_TKE(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP3_DEVICE,ZTMP4_DEVICE)
!$acc kernels
- ZA(:,:,:) = ZTMP2_DEVICE / PDZZ * (-PPHI3*ZTMP4_DEVICE) * XCSHF
+ ZA(:,:,:) = ZTMP2_DEVICE(:,:,:) / PDZZ(:,:,:) * (-PPHI3(:,:,:)*ZTMP4_DEVICE(:,:,:)) * XCSHF
#endif
ZA(:,:,IKB) = ( PIMPL*PSFTHP(:,:) + PEXPL*PSFTHM(:,:) ) * PDIRCOSZW(:,:)
!$acc end kernels
!
! compute <w Rc>
#ifndef MNH_OPENACC
- ZFLXZ(:,:,:) = MZM(KKA,KKU,KKL, PAMOIST * 2.* PSRCM ) * ZFLXZ(:,:,:) + &
- MZM(KKA,KKU,KKL, PATHETA * 2.* PSRCM ) * ZA(:,:,:)
+ ZFLXZ(:,:,:) = MZM(KKA,KKU,KKL, PAMOIST(:,:,:) * 2.* PSRCM(:,:,:) ) * ZFLXZ(:,:,:) + &
+ MZM(KKA,KKU,KKL, PATHETA(:,:,:) * 2.* PSRCM(:,:,:) ) * ZA(:,:,:)
#else
!$acc kernels
- ZTMP1_DEVICE = PAMOIST * 2.* PSRCM
+ ZTMP1_DEVICE(:,:,:) = PAMOIST(:,:,:) * 2.* PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP1_DEVICE, ZTMP2_DEVICE )
!$acc kernels
- ZTMP3_DEVICE =PATHETA * 2.* PSRCM
+ ZTMP3_DEVICE(:,:,:) =PATHETA(:,:,:) * 2.* PSRCM(:,:,:)
!$acc end kernels
CALL MZM_DEVICE(ZTMP3_DEVICE, ZTMP4_DEVICE )
!$acc kernels
- ZFLXZ(:,:,:) = ZTMP2_DEVICE * ZFLXZ(:,:,:) + &
- ZTMP4_DEVICE * ZA(:,:,:)
+ ZFLXZ(:,:,:) = ZTMP2_DEVICE(:,:,:) * ZFLXZ(:,:,:) + &
+ ZTMP4_DEVICE(:,:,:) * ZA(:,:,:)
#endif
ZFLXZ(:,:,KKA) = ZFLXZ(:,:,IKB)
!$acc end kernels
@@ -1428,7 +1428,7 @@ IF ( ((OTURB_FLX .AND. OCLOSE_OUT) .OR. LLES_CALL) .AND. (KRRL > 0) ) THEN
#else
!$acc data copy(X_LES_SUBGRID_WRc)
CALL MZF_DEVICE(KKA,KKU,KKL,ZFLXZ,ZTMP1_DEVICE)
- CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WRc )
+ CALL LES_MEAN_SUBGRID( ZTMP1_DEVICE, X_LES_SUBGRID_WRc )
!$acc end data
#endif
CALL SECOND_MNH(ZTIME2)