Forked from
Méso-NH / Méso-NH code
2927 commits behind, 418 commits ahead of the upstream repository.
-
Juan Escobar authoredJuan 19/06/2020:mode_prandtl.f90 , Bug (ifort identifaction) replace routine-name->array-name : M3_WTH_W2TH(:,:,:) -> PM3_WTH_W2TH(:,:,:)
Juan Escobar authoredJuan 19/06/2020:mode_prandtl.f90 , Bug (ifort identifaction) replace routine-name->array-name : M3_WTH_W2TH(:,:,:) -> PM3_WTH_W2TH(:,:,:)
mode_prandtl.f90 124.18 KiB
!MNH_LIC Copyright 1994-2020 CNRS, Meteo-France and Universite Paul Sabatier
!MNH_LIC This is part of the Meso-NH software governed by the CeCILL-C licence
!MNH_LIC version 1. See LICENSE, CeCILL-C_V1-en.txt and CeCILL-C_V1-fr.txt
!MNH_LIC for details. version 1.
!-----------------------------------------------------------------
! ####################
MODULE MODE_PRANDTL
! ####################
!
!* modification 08/2010 V. Masson smoothing of the discontinuity in functions
! used for implicitation of exchange coefficients
!
USE MODD_CTURB, ONLY : XCTV, XCSHF, XCTD, XPHI_LIM, XCPR3, XCPR4, XCPR5
USE MODD_PARAMETERS, ONLY : JPVEXT_TURB
#ifdef MNH_OPENACC
use mode_msg
#endif
#ifdef MNH_BITREP
USE MODI_BITREP
#endif
#ifndef MNH_OPENACC
USE MODI_SHUMAN
#else
USE MODI_SHUMAN_DEVICE
#endif
!
IMPLICIT NONE
!----------------------------------------------------------------------------
CONTAINS
!----------------------------------------------------------------------------
SUBROUTINE SMOOTH_TURB_FUNCT(PPHI3,PF_LIM,PF)
!
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPHI3 ! Phi3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PF_LIM ! Value of F when Phi3 is
! ! larger than Phi_lim
REAL, DIMENSION(:,:,:), INTENT(INOUT) :: PF ! function F to smooth
!
REAL, DIMENSION(SIZE(PF,1),SIZE(PF,2),SIZE(PF,3)) :: ZCOEF
!$acc data present( PPHI3, PF_LIM, PF ) create( ZCOEF )
!* adds a artificial correction to smooth the function near the discontinuity
! point at Phi3 = Phi_lim
! This smoothing is applied between 0.9*phi_lim (=2.7) and Phi_lim (=3)
! Note that in the Boundary layer, phi is usually between 0.8 and 1
!
!
!$acc kernels
ZCOEF = MAX(MIN(( 10.*(1.-PPHI3/XPHI_LIM)) ,1.), 0.)
!
PF(:,:,:) = ZCOEF(:,:,:) * PF &
+ (1.-ZCOEF(:,:,:)) * PF_LIM
!$acc end kernels
!$acc end data
END SUBROUTINE SMOOTH_TURB_FUNCT
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION PHI3(PREDTH1,PREDR1,PRED2TH3,PRED2R3,PRED2THR3,HTURBDIM,OUSERV) RESULT(PPHI3)
#else
SUBROUTINE PHI3(PREDTH1,PREDR1,PRED2TH3,PRED2R3,PRED2THR3,HTURBDIM,OUSERV,PPHI3)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2TH3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2R3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3 CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PPHI3
#else
REAL, DIMENSION(:,:,:), INTENT(OUT) :: PPHI3
#endif
!
INTEGER :: IKB, IKE
LOGICAL,DIMENSION(:,:,:), allocatable :: PHI3LOGIC
REAL, DIMENSION(:,:,:), allocatable :: ZW1, ZW2
!$acc data present( PREDTH1, PREDR1, PRED2TH3, PRED2R3, PRED2THR3, PPHI3 )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
allocate( zw1 ( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
allocate( zw2 ( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
allocate( phi3logic( size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
!$acc data create( zw1, zw2, phi3logic )
!$acc kernels
IF (HTURBDIM=='3DIM') THEN
!* 3DIM case
IF (OUSERV) THEN
ZW1(:,:,:) = 1. + 1.5* (PREDTH1(:,:,:)+PREDR1(:,:,:)) + &
#ifndef MNH_BITREP
( 0.5 * (PREDTH1(:,:,:)**2+PREDR1(:,:,:)**2) &
#else
( 0.5 * (BR_P2(PREDTH1(:,:,:))+BR_P2(PREDR1(:,:,:))) &
#endif
+ PREDTH1(:,:,:) * PREDR1(:,:,:) &
)
ZW2(:,:,:) = 0.5 * (PRED2TH3(:,:,:)-PRED2R3(:,:,:))
PPHI3(:,:,:)= 1. - &
( ( (1.+PREDR1(:,:,:)) * &
(PRED2THR3(:,:,:) + PRED2TH3(:,:,:)) / PREDTH1(:,:,:) &
) + ZW2(:,:,:) &
) / ZW1(:,:,:)
ELSE
ZW1(:,:,:) = 1. + 1.5* PREDTH1(:,:,:) + &
#ifndef MNH_BITREP
0.5* PREDTH1(:,:,:)**2
#else
0.5* BR_P2(PREDTH1(:,:,:))
#endif
ZW2(:,:,:) = 0.5* PRED2TH3(:,:,:)
PPHI3(:,:,:)= 1. - &
(PRED2TH3(:,:,:) / PREDTH1(:,:,:) + ZW2(:,:,:)) / ZW1(:,:,:)
END IF
!
!WARNING: BUG PGI (tested up to PGI 16.10): necessary to use a logical mask
!because the compiler does not manage correctly the .OR. in the WHERE
!WHERE( PPHI3 <= 0. .OR. PPHI3 > XPHI_LIM )
PHI3LOGIC = (PPHI3 <= 0. .OR. PPHI3 > XPHI_LIM)
WHERE( PHI3LOGIC )
PPHI3 = XPHI_LIM
END WHERE
ELSE
!* 1DIM case
IF (OUSERV) THEN
PPHI3(:,:,:)= 1./(1.+PREDTH1(:,:,:)+PREDR1(:,:,:))
ELSE
PPHI3(:,:,:)= 1./(1.+PREDTH1(:,:,:))
END IF
END IF
!PPHI3(:,:,IKB-1)=PPHI3(:,:,IKB)
PPHI3(:,:,IKE+1)=PPHI3(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION PHI3
#else
END SUBROUTINE PHI3
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION PSI_SV(PREDTH1,PREDR1,PREDS1,PRED2THS,PRED2RS,PPHI3,PPSI3) RESULT(PPSI_SV)
#else
SUBROUTINE PSI_SV(PREDTH1,PREDR1,PREDS1,PRED2THS,PRED2RS,PPHI3,PPSI3,PPSI_SV)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:,:), INTENT(IN) :: PREDS1
REAL, DIMENSION(:,:,:,:), INTENT(IN) :: PRED2THS
REAL, DIMENSION(:,:,:,:), INTENT(IN) :: PRED2RS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPHI3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPSI3
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PRED2THS,1),SIZE(PRED2THS,2),SIZE(PRED2THS,3),SIZE(PRED2THS,4)) :: PPSI_SV
#else
REAL, DIMENSION(:,:,:,:), INTENT(OUT) :: PPSI_SV
#endif
!
INTEGER :: IKB, IKE
INTEGER :: JSV
LOGICAL, DIMENSION(:,:,:), allocatable :: PSILOGIC
!$acc data present( PREDTH1, PREDR1, PREDS1, PRED2THS, PRED2RS, PPHI3, PPSI3, PPSI_SV )
allocate( psilogic( size( pred2ths, 1 ), size( pred2ths, 2 ), size( pred2ths, 3 ) ) )
!$acc data create( psilogic )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
!
!$acc kernels
DO JSV=1,SIZE(PPSI_SV,4)
PPSI_SV(:,:,:,JSV) = ( 1. &
- (XCPR3+XCPR5) * (PRED2THS(:,:,:,JSV)/PREDS1(:,:,:,JSV)-PREDTH1) &
- (XCPR4+XCPR5) * (PRED2RS (:,:,:,JSV)/PREDS1(:,:,:,JSV)-PREDR1 ) &
- XCPR3 * PREDTH1 * PPHI3 - XCPR4 * PREDR1 * PPSI3 &
) / ( 1. + XCPR5 * ( PREDTH1 + PREDR1 ) )
! control of the PPSI_SV positivity
!WARNING: BUG PGI (tested up to PGI 16.10): necessary to use a logical mask
!because the compiler does not manage correctly the .AND. in the WHERE
!Failure during execution
!WHERE ( (PPSI_SV(:,:,:,JSV) <=0.).AND. (PREDTH1+PREDR1) <= 0. )
PSILOGIC = ((PPSI_SV(:,:,:,JSV) <=0.).AND. (PREDTH1+PREDR1) <= 0. )
WHERE ( PSILOGIC )
PPSI_SV(:,:,:,JSV)=XPHI_LIM
END WHERE
PPSI_SV(:,:,:,JSV) = MAX( 1.E-4, MIN(XPHI_LIM,PPSI_SV(:,:,:,JSV)) )
!
PPSI_SV(:,:,IKB-1,JSV)=PPSI_SV(:,:,IKB,JSV)
PPSI_SV(:,:,IKE+1,JSV)=PPSI_SV(:,:,IKE,JSV)
END DO
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION PSI_SV
#else
END SUBROUTINE PSI_SV
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV) RESULT(PD_PHI3DTDZ_O_DDTDZ)
#else
SUBROUTINE D_PHI3DTDZ_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV,PD_PHI3DTDZ_O_DDTDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPHI3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2TH3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PD_PHI3DTDZ_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)), INTENT(OUT) :: PD_PHI3DTDZ_O_DDTDZ
#endif
INTEGER :: IKB, IKE,JL,JK,JJ
!$acc data present( PPHI3, PREDTH1, PREDR1, PRED2TH3, PRED2THR3, PD_PHI3DTDZ_O_DDTDZ )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
!
!$acc kernels
IF (HTURBDIM=='3DIM') THEN
!* 3DIM case
IF (OUSERV) THEN
WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DTDZ_O_DDTDZ(:,:,:) = PPHI3(:,:,:) &
* (1. - PREDTH1(:,:,:) * (3./2.+PREDTH1+PREDR1) &
/((1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1)))) &
+ (1.+PREDR1)*(PRED2THR3+PRED2TH3) &
/ (PREDTH1*(1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1))) &
- (1./2.*PREDTH1+PREDR1 * (1.+PREDTH1+PREDR1)) &
/ ((1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1)))
ELSEWHERE
PD_PHI3DTDZ_O_DDTDZ(:,:,:) = PPHI3(:,:,:)
ENDWHERE
!
ELSE
WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DTDZ_O_DDTDZ(:,:,:) = PPHI3(:,:,:) &
* (1. - PREDTH1(:,:,:) * (3./2.+PREDTH1) &
/((1.+PREDTH1)*(1.+1./2.*PREDTH1))) &
+ PRED2TH3 / (PREDTH1*(1.+PREDTH1)*(1.+1./2.*PREDTH1)) &
- 1./2.*PREDTH1 / ((1.+PREDTH1)*(1.+1./2.*PREDTH1))
ELSEWHERE
PD_PHI3DTDZ_O_DDTDZ(:,:,:) = PPHI3(:,:,:)
ENDWHERE
!
END IF
ELSE
!* 1DIM case
! WHERE (PPHI3(:,:,:)<=XPHI_LIM)
! PD_PHI3DTDZ_O_DDTDZ(:,:,:) = PPHI3(:,:,:) &
! * (1. - PREDTH1(:,:,:)*PPHI3(:,:,:))
! ELSEWHERE
! PD_PHI3DTDZ_O_DDTDZ(:,:,:) = PPHI3(:,:,:)
! ENDWHEREDO JJ=1,SIZE(PPHI3,2)
DO JL=1,SIZE(PPHI3,1)
DO JK=1,SIZE(PPHI3,3)
IF ( ABS(PPHI3(JL,JJ,JK)-XPHI_LIM) < 1.E-12 ) THEN
PD_PHI3DTDZ_O_DDTDZ(JL,JJ,JK)=PPHI3(JL,JJ,JK)*&
& (1. - PREDTH1(JL,JJ,JK)*PPHI3(JL,JJ,JK))
ELSE
PD_PHI3DTDZ_O_DDTDZ(JL,JJ,JK)=PPHI3(JL,JJ,JK)
ENDIF
ENDDO
ENDDO
ENDDO
END IF
!$acc end kernels
!
!* smoothing
CALL SMOOTH_TURB_FUNCT(PPHI3,PPHI3,PD_PHI3DTDZ_O_DDTDZ)
!
!$acc kernels
PD_PHI3DTDZ_O_DDTDZ(:,:,IKB-1)=PD_PHI3DTDZ_O_DDTDZ(:,:,IKB)
PD_PHI3DTDZ_O_DDTDZ(:,:,IKE+1)=PD_PHI3DTDZ_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_PHI3DTDZ_O_DDTDZ
#else
END SUBROUTINE D_PHI3DTDZ_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_PHI3DRDZ_O_DDRDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV) RESULT(PD_PHI3DRDZ_O_DDRDZ)
#else
SUBROUTINE D_PHI3DRDZ_O_DDRDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV,PD_PHI3DRDZ_O_DDRDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPHI3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2TH3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PD_PHI3DRDZ_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)), INTENT(OUT) :: PD_PHI3DRDZ_O_DDRDZ
#endif
INTEGER :: IKB, IKE
!$acc data present( PPHI3, PREDTH1, PREDR1, PRED2TH3, PRED2THR3, PD_PHI3DRDZ_O_DDRDZ )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
!
!
!$acc kernels
IF (HTURBDIM=='3DIM') THEN
!* 3DIM case
IF (OUSERV) THEN
WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DRDZ_O_DDRDZ(:,:,:) = &
PPHI3(:,:,:) * (1.-PREDR1(:,:,:)*(3./2.+PREDTH1+PREDR1) &
/ ((1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1)))) &
- PREDR1(:,:,:) * (PRED2THR3+PRED2TH3) / (PREDTH1 &
* (1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1))) &
+ PREDR1(:,:,:) * (1./2.+PREDTH1+PREDR1) &
/ ((1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1)))
ELSEWHERE
PD_PHI3DRDZ_O_DDRDZ(:,:,:) = PPHI3(:,:,:) END WHERE
ELSE
PD_PHI3DRDZ_O_DDRDZ(:,:,:) = PPHI3(:,:,:)
END IF
ELSE
!* 1DIM case
WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DRDZ_O_DDRDZ(:,:,:) = PPHI3(:,:,:) &
* (1. - PREDR1(:,:,:)*PPHI3(:,:,:))
ELSEWHERE
PD_PHI3DRDZ_O_DDRDZ(:,:,:) = PPHI3(:,:,:)
END WHERE
END IF
!$acc end kernels
!
!* smoothing
CALL SMOOTH_TURB_FUNCT(PPHI3,PPHI3,PD_PHI3DRDZ_O_DDRDZ)
!
!$acc kernels
PD_PHI3DRDZ_O_DDRDZ(:,:,IKB-1)=PD_PHI3DRDZ_O_DDRDZ(:,:,IKB)
PD_PHI3DRDZ_O_DDRDZ(:,:,IKE+1)=PD_PHI3DRDZ_O_DDRDZ(:,:,IKE)
!$acc end kernels
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_PHI3DRDZ_O_DDRDZ
#else
END SUBROUTINE D_PHI3DRDZ_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_PHI3DTDZ2_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,PDTDZ,HTURBDIM,OUSERV) RESULT(PD_PHI3DTDZ2_O_DDTDZ)
#else
SUBROUTINE D_PHI3DTDZ2_O_DDTDZ(PPHI3,PREDTH1,PREDR1,PRED2TH3,PRED2THR3,PDTDZ,HTURBDIM,OUSERV,PD_PHI3DTDZ2_O_DDTDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPHI3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2TH3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PD_PHI3DTDZ2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)),INTENT(OUT) :: PD_PHI3DTDZ2_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
#endif
!$acc data present( PPHI3, PREDTH1, PREDR1, PRED2TH3, PRED2THR3, PDTDZ, PD_PHI3DTDZ2_O_DDTDZ )
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( predth1, 1 ), size( predth1, 2 ), size( predth1, 3 ) ) )
#endif
!$acc data create( ztmp1_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PREDTH1,3)-JPVEXT_TURB
!
!
!$acc kernels
IF (HTURBDIM=='3DIM') THEN
!* 3DIM case
IF (OUSERV) THEN WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DTDZ2_O_DDTDZ(:,:,:) = PPHI3(:,:,:) &
* PDTDZ(:,:,:)*(2.-PREDTH1(:,:,:)*(3./2.+PREDTH1+PREDR1) &
/((1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1)))) &
+ (1.+PREDR1)*(PRED2THR3+PRED2TH3) &
/ (PREDTH1*(1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1))) &
- (1./2.*PREDTH1+PREDR1 * (1.+PREDTH1+PREDR1)) &
/ ((1.+PREDTH1+PREDR1)*(1.+1./2.*(PREDTH1+PREDR1)))
ELSEWHERE
PD_PHI3DTDZ2_O_DDTDZ(:,:,:) = PPHI3(:,:,:) * 2. * PDTDZ(:,:,:)
ENDWHERE
!
ELSE
WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DTDZ2_O_DDTDZ(:,:,:) = PPHI3(:,:,:) &
* PDTDZ(:,:,:)*(2.-PREDTH1(:,:,:)*(3./2.+PREDTH1) &
/((1.+PREDTH1)*(1.+1./2.*PREDTH1))) &
+ PRED2TH3 / (PREDTH1*(1.+PREDTH1)*(1.+1./2.*PREDTH1)) &
- 1./2.*PREDTH1 / ((1.+PREDTH1)*(1.+1./2.*PREDTH1))
ELSEWHERE
PD_PHI3DTDZ2_O_DDTDZ(:,:,:) = PPHI3(:,:,:) * 2. * PDTDZ(:,:,:)
ENDWHERE
END IF
ELSE
!* 1DIM case
WHERE (PPHI3(:,:,:)<=XPHI_LIM)
PD_PHI3DTDZ2_O_DDTDZ(:,:,:) = PPHI3(:,:,:)*PDTDZ(:,:,:) &
* (2. - PREDTH1(:,:,:)*PPHI3(:,:,:))
ELSEWHERE
PD_PHI3DTDZ2_O_DDTDZ(:,:,:) = PPHI3(:,:,:) * 2. * PDTDZ(:,:,:)
END WHERE
END IF
!
!* smoothing
#ifndef MNH_OPENACC
CALL SMOOTH_TURB_FUNCT(PPHI3,PPHI3*2.*PDTDZ,PD_PHI3DTDZ2_O_DDTDZ)
#else
ZTMP1_DEVICE = PPHI3*2.*PDTDZ
!$acc end kernels
CALL SMOOTH_TURB_FUNCT(PPHI3,ZTMP1_DEVICE,PD_PHI3DTDZ2_O_DDTDZ)
#endif
!
!
!$acc kernels
PD_PHI3DTDZ2_O_DDTDZ(:,:,IKB-1)=PD_PHI3DTDZ2_O_DDTDZ(:,:,IKB)
PD_PHI3DTDZ2_O_DDTDZ(:,:,IKE+1)=PD_PHI3DTDZ2_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_PHI3DTDZ2_O_DDTDZ
#else
END SUBROUTINE D_PHI3DTDZ2_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WTH_WTH2(PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA) RESULT(PM3_WTH_WTH2)
#else
SUBROUTINE M3_WTH_WTH2(PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA,PM3_WTH_WTH2)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WTH_WTH2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_WTH_WTH2
#endif
INTEGER :: IKB, IKE
!$acc data present( PREDTH1, PREDR1, PD, PBLL_O_E, PETHETA, PM3_WTH_WTH2 )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WTH_WTH2', 'OpenACC: not yet tested' )
#endif
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
!$acc kernels
PM3_WTH_WTH2(:,:,:) = XCSHF*PBLL_O_E*PETHETA*0.5/XCTD &
* (1.+0.5*PREDTH1+PREDR1) / PD
PM3_WTH_WTH2(:,:,IKB-1)=PM3_WTH_WTH2(:,:,IKB)
PM3_WTH_WTH2(:,:,IKE+1)=PM3_WTH_WTH2(:,:,IKE)
!$acc end kernels
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_WTH_WTH2
#else
END SUBROUTINE M3_WTH_WTH2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WTH_WTH2_O_DDTDZ(PM3_WTH_WTH2,PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA) RESULT(PD_M3_WTH_WTH2_O_DDTDZ)
#else
SUBROUTINE D_M3_WTH_WTH2_O_DDTDZ(PM3_WTH_WTH2,PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA,PD_M3_WTH_WTH2_O_DDTDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PM3_WTH_WTH2
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WTH_WTH2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_WTH_WTH2_O_DDTDZ
#endif
INTEGER :: IKB, IKE
!$acc data present( PM3_WTH_WTH2, PREDTH1, PREDR1, PD, PBLL_O_E, PETHETA, PD_M3_WTH_WTH2_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WTH_WTH2_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
!$acc kernels
PD_M3_WTH_WTH2_O_DDTDZ(:,:,:) = ( 0.5*XCSHF*PBLL_O_E*PETHETA*0.5/XCTD/PD &
- PM3_WTH_WTH2/PD*(1.5+PREDTH1+PREDR1) )&
* PBLL_O_E * PETHETA * XCTV
!
PD_M3_WTH_WTH2_O_DDTDZ(:,:,IKB-1)=PD_M3_WTH_WTH2_O_DDTDZ(:,:,IKB)
PD_M3_WTH_WTH2_O_DDTDZ(:,:,IKE+1)=PD_M3_WTH_WTH2_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_WTH_WTH2_O_DDTDZ
#else
END SUBROUTINE D_M3_WTH_WTH2_O_DDTDZ#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WTH_W2TH(PREDTH1,PREDR1,PD,PKEFF,PTKE) RESULT(PM3_WTH_W2TH)
#else
SUBROUTINE M3_WTH_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PKEFF,PTKE,PM3_WTH_W2TH)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WTH_W2TH
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_WTH_W2TH
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PKEFF, PTKE, PM3_WTH_W2TH )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WTH_W2TH', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_WTH_W2TH(:,:,:) = XCSHF*PKEFF*1.5/MZM(PTKE) &
* (1. - 0.5*PREDR1*(1.+PREDR1)/PD ) / (1.+PREDTH1)
#else
CALL MZM_DEVICE(PTKE,ZTMP1_DEVICE)
!$acc kernels
PM3_WTH_W2TH(:,:,:) = XCSHF*PKEFF*1.5/ZTMP1_DEVICE &
* (1. - 0.5*PREDR1*(1.+PREDR1)/PD ) / (1.+PREDTH1)
#endif
!
PM3_WTH_W2TH(:,:,IKB-1)=PM3_WTH_W2TH(:,:,IKB)
PM3_WTH_W2TH(:,:,IKE+1)=PM3_WTH_W2TH(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_WTH_W2TH
#else
END SUBROUTINE M3_WTH_W2TH
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WTH_W2TH_O_DDTDZ(PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA,PKEFF,PTKE) RESULT(PD_M3_WTH_W2TH_O_DDTDZ)
#else
SUBROUTINE D_M3_WTH_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA,PKEFF,PTKE,PD_M3_WTH_W2TH_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WTH_W2TH_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_WTH_W2TH_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PBLL_O_E, PETHETA, PKEFF, PTKE, PD_M3_WTH_W2TH_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WTH_W2TH_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_WTH_W2TH_O_DDTDZ(:,:,:) = &
#ifndef MNH_BITREP
- XCSHF*PKEFF*1.5/MZM(PTKE)/(1.+PREDTH1)**2*XCTV*PBLL_O_E*PETHETA &
#else
- XCSHF*PKEFF*1.5/MZM(PTKE)/BR_P2(1.+PREDTH1)*XCTV*PBLL_O_E*PETHETA &
#endif
* (1. - 0.5*PREDR1*(1.+PREDR1)/PD*( 1.+(1.+PREDTH1)*(1.5+PREDR1+PREDTH1)/PD) )
#else
CALL MZM_DEVICE(PTKE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_WTH_W2TH_O_DDTDZ(:,:,:) = &
#ifndef MNH_BITREP
- XCSHF*PKEFF*1.5/ZTMP1_DEVICE/(1.+PREDTH1)**2*XCTV*PBLL_O_E*PETHETA &
#else
- XCSHF*PKEFF*1.5/ZTMP1_DEVICE/BR_P2(1.+PREDTH1)*XCTV*PBLL_O_E*PETHETA &
#endif
* (1. - 0.5*PREDR1*(1.+PREDR1)/PD*( 1.+(1.+PREDTH1)*(1.5+PREDR1+PREDTH1)/PD) )
#endif
!
PD_M3_WTH_W2TH_O_DDTDZ(:,:,IKB-1)=PD_M3_WTH_W2TH_O_DDTDZ(:,:,IKB)
PD_M3_WTH_W2TH_O_DDTDZ(:,:,IKE+1)=PD_M3_WTH_W2TH_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_WTH_W2TH_O_DDTDZ
#else
END SUBROUTINE D_M3_WTH_W2TH_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WTH_W2R(PD,PKEFF,PTKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PM3_WTH_W2R)#else
SUBROUTINE M3_WTH_W2R(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PKEFF,PTKE,PBLL_O_E,PEMOIST,PDTDZ,PM3_WTH_W2R)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WTH_W2R
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_WTH_W2R
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
#endif
!$acc data present( PD, PKEFF, PTKE, PBLL_O_E, PEMOIST, PDTDZ, PM3_WTH_W2R )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WTH_W2R', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_WTH_W2R(:,:,:) = - XCSHF*PKEFF*0.75*XCTV*PBLL_O_E/MZM(PTKE)*PEMOIST*PDTDZ/PD
#else
CALL MZM_DEVICE(PTKE,ZTMP1_DEVICE)
!$acc kernels
PM3_WTH_W2R(:,:,:) = - XCSHF*PKEFF*0.75*XCTV*PBLL_O_E/ZTMP1_DEVICE*PEMOIST*PDTDZ/PD
#endif
!
PM3_WTH_W2R(:,:,IKB-1)=PM3_WTH_W2R(:,:,IKB)
PM3_WTH_W2R(:,:,IKE+1)=PM3_WTH_W2R(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_WTH_W2R
#else
END SUBROUTINE M3_WTH_W2R
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WTH_W2R_O_DDTDZ(PREDTH1,PREDR1,PD,PKEFF,PTKE,PBLL_O_E,PEMOIST) RESULT(PD_M3_WTH_W2R_O_DDTDZ)
#else
SUBROUTINE D_M3_WTH_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PKEFF,PTKE,PBLL_O_E,PEMOIST,PD_M3_WTH_W2R_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1 REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WTH_W2R_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_WTH_W2R_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PKEFF, PTKE, PBLL_O_E, PEMOIST, PD_M3_WTH_W2R_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WTH_W2R_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_WTH_W2R_O_DDTDZ(:,:,:) = - XCSHF*PKEFF*0.75*XCTV*PBLL_O_E/MZM(PTKE)*PEMOIST/PD &
* (1. - PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
#else
CALL MZM_DEVICE(PTKE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_WTH_W2R_O_DDTDZ(:,:,:) = - XCSHF*PKEFF*0.75*XCTV*PBLL_O_E/ZTMP1_DEVICE*PEMOIST/PD &
* (1. - PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
#endif
!
PD_M3_WTH_W2R_O_DDTDZ(:,:,IKB-1)=PD_M3_WTH_W2R_O_DDTDZ(:,:,IKB)
PD_M3_WTH_W2R_O_DDTDZ(:,:,IKE+1)=PD_M3_WTH_W2R_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_WTH_W2R_O_DDTDZ
#else
END SUBROUTINE D_M3_WTH_W2R_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WTH_WR2(PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST,PDTDZ) RESULT(PM3_WTH_WR2)
#else
SUBROUTINE M3_WTH_WR2(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST,PDTDZ,PM3_WTH_WR2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E REAL, DIMENSION(:,:,:), INTENT(IN) :: PBETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WTH_WR2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_WTH_WR2
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PKEFF, PTKE, PSQRT_TKE, PBLL_O_E, PBETA, PLEPS, PEMOIST, PDTDZ, PM3_WTH_WR2 )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WTH_WR2', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PM3_WTH_WR2(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*PEMOIST**2 &
#else
PM3_WTH_WR2(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*BR_P2(PEMOIST) &
#endif
*MZM(PBETA*PLEPS/(PSQRT_TKE*PTKE))/XCTD*PDTDZ/PD
#else
!$acc kernels
ZTMP2_DEVICE = PBETA*PLEPS/(PSQRT_TKE*PTKE)
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PM3_WTH_WR2(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*PEMOIST**2 &
#else
PM3_WTH_WR2(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*BR_P2(PEMOIST) &
#endif
*ZTMP1_DEVICE/XCTD*PDTDZ/PD
#endif
!
PM3_WTH_WR2(:,:,IKB-1)=PM3_WTH_WR2(:,:,IKB)
PM3_WTH_WR2(:,:,IKE+1)=PM3_WTH_WR2(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_WTH_WR2
#else
END SUBROUTINE M3_WTH_WR2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WTH_WR2_O_DDTDZ(PREDTH1,PREDR1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST) &
RESULT(PD_M3_WTH_WR2_O_DDTDZ)
#else
SUBROUTINE D_M3_WTH_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PEMOIST, & PD_M3_WTH_WR2_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WTH_WR2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_WTH_WR2_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PTKE, PSQRT_TKE, PBETA, PLEPS, PREDTH1, PREDR1, PD, PKEFF, PBLL_O_E, PEMOIST, PD_M3_WTH_WR2_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WTH_WR2_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PD_M3_WTH_WR2_O_DDTDZ(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*PEMOIST**2 &
#else
PD_M3_WTH_WR2_O_DDTDZ(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*BR_P2(PEMOIST) &
#endif
*MZM(PBETA*PLEPS/(PSQRT_TKE*PTKE))/XCTD/PD &
* (1. - PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
#else
!$acc kernels
ZTMP2_DEVICE = PBETA*PLEPS/(PSQRT_TKE*PTKE)
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PD_M3_WTH_WR2_O_DDTDZ(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*PEMOIST**2 &
#else
PD_M3_WTH_WR2_O_DDTDZ(:,:,:) = - XCSHF*PKEFF*0.25*PBLL_O_E*XCTV*BR_P2(PEMOIST) &
#endif
*ZTMP1_DEVICE/XCTD/PD &
* (1. - PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
#endif
!
PD_M3_WTH_WR2_O_DDTDZ(:,:,IKB-1)=PD_M3_WTH_WR2_O_DDTDZ(:,:,IKB)
PD_M3_WTH_WR2_O_DDTDZ(:,:,IKE+1)=PD_M3_WTH_WR2_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_WTH_WR2_O_DDTDZ
#else
END SUBROUTINE D_M3_WTH_WR2_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WTH_WTHR(PREDR1,PD,PKEFF,PTKE,PSQRT_TKE,PBETA,PLEPS,PEMOIST) RESULT(PM3_WTH_WTHR)
#else
SUBROUTINE M3_WTH_WTHR(KKA,KKU,KKL,PREDR1,PD,PKEFF,PTKE,PSQRT_TKE,PBETA,PLEPS,PEMOIST,PM3_WTH_WTHR)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDR1,1),SIZE(PREDR1,2),SIZE(PREDR1,3)) :: PM3_WTH_WTHR
#else
REAL, DIMENSION(SIZE(PREDR1,1),SIZE(PREDR1,2),SIZE(PREDR1,3)),INTENT(OUT) :: PM3_WTH_WTHR
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDR1, PD, PKEFF, PTKE, PSQRT_TKE, PBETA, PLEPS, PEMOIST, PM3_WTH_WTHR )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WTH_WTHR', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_WTH_WTHR(:,:,:) = XCSHF*PKEFF*PEMOIST*MZM(PBETA/PTKE*PSQRT_TKE) &
*0.5*PLEPS/XCTD*(1+PREDR1)/PD
#else
!$acc kernels
ZTMP2_DEVICE = PBETA/PTKE*PSQRT_TKE
!$acc end kernels
CALL MZM_DEVICE(ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PM3_WTH_WTHR(:,:,:) = XCSHF*PKEFF*PEMOIST*ZTMP1_DEVICE*0.5*PLEPS/XCTD*(1+PREDR1)/PD
#endif
!
PM3_WTH_WTHR(:,:,IKB-1)=PM3_WTH_WTHR(:,:,IKB)
PM3_WTH_WTHR(:,:,IKE+1)=PM3_WTH_WTHR(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_WTH_WTHR
#else
END SUBROUTINE M3_WTH_WTHR
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WTH_WTHR_O_DDTDZ(PM3_WTH_WTHR,PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA) RESULT(PD_M3_WTH_WTHR_O_DDTDZ)
#else
SUBROUTINE D_M3_WTH_WTHR_O_DDTDZ(PM3_WTH_WTHR,PREDTH1,PREDR1,PD,PBLL_O_E,PETHETA,PD_M3_WTH_WTHR_O_DDTDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PM3_WTH_WTHR
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WTH_WTHR_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_WTH_WTHR_O_DDTDZ
#endif
INTEGER :: IKB, IKE
!$acc data present( PM3_WTH_WTHR, PREDTH1, PREDR1, PD, PBLL_O_E, PETHETA, PD_M3_WTH_WTHR_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WTH_WTHR_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
!$acc kernels
PD_M3_WTH_WTHR_O_DDTDZ(:,:,:) = - PM3_WTH_WTHR * (1.5+PREDTH1+PREDR1)/PD*XCTV*PBLL_O_E*PETHETA
!
PD_M3_WTH_WTHR_O_DDTDZ(:,:,IKB-1)=PD_M3_WTH_WTHR_O_DDTDZ(:,:,IKB)
PD_M3_WTH_WTHR_O_DDTDZ(:,:,IKE+1)=PD_M3_WTH_WTHR_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_WTH_WTHR_O_DDTDZ
#else
END SUBROUTINE D_M3_WTH_WTHR_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_TH2_W2TH(PREDTH1,PREDR1,PD,PDTDZ,PLM,PLEPS,PTKE) RESULT(PM3_TH2_W2TH)
#else
SUBROUTINE M3_TH2_W2TH(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PDTDZ,PLM,PLEPS,PTKE,PM3_TH2_W2TH)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_TH2_W2TH
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_TH2_W2TH
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE#endif
!$acc data present( PREDTH1, PREDR1, PD, PDTDZ, PLM, PLEPS, PTKE, PM3_TH2_W2TH )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_TH2_W2TH', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_TH2_W2TH(:,:,:) = - MZF((1.-0.5*PREDR1*(1.+PREDR1)/PD)/(1.+PREDTH1)*PDTDZ) &
* 1.5*PLM*PLEPS/PTKE*XCTV
#else
!$acc kernels
ZTMP2_DEVICE = (1.-0.5*PREDR1*(1.+PREDR1)/PD)/(1.+PREDTH1)*PDTDZ
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PM3_TH2_W2TH(:,:,:) = - ZTMP1_DEVICE &
* 1.5*PLM*PLEPS/PTKE*XCTV
#endif
!
PM3_TH2_W2TH(:,:,IKB-1)=PM3_TH2_W2TH(:,:,IKB)
PM3_TH2_W2TH(:,:,IKE+1)=PM3_TH2_W2TH(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_TH2_W2TH
#else
END SUBROUTINE M3_TH2_W2TH
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_TH2_W2TH_O_DDTDZ(PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,OUSERV) RESULT(PD_M3_TH2_W2TH_O_DDTDZ)
#else
SUBROUTINE D_M3_TH2_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,OUSERV,PD_M3_TH2_W2TH_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
LOGICAL, INTENT(IN) :: OUSERV
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_TH2_W2TH_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_TH2_W2TH_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLM, PLEPS, PTKE, PD_M3_TH2_W2TH_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_TH2_W2TH_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
IF (OUSERV) THEN
PD_M3_TH2_W2TH_O_DDTDZ(:,:,:) = - 1.5*PLM*PLEPS/PTKE*XCTV * MZF( &
(1.-0.5*PREDR1*(1.+PREDR1)/PD)*(1.-(1.5+PREDTH1+PREDR1)* &
#ifndef MNH_BITREP
PREDTH1*(1.+PREDTH1)/PD ) / (1.+PREDTH1)**2 )
#else
PREDTH1*(1.+PREDTH1)/PD ) / BR_P2(1.+PREDTH1) )
#endif
ELSE
#ifndef MNH_BITREP
PD_M3_TH2_W2TH_O_DDTDZ(:,:,:) = - 1.5*PLM*PLEPS/PTKE*XCTV * MZF(1./(1.+PREDTH1)**2)
#else
PD_M3_TH2_W2TH_O_DDTDZ(:,:,:) = - 1.5*PLM*PLEPS/PTKE*XCTV * MZF(1./BR_P2(1.+PREDTH1))
#endif
END IF
#else
IF (OUSERV) THEN
!$acc kernels
ZTMP2_DEVICE = (1.-0.5*PREDR1*(1.+PREDR1)/PD)*(1.-(1.5+PREDTH1+PREDR1)* &
#ifndef MNH_BITREP
PREDTH1*(1.+PREDTH1)/PD ) / (1.+PREDTH1)**2
#else
PREDTH1*(1.+PREDTH1)/PD ) / BR_P2(1.+PREDTH1)
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE, ZTMP1_DEVICE)
!$acc kernels
PD_M3_TH2_W2TH_O_DDTDZ(:,:,:) = - 1.5*PLM*PLEPS/PTKE*XCTV * ZTMP1_DEVICE
!$acc end kernels
ELSE
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = 1./(1.+PREDTH1)**2
#else
ZTMP2_DEVICE = 1./BR_P2(1.+PREDTH1)
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_TH2_W2TH_O_DDTDZ(:,:,:) = - 1.5*PLM*PLEPS/PTKE*XCTV * ZTMP1_DEVICE
!$acc end kernels
END IF
#endif
!
!$acc kernels
PD_M3_TH2_W2TH_O_DDTDZ(:,:,IKB-1)=PD_M3_TH2_W2TH_O_DDTDZ(:,:,IKB)
PD_M3_TH2_W2TH_O_DDTDZ(:,:,IKE+1)=PD_M3_TH2_W2TH_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_TH2_W2TH_O_DDTDZ
#else
END SUBROUTINE D_M3_TH2_W2TH_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_TH2_WTH2(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE) RESULT(PM3_TH2_WTH2)
#else
SUBROUTINE M3_TH2_WTH2(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PM3_TH2_WTH2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_TH2_WTH2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_TH2_WTH2
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PM3_TH2_WTH2 )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_TH2_WTH2', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_TH2_WTH2(:,:,:) = PLEPS*0.5/XCTD/PSQRT_TKE &
#ifndef MNH_BITREP
* MZF( (1.+0.5*PREDTH1+1.5*PREDR1+0.5*PREDR1**2)/PD )
#else
* MZF( (1.+0.5*PREDTH1+1.5*PREDR1+0.5*BR_P2(PREDR1))/PD )
#endif
#else
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = (1.+0.5*PREDTH1+1.5*PREDR1+0.5*PREDR1**2)/PD
#else
ZTMP2_DEVICE = (1.+0.5*PREDTH1+1.5*PREDR1+0.5*BR_P2(PREDR1))/PD
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP2_DEVICE ,ZTMP1_DEVICE)
!$acc kernels
PM3_TH2_WTH2(:,:,:) = PLEPS*0.5/XCTD/PSQRT_TKE*ZTMP1_DEVICE
#endif
!
PM3_TH2_WTH2(:,:,IKB-1)=PM3_TH2_WTH2(:,:,IKB)
PM3_TH2_WTH2(:,:,IKE+1)=PM3_TH2_WTH2(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_TH2_WTH2
#else
END SUBROUTINE M3_TH2_WTH2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_TH2_WTH2_O_DDTDZ(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA) RESULT(PD_M3_TH2_WTH2_O_DDTDZ)
#else
SUBROUTINE D_M3_TH2_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PD_M3_TH2_WTH2_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_TH2_WTH2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_TH2_WTH2_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PD_M3_TH2_WTH2_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_TH2_WTH2_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_TH2_WTH2_O_DDTDZ(:,:,:) = PLEPS*0.5/XCTD/PSQRT_TKE*XCTV &
* MZF( PBLL_O_E*PETHETA* (0.5/PD &
#ifndef MNH_BITREP
- (1.5+PREDTH1+PREDR1)*(1.+0.5*PREDTH1+1.5*PREDR1+0.5*PREDR1**2)/PD**2 &
#else
- (1.5+PREDTH1+PREDR1)*(1.+0.5*PREDTH1+1.5*PREDR1+0.5*BR_P2(PREDR1))/BR_P2(PD) &
#endif
) )
#else
!$acc kernels
ZTMP2_DEVICE = PBLL_O_E*PETHETA* (0.5/PD &
#ifndef MNH_BITREP
- (1.5+PREDTH1+PREDR1)*(1.+0.5*PREDTH1+1.5*PREDR1+0.5*PREDR1**2)/PD**2 &
#else
- (1.5+PREDTH1+PREDR1)*(1.+0.5*PREDTH1+1.5*PREDR1+0.5*BR_P2(PREDR1))/BR_P2(PD) &
#endif
)!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL, ZTMP2_DEVICE ,ZTMP1_DEVICE)
!$acc kernels
PD_M3_TH2_WTH2_O_DDTDZ(:,:,:) = PLEPS*0.5/XCTD/PSQRT_TKE*XCTV*ZTMP1_DEVICE
#endif
!
PD_M3_TH2_WTH2_O_DDTDZ(:,:,IKB-1)=PD_M3_TH2_WTH2_O_DDTDZ(:,:,IKB)
PD_M3_TH2_WTH2_O_DDTDZ(:,:,IKE+1)=PD_M3_TH2_WTH2_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_TH2_WTH2_O_DDTDZ
#else
END SUBROUTINE D_M3_TH2_WTH2_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_TH2_W2R(PD,PLM,PLEPS,PTKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PM3_TH2_W2R)
#else
SUBROUTINE M3_TH2_W2R(KKA,KKU,KKL,PD,PLM,PLEPS,PTKE,PBLL_O_E,PEMOIST,PDTDZ,PM3_TH2_W2R)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_TH2_W2R
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_TH2_W2R
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PD, PLM, PLEPS, PTKE, PBLL_O_E, PEMOIST, PDTDZ, PM3_TH2_W2R )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_TH2_W2R', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PM3_TH2_W2R(:,:,:) = 0.75*XCTV**2*MZF(PBLL_O_E*PEMOIST/PD*PDTDZ**2)*PLM*PLEPS/PTKE
#else
PM3_TH2_W2R(:,:,:) = 0.75*BR_P2(XCTV)*MZF(PBLL_O_E*PEMOIST/PD*BR_P2(PDTDZ))*PLM*PLEPS/PTKE
#endif
#else
!$acc kernels
#ifndef MNH_BITREPZTMP2_DEVICE = PBLL_O_E*PEMOIST/PD*PDTDZ**2
#else
ZTMP2_DEVICE = PBLL_O_E*PEMOIST/PD*BR_P2(PDTDZ)
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PM3_TH2_W2R(:,:,:) = 0.75*XCTV**2*ZTMP1_DEVICE*PLM*PLEPS/PTKE
#else
PM3_TH2_W2R(:,:,:) = 0.75*BR_P2(XCTV)*ZTMP1_DEVICE*PLM*PLEPS/PTKE
#endif
#endif
!
PM3_TH2_W2R(:,:,IKB-1)=PM3_TH2_W2R(:,:,IKB)
PM3_TH2_W2R(:,:,IKE+1)=PM3_TH2_W2R(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_TH2_W2R
#else
END SUBROUTINE M3_TH2_W2R
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_TH2_W2R_O_DDTDZ(PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PD_M3_TH2_W2R_O_DDTDZ)
#else
SUBROUTINE D_M3_TH2_W2R_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PEMOIST,PDTDZ,PD_M3_TH2_W2R_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_TH2_W2R_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_TH2_W2R_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLM, PLEPS, PTKE, PBLL_O_E, PEMOIST, PDTDZ, PD_M3_TH2_W2R_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_TH2_W2R_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PD_M3_TH2_W2R_O_DDTDZ(:,:,:) = 0.75*XCTV**2*PLM*PLEPS/PTKE &
#else
PD_M3_TH2_W2R_O_DDTDZ(:,:,:) = 0.75*BR_P2(XCTV)*PLM*PLEPS/PTKE &
#endif
* MZF( PBLL_O_E*PEMOIST/PD*PDTDZ*(2.-PREDTH1*(1.5+PREDTH1+PREDR1)/PD) )
#else
!$acc kernels
ZTMP2_DEVICE = PBLL_O_E*PEMOIST/PD*PDTDZ*(2.-PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PD_M3_TH2_W2R_O_DDTDZ(:,:,:) = 0.75*XCTV**2*PLM*PLEPS/PTKE &
#else
PD_M3_TH2_W2R_O_DDTDZ(:,:,:) = 0.75*BR_P2(XCTV)*PLM*PLEPS/PTKE &
#endif
* ZTMP1_DEVICE
#endif
!
PD_M3_TH2_W2R_O_DDTDZ(:,:,IKB-1)=PD_M3_TH2_W2R_O_DDTDZ(:,:,IKB)
PD_M3_TH2_W2R_O_DDTDZ(:,:,IKE+1)=PD_M3_TH2_W2R_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_TH2_W2R_O_DDTDZ
#else
END SUBROUTINE D_M3_TH2_W2R_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_TH2_WR2(PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PM3_TH2_WR2)
#else
SUBROUTINE M3_TH2_WR2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PM3_TH2_WR2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_TH2_WR2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_TH2_WR2
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PDTDZ, PM3_TH2_WR2 )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_TH2_WR2', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PM3_TH2_WR2(:,:,:) = 0.25*XCTV**2*MZF((PBLL_O_E*PEMOIST*PDTDZ)**2/PD)*PLEPS/PSQRT_TKE/XCTD
#else
PM3_TH2_WR2(:,:,:) = 0.25*BR_P2(XCTV)*MZF(BR_P2(PBLL_O_E*PEMOIST*PDTDZ)/PD)*PLEPS/PSQRT_TKE/XCTD
#endif
#else
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = (PBLL_O_E*PEMOIST*PDTDZ)**2/PD
#else
ZTMP2_DEVICE = BR_P2(PBLL_O_E*PEMOIST*PDTDZ)/PD
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PM3_TH2_WR2(:,:,:) = 0.25*XCTV**2*ZTMP1_DEVICE*PLEPS/PSQRT_TKE/XCTD
#else
PM3_TH2_WR2(:,:,:) = 0.25*BR_P2(XCTV)*ZTMP1_DEVICE*PLEPS/PSQRT_TKE/XCTD
#endif
#endif
!
PM3_TH2_WR2(:,:,IKB-1)=PM3_TH2_WR2(:,:,IKB)
PM3_TH2_WR2(:,:,IKE+1)=PM3_TH2_WR2(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_TH2_WR2
#else
END SUBROUTINE M3_TH2_WR2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_TH2_WR2_O_DDTDZ(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PD_M3_TH2_WR2_O_DDTDZ)
#else
SUBROUTINE D_M3_TH2_WR2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PD_M3_TH2_WR2_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_TH2_WR2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_TH2_WR2_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PDTDZ, PD_M3_TH2_WR2_O_DDTDZ )#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_TH2_WR2_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PD_M3_TH2_WR2_O_DDTDZ(:,:,:) = 0.25*XCTV**2*PLEPS/PSQRT_TKE/XCTD &
* MZF( (PBLL_O_E*PEMOIST)**2*PDTDZ/PD*(2.-PREDTH1*(1.5+PREDTH1+PREDR1)/PD) )
#else
PD_M3_TH2_WR2_O_DDTDZ(:,:,:) = 0.25*BR_P2(XCTV)*PLEPS/PSQRT_TKE/XCTD &
* MZF( BR_P2(PBLL_O_E*PEMOIST)*PDTDZ/PD*(2.-PREDTH1*(1.5+PREDTH1+PREDR1)/PD) )
#endif
#else
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = (PBLL_O_E*PEMOIST)**2*PDTDZ/PD*(2.-PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
#else
ZTMP2_DEVICE = BR_P2(PBLL_O_E*PEMOIST)*PDTDZ/PD*(2.-PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PD_M3_TH2_WR2_O_DDTDZ(:,:,:) = 0.25*XCTV**2*PLEPS/PSQRT_TKE/XCTD &
#else
PD_M3_TH2_WR2_O_DDTDZ(:,:,:) = 0.25*BR_P2(XCTV)*PLEPS/PSQRT_TKE/XCTD &
#endif
* ZTMP1_DEVICE
#endif
!
PD_M3_TH2_WR2_O_DDTDZ(:,:,IKB-1)=PD_M3_TH2_WR2_O_DDTDZ(:,:,IKB)
PD_M3_TH2_WR2_O_DDTDZ(:,:,IKE+1)=PD_M3_TH2_WR2_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_TH2_WR2_O_DDTDZ
#else
END SUBROUTINE D_M3_TH2_WR2_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_TH2_WTHR(PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PM3_TH2_WTHR)
#else
SUBROUTINE M3_TH2_WTHR(KKA,KKU,KKL,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PM3_TH2_WTHR)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_TH2_WTHR
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_TH2_WTHR
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PDTDZ, PM3_TH2_WTHR )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_TH2_WTHR', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_TH2_WTHR(:,:,:) = - 0.5*XCTV*PLEPS/PSQRT_TKE/XCTD &
* MZF( PBLL_O_E*PEMOIST*PDTDZ*(1.+PREDR1)/PD )
#else
!$acc kernels
ZTMP2_DEVICE = PBLL_O_E*PEMOIST*PDTDZ*(1.+PREDR1)/PD
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PM3_TH2_WTHR(:,:,:) = - 0.5*XCTV*PLEPS/PSQRT_TKE/XCTD*ZTMP1_DEVICE
#endif
!
PM3_TH2_WTHR(:,:,IKB-1)=PM3_TH2_WTHR(:,:,IKB)
PM3_TH2_WTHR(:,:,IKE+1)=PM3_TH2_WTHR(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_TH2_WTHR
#else
END SUBROUTINE M3_TH2_WTHR
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_TH2_WTHR_O_DDTDZ(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PD_M3_TH2_WTHR_O_DDTDZ)
#else
SUBROUTINE D_M3_TH2_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PD_M3_TH2_WTHR_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_TH2_WTHR_O_DDTDZ
#else REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_TH2_WTHR_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PDTDZ, PD_M3_TH2_WTHR_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_TH2_WTHR_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_TH2_WTHR_O_DDTDZ(:,:,:) = - 0.5*XCTV*PLEPS/PSQRT_TKE/XCTD &
* MZF( PBLL_O_E*PEMOIST*(1.+PREDR1)/PD * (1. -PREDTH1*(1.5+PREDTH1+PREDR1)/PD) )
#else
!$acc kernels
ZTMP2_DEVICE = PBLL_O_E*PEMOIST*(1.+PREDR1)/PD * (1. -PREDTH1*(1.5+PREDTH1+PREDR1)/PD)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_TH2_WTHR_O_DDTDZ(:,:,:) = - 0.5*XCTV*PLEPS/PSQRT_TKE/XCTD &
* ZTMP1_DEVICE
#endif
!
PD_M3_TH2_WTHR_O_DDTDZ(:,:,IKB-1)=PD_M3_TH2_WTHR_O_DDTDZ(:,:,IKB)
PD_M3_TH2_WTHR_O_DDTDZ(:,:,IKE+1)=PD_M3_TH2_WTHR_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_TH2_WTHR_O_DDTDZ
#else
END SUBROUTINE D_M3_TH2_WTHR_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_THR_WTHR(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE) RESULT(PM3_THR_WTHR)
#else
SUBROUTINE M3_THR_WTHR(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PM3_THR_WTHR)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_THR_WTHR
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_THR_WTHR
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PM3_THR_WTHR )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_THR_WTHR', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_THR_WTHR(:,:,:) = 0.5*PLEPS/PSQRT_TKE/XCTD &
* MZF( (1.+PREDTH1)*(1.+PREDR1)/PD )
#else
!$acc kernels
ZTMP2_DEVICE = (1.+PREDTH1)*(1.+PREDR1)/PD
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PM3_THR_WTHR(:,:,:) = 0.5*PLEPS/PSQRT_TKE/XCTD*ZTMP1_DEVICE
#endif
!
PM3_THR_WTHR(:,:,IKB-1)=PM3_THR_WTHR(:,:,IKB)
PM3_THR_WTHR(:,:,IKE+1)=PM3_THR_WTHR(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_THR_WTHR
#else
END SUBROUTINE M3_THR_WTHR
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_WTHR_O_DDTDZ(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA) RESULT(PD_M3_THR_WTHR_O_DDTDZ)
#else
SUBROUTINE D_M3_THR_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PD_M3_THR_WTHR_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_WTHR_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_THR_WTHR_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PD_M3_THR_WTHR_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_WTHR_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_THR_WTHR_O_DDTDZ(:,:,:) = 0.5*PLEPS/PSQRT_TKE/XCTD * XCTV &
* MZF( PETHETA*PBLL_O_E/PD*(1.+PREDR1)*(1.-(1.+PREDTH1)*(1.5+PREDTH1+PREDR1)/PD) )
#else
!$acc kernels
ZTMP2_DEVICE = PETHETA*PBLL_O_E/PD*(1.+PREDR1)*(1.-(1.+PREDTH1)*(1.5+PREDTH1+PREDR1)/PD)
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_THR_WTHR_O_DDTDZ(:,:,:) = 0.5*PLEPS/PSQRT_TKE/XCTD * XCTV * ZTMP1_DEVICE
#endif
!
PD_M3_THR_WTHR_O_DDTDZ(:,:,IKB-1)=PD_M3_THR_WTHR_O_DDTDZ(:,:,IKB)
PD_M3_THR_WTHR_O_DDTDZ(:,:,IKE+1)=PD_M3_THR_WTHR_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_WTHR_O_DDTDZ
#else
END SUBROUTINE D_M3_THR_WTHR_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_THR_WTH2(PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PM3_THR_WTH2)
#else
SUBROUTINE M3_THR_WTH2(KKA,KKU,KKL,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PM3_THR_WTH2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_THR_WTH2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_THR_WTH2
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PDRDZ, PM3_THR_WTH2 )
#ifdef MNH_OPENACCcall Print_msg( NVERB_WARNING, 'GEN', 'M3_THR_WTH2', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_THR_WTH2(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*XCTV &
* MZF( (1.+PREDR1)*PBLL_O_E*PETHETA*PDRDZ/PD )
#else
!$acc kernels
ZTMP2_DEVICE = (1.+PREDR1)*PBLL_O_E*PETHETA*PDRDZ/PD
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PM3_THR_WTH2(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*XCTV * ZTMP1_DEVICE
#endif
!
PM3_THR_WTH2(:,:,IKB-1)=PM3_THR_WTH2(:,:,IKB)
PM3_THR_WTH2(:,:,IKE+1)=PM3_THR_WTH2(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_THR_WTH2
#else
END SUBROUTINE M3_THR_WTH2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_WTH2_O_DDTDZ(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PD_M3_THR_WTH2_O_DDTDZ)
#else
SUBROUTINE D_M3_THR_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_THR_WTH2_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_WTH2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_THR_WTH2_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PDRDZ, PD_M3_THR_WTH2_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_WTH2_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PD_M3_THR_WTH2_O_DDTDZ(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*XCTV**2 &
* MZF( -(1.+PREDR1)*(PBLL_O_E*PETHETA/PD)**2*PDRDZ*(1.5+PREDTH1+PREDR1) )
#else
PD_M3_THR_WTH2_O_DDTDZ(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*BR_P2(XCTV) &
* MZF( -(1.+PREDR1)*BR_P2(PBLL_O_E*PETHETA/PD)*PDRDZ*(1.5+PREDTH1+PREDR1) )
#endif
#else
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = -(1.+PREDR1)*(PBLL_O_E*PETHETA/PD)**2*PDRDZ*(1.5+PREDTH1+PREDR1)
#else
ZTMP2_DEVICE = -(1.+PREDR1)*BR_P2(PBLL_O_E*PETHETA/PD)*PDRDZ*(1.5+PREDTH1+PREDR1)
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PD_M3_THR_WTH2_O_DDTDZ(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*XCTV**2 * ZTMP1_DEVICE
#else
PD_M3_THR_WTH2_O_DDTDZ(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*BR_P2(XCTV) * ZTMP1_DEVICE
#endif
#endif
!
PD_M3_THR_WTH2_O_DDTDZ(:,:,IKB-1)=PD_M3_THR_WTH2_O_DDTDZ(:,:,IKB)
PD_M3_THR_WTH2_O_DDTDZ(:,:,IKE+1)=PD_M3_THR_WTH2_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_WTH2_O_DDTDZ
#else
END SUBROUTINE D_M3_THR_WTH2_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_WTH2_O_DDRDZ(PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA) RESULT(PD_M3_THR_WTH2_O_DDRDZ)
#else
SUBROUTINE D_M3_THR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PD_M3_THR_WTH2_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_WTH2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_THR_WTH2_O_DDRDZ
#endif INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PD_M3_THR_WTH2_O_DDRDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_WTH2_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_THR_WTH2_O_DDRDZ(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*XCTV &
* MZF( PBLL_O_E*PETHETA/PD &
*(-(1.+PREDR1)*PREDR1/PD*(1.5+PREDTH1+PREDR1)+(1.+2.*PREDR1)) &
)
#else
!$acc kernels
ZTMP2_DEVICE = PBLL_O_E*PETHETA/PD &
*(-(1.+PREDR1)*PREDR1/PD*(1.5+PREDTH1+PREDR1)+(1.+2.*PREDR1))
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_THR_WTH2_O_DDRDZ(:,:,:) = - 0.25*PLEPS/PSQRT_TKE/XCTD*XCTV * ZTMP1_DEVICE
#endif
!
PD_M3_THR_WTH2_O_DDRDZ(:,:,IKB-1)=PD_M3_THR_WTH2_O_DDRDZ(:,:,IKB)
PD_M3_THR_WTH2_O_DDRDZ(:,:,IKE+1)=PD_M3_THR_WTH2_O_DDRDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_WTH2_O_DDRDZ
#else
END SUBROUTINE D_M3_THR_WTH2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_THR_W2TH(PREDR1,PD,PLM,PLEPS,PTKE,PDRDZ) RESULT(PM3_THR_W2TH)
#else
SUBROUTINE M3_THR_W2TH(KKA,KKU,KKL,PREDR1,PD,PLM,PLEPS,PTKE,PDRDZ,PM3_THR_W2TH)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_THR_W2TH
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PM3_THR_W2TH
#endif
INTEGER :: IKB, IKE#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDR1, PD, PLM, PLEPS, PTKE, PDRDZ, PM3_THR_W2TH )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_THR_W2TH', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PM3_THR_W2TH(:,:,:) = - 0.75*PLM*PLEPS/PTKE * XCTV &
* MZF( (1.+PREDR1)*PDRDZ/PD )
#else
!$acc kernels
ZTMP2_DEVICE = (1.+PREDR1)*PDRDZ/PD
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PM3_THR_W2TH(:,:,:) = - 0.75*PLM*PLEPS/PTKE * XCTV * ZTMP1_DEVICE
#endif
!
PM3_THR_W2TH(:,:,IKB-1)=PM3_THR_W2TH(:,:,IKB)
PM3_THR_W2TH(:,:,IKE+1)=PM3_THR_W2TH(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION M3_THR_W2TH
#else
END SUBROUTINE M3_THR_W2TH
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_W2TH_O_DDTDZ(PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PDRDZ,PETHETA) RESULT(PD_M3_THR_W2TH_O_DDTDZ)
#else
SUBROUTINE D_M3_THR_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PDRDZ,PETHETA,PD_M3_THR_W2TH_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_W2TH_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_THR_W2TH_O_DDTDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLM, PLEPS, PTKE, PBLL_O_E, PDRDZ, PETHETA, PD_M3_THR_W2TH_O_DDTDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_W2TH_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
#ifndef MNH_BITREP
PD_M3_THR_W2TH_O_DDTDZ(:,:,:) = - 0.75*PLM*PLEPS/PTKE * XCTV**2 &
* MZF( -PETHETA*PBLL_O_E*(1.+PREDR1)*PDRDZ*(1.5+PREDTH1+PREDR1)/PD**2 )
#else
PD_M3_THR_W2TH_O_DDTDZ(:,:,:) = - 0.75*PLM*PLEPS/PTKE * BR_P2(XCTV) &
* MZF( -PETHETA*PBLL_O_E*(1.+PREDR1)*PDRDZ*(1.5+PREDTH1+PREDR1)/BR_P2(PD) )
#endif
#else
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = -PETHETA*PBLL_O_E*(1.+PREDR1)*PDRDZ*(1.5+PREDTH1+PREDR1)/PD**2
#else
ZTMP2_DEVICE = -PETHETA*PBLL_O_E*(1.+PREDR1)*PDRDZ*(1.5+PREDTH1+PREDR1)/BR_P2(PD)
#endif
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
#ifndef MNH_BITREP
PD_M3_THR_W2TH_O_DDTDZ(:,:,:) = - 0.75*PLM*PLEPS/PTKE * XCTV**2 * ZTMP1_DEVICE
#else
PD_M3_THR_W2TH_O_DDTDZ(:,:,:) = - 0.75*PLM*PLEPS/PTKE * BR_P2(XCTV) * ZTMP1_DEVICE
#endif
#endif
!
PD_M3_THR_W2TH_O_DDTDZ(:,:,IKB-1)=PD_M3_THR_W2TH_O_DDTDZ(:,:,IKB)
PD_M3_THR_W2TH_O_DDTDZ(:,:,IKE+1)=PD_M3_THR_W2TH_O_DDTDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_W2TH_O_DDTDZ
#else
END SUBROUTINE D_M3_THR_W2TH_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_W2TH_O_DDRDZ(PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE) RESULT(PD_M3_THR_W2TH_O_DDRDZ)
#else
SUBROUTINE D_M3_THR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDTH1,PREDR1,PD,PLM,PLEPS,PTKE,PD_M3_THR_W2TH_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_W2TH_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)),INTENT(OUT) :: PD_M3_THR_W2TH_O_DDRDZ
#endif
INTEGER :: IKB, IKE
#ifdef MNH_OPENACC
REAL, DIMENSION(:,:,:), allocatable :: ZTMP1_DEVICE, ZTMP2_DEVICE
#endif
!$acc data present( PREDTH1, PREDR1, PD, PLM, PLEPS, PTKE, PD_M3_THR_W2TH_O_DDRDZ )
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_W2TH_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifdef MNH_OPENACC
allocate( ztmp1_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
allocate( ztmp2_device(size( pd, 1 ), size( pd, 2 ), size( pd, 3 ) ) )
#endif
!$acc data create( ztmp1_device, ztmp2_device )
IKB = 1+JPVEXT_TURB
IKE = SIZE(PD,3)-JPVEXT_TURB
#ifndef MNH_OPENACC
PD_M3_THR_W2TH_O_DDRDZ(:,:,:) = - 0.75*PLM*PLEPS/PTKE * XCTV &
#ifndef MNH_BITREP
* MZF( -(1.+PREDR1)*PREDR1*(1.5+PREDTH1+PREDR1)/PD**2 &
#else
* MZF( -(1.+PREDR1)*PREDR1*(1.5+PREDTH1+PREDR1)/BR_P2(PD) &
#endif
+(1.+2.*PREDR1)/PD &
)
#else
!$acc kernels
#ifndef MNH_BITREP
ZTMP2_DEVICE = -(1.+PREDR1)*PREDR1*(1.5+PREDTH1+PREDR1)/PD**2 &
#else
ZTMP2_DEVICE = -(1.+PREDR1)*PREDR1*(1.5+PREDTH1+PREDR1)/BR_P2(PD) &
#endif
+(1.+2.*PREDR1)/PD
!$acc end kernels
CALL MZF_DEVICE(KKA,KKU,KKL,ZTMP2_DEVICE,ZTMP1_DEVICE)
!$acc kernels
PD_M3_THR_W2TH_O_DDRDZ(:,:,:) = - 0.75*PLM*PLEPS/PTKE * XCTV * ZTMP1_DEVICE
#endif
!
PD_M3_THR_W2TH_O_DDRDZ(:,:,IKB-1)=PD_M3_THR_W2TH_O_DDRDZ(:,:,IKB)
PD_M3_THR_W2TH_O_DDRDZ(:,:,IKE+1)=PD_M3_THR_W2TH_O_DDRDZ(:,:,IKE)
!$acc end kernels
!$acc end data
!$acc end data
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_W2TH_O_DDRDZ
#else
END SUBROUTINE D_M3_THR_W2TH_O_DDRDZ
#endif
!----------------------------------------------------------------------------
!----------------------------------------------------------------------------
!----------------------------------------------------------------------------
!
#ifndef MNH_OPENACC
FUNCTION PSI3(PREDR1,PREDTH1,PRED2R3,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV) RESULT(PPSI3)#else
SUBROUTINE PSI3(PREDR1,PREDTH1,PRED2R3,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV,PPSI3)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2TH3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2R3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PPSI3
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)),INTENT(OUT) :: PPSI3
#endif
!
#ifndef MNH_OPENACC
PPSI3 = PHI3(PREDR1,PREDTH1,PRED2R3,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV)
#else
!$acc data present( PREDR1, PREDTH1, PRED2R3, PRED2TH3, PRED2THR3, PPSI3 )
CALL PHI3(PREDR1,PREDTH1,PRED2R3,PRED2TH3,PRED2THR3,HTURBDIM,OUSERV,PPSI3)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION PSI3
#else
END SUBROUTINE PSI3
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV) RESULT(PD_PSI3DRDZ_O_DDRDZ)
#else
SUBROUTINE D_PSI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV,PD_PSI3DRDZ_O_DDRDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPSI3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2R3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PD_PSI3DRDZ_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)), INTENT(OUT) :: PD_PSI3DRDZ_O_DDRDZ
#endif
!
#ifndef MNH_OPENACC
PD_PSI3DRDZ_O_DDRDZ = D_PHI3DTDZ_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV)
#else
!$acc data present( PPSI3, PREDR1, PREDTH1, PRED2R3, PRED2THR3, PD_PSI3DRDZ_O_DDRDZ )
CALL D_PHI3DTDZ_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV,PD_PSI3DRDZ_O_DDRDZ)
!$acc end data
#endif
!
!C'est ok?!
!
#ifndef MNH_OPENACC
END FUNCTION D_PSI3DRDZ_O_DDRDZ
#else
END SUBROUTINE D_PSI3DRDZ_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_PSI3DTDZ_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV) RESULT(PD_PSI3DTDZ_O_DDTDZ)
#else
SUBROUTINE D_PSI3DTDZ_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV,PD_PSI3DTDZ_O_DDTDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPSI3 REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2R3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PD_PSI3DTDZ_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)), INTENT(OUT) :: PD_PSI3DTDZ_O_DDTDZ
#endif
!
#ifndef MNH_OPENACC
PD_PSI3DTDZ_O_DDTDZ = D_PHI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV)
#else
!$acc data present( PPSI3, PREDR1, PREDTH1, PRED2R3, PRED2THR3, PD_PSI3DTDZ_O_DDTDZ )
CALL D_PHI3DRDZ_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,HTURBDIM,OUSERV,PD_PSI3DTDZ_O_DDTDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_PSI3DTDZ_O_DDTDZ
#else
END SUBROUTINE D_PSI3DTDZ_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_PSI3DRDZ2_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,PDRDZ,HTURBDIM,OUSERV) RESULT(PD_PSI3DRDZ2_O_DDRDZ)
#else
SUBROUTINE D_PSI3DRDZ2_O_DDRDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,PDRDZ,HTURBDIM,OUSERV,PD_PSI3DRDZ2_O_DDRDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PPSI3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2R3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PRED2THR3
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
CHARACTER(len=4), INTENT(IN) :: HTURBDIM ! 1DIM or 3DIM turb. scheme
LOGICAL, INTENT(IN) :: OUSERV ! flag to use vapor
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)) :: PD_PSI3DRDZ2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PREDTH1,1),SIZE(PREDTH1,2),SIZE(PREDTH1,3)), INTENT(OUT) :: PD_PSI3DRDZ2_O_DDRDZ
#endif
!
#ifndef MNH_OPENACC
PD_PSI3DRDZ2_O_DDRDZ = D_PHI3DTDZ2_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,PDRDZ,HTURBDIM,OUSERV)
#else
!$acc data present( PPSI3, PREDR1, PREDTH1, PRED2R3, PRED2THR3, PDRDZ, PD_PSI3DRDZ2_O_DDRDZ )
CALL D_PHI3DTDZ2_O_DDTDZ(PPSI3,PREDR1,PREDTH1,PRED2R3,PRED2THR3,PDRDZ,HTURBDIM,OUSERV,PD_PSI3DRDZ2_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_PSI3DRDZ2_O_DDRDZ
#else
END SUBROUTINE D_PSI3DRDZ2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WR_WR2(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST) RESULT(PM3_WR_WR2)
#else
SUBROUTINE M3_WR_WR2(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PM3_WR_WR2)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WR_WR2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_WR_WR2
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WR_WR2', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_WR_WR2 = M3_WTH_WTH2(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST)
#else
!$acc data present( PREDR1, PREDTH1, PD, PBLL_O_E, PEMOIST, PM3_WR_WR2 )
CALL M3_WTH_WTH2(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST, PM3_WR_WR2)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_WR_WR2
#else
END SUBROUTINE M3_WR_WR2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WR_WR2_O_DDRDZ(PM3_WR_WR2,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST) RESULT(PD_M3_WR_WR2_O_DDRDZ)
#else
SUBROUTINE D_M3_WR_WR2_O_DDRDZ(PM3_WR_WR2,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PD_M3_WR_WR2_O_DDRDZ)
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PM3_WR_WR2
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WR_WR2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_WR_WR2_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WR_WR2_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_WR_WR2_O_DDRDZ = D_M3_WTH_WTH2_O_DDTDZ(PM3_WR_WR2,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST)
#else
!$acc data present( PM3_WR_WR2, PREDR1, PREDTH1, PD, PBLL_O_E, PEMOIST, PD_M3_WR_WR2_O_DDRDZ )
CALL D_M3_WTH_WTH2_O_DDTDZ(PM3_WR_WR2,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PD_M3_WR_WR2_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_WR_WR2_O_DDRDZ
#else
END SUBROUTINE D_M3_WR_WR2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WR_W2R(PREDR1,PREDTH1,PD,PKEFF,PTKE) RESULT(PM3_WR_W2R)
#else
SUBROUTINE M3_WR_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PM3_WR_W2R)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WR_W2R
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_WR_W2R
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WR_W2R', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_WR_W2R = M3_WTH_W2TH(PREDR1,PREDTH1,PD,PKEFF,PTKE)
#else
!$acc data present( PREDR1, PREDTH1, PD, PKEFF, PTKE, PM3_WR_W2R )
CALL M3_WTH_W2TH(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PM3_WR_W2R)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_WR_W2R
#else
END SUBROUTINE M3_WR_W2R
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WR_W2R_O_DDRDZ(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PKEFF,PTKE) RESULT(PD_M3_WR_W2R_O_DDRDZ)
#else
SUBROUTINE D_M3_WR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PKEFF,PTKE,PD_M3_WR_W2R_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WR_W2R_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_WR_W2R_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WR_W2R_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_WR_W2R_O_DDRDZ = D_M3_WTH_W2TH_O_DDTDZ(PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PKEFF,PTKE)
#else
!$acc data present( PREDR1, PREDTH1, PD, PBLL_O_E, PEMOIST, PKEFF, PTKE, PD_M3_WR_W2R_O_DDRDZ )
CALL D_M3_WTH_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PKEFF,PTKE,PD_M3_WR_W2R_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_WR_W2R_O_DDRDZ
#else
END SUBROUTINE D_M3_WR_W2R_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WR_W2TH(PD,PKEFF,PTKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PM3_WR_W2TH)
#else
SUBROUTINE M3_WR_W2TH(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PBLL_O_E,PETHETA,PDRDZ,PM3_WR_W2TH)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
#endif REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WR_W2TH
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_WR_W2TH
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WR_W2TH', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_WR_W2TH = M3_WTH_W2R(PD,PKEFF,PTKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PREDR1, PREDTH1, PD, PKEFF, PTKE, PBLL_O_E, PETHETA, PDRDZ, PM3_WR_W2TH )
CALL M3_WTH_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PBLL_O_E,PETHETA,PDRDZ,PM3_WR_W2TH)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_WR_W2TH
#else
END SUBROUTINE M3_WR_W2TH
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WR_W2TH_O_DDRDZ(PREDR1,PREDTH1,PD,PKEFF,PTKE,PBLL_O_E,PETHETA) RESULT(PD_M3_WR_W2TH_O_DDRDZ)
#else
SUBROUTINE D_M3_WR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PBLL_O_E,PETHETA,PD_M3_WR_W2TH_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WR_W2TH_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_WR_W2TH_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WR_W2TH_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_WR_W2TH_O_DDRDZ = D_M3_WTH_W2R_O_DDTDZ(PREDR1,PREDTH1,PD,PKEFF,PTKE,PBLL_O_E,PETHETA)
#else
!$acc data present( PREDR1, PREDTH1, PD, PKEFF, PTKE, PBLL_O_E, PETHETA, PD_M3_WR_W2TH_O_DDRDZ )
CALL D_M3_WTH_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PBLL_O_E,PETHETA,PD_M3_WR_W2TH_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_WR_W2TH_O_DDRDZ
#else
END SUBROUTINE D_M3_WR_W2TH_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WR_WTH2(PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PDRDZ) RESULT(PM3_WR_WTH2)
#elseSUBROUTINE M3_WR_WTH2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PDRDZ,PM3_WR_WTH2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WR_WTH2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_WR_WTH2
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WR_WTH2', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_WR_WTH2 = M3_WTH_WR2(PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PDRDZ)
#else
!$acc data present( PREDR1, PREDTH1, PD, PKEFF, PTKE, PSQRT_TKE, PBLL_O_E, PBETA, PLEPS, PETHETA, PDRDZ, PM3_WR_WTH2 )
CALL M3_WTH_WR2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PDRDZ,PM3_WR_WTH2)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_WR_WTH2
#else
END SUBROUTINE M3_WR_WTH2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WR_WTH2_O_DDRDZ(PREDR1,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA) &
RESULT(PD_M3_WR_WTH2_O_DDRDZ)
#else
SUBROUTINE D_M3_WR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA, &
PD_M3_WR_WTH2_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WR_WTH2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_WR_WTH2_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WR_WTH2_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_WR_WTH2_O_DDRDZ = D_M3_WTH_WR2_O_DDTDZ(PREDR1,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA)#else
!$acc data present( PREDR1, PREDTH1, PD, PKEFF, PTKE, PSQRT_TKE, PBLL_O_E, PBETA, PLEPS, PETHETA, PD_M3_WR_WTH2_O_DDRDZ )
CALL D_M3_WTH_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBLL_O_E,PBETA,PLEPS,PETHETA,PD_M3_WR_WTH2_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_WR_WTH2_O_DDRDZ
#else
END SUBROUTINE D_M3_WR_WTH2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_WR_WTHR(PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBETA,PLEPS,PETHETA) RESULT(PM3_WR_WTHR)
#else
SUBROUTINE M3_WR_WTHR(KKA,KKU,KKL,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBETA,PLEPS,PETHETA,PM3_WR_WTHR)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PKEFF
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_WR_WTHR
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_WR_WTHR
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_WR_WTHR', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_WR_WTHR = M3_WTH_WTHR(PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBETA,PLEPS,PETHETA)
#else
!$acc data present( PREDTH1, PD, PKEFF, PTKE, PSQRT_TKE, PBETA, PLEPS, PETHETA, PM3_WR_WTHR )
CALL M3_WTH_WTHR(KKA,KKU,KKL,PREDTH1,PD,PKEFF,PTKE,PSQRT_TKE,PBETA,PLEPS,PETHETA,PM3_WR_WTHR)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_WR_WTHR
#else
END SUBROUTINE M3_WR_WTHR
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_WR_WTHR_O_DDRDZ(PM3_WR_WTHR,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST) RESULT(PD_M3_WR_WTHR_O_DDRDZ)
#else
SUBROUTINE D_M3_WR_WTHR_O_DDRDZ(KKA,KKU,KKL,PM3_WR_WTHR,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PD_M3_WR_WTHR_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PM3_WR_WTHR
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_WR_WTHR_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_WR_WTHR_O_DDRDZ
#endif!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_WR_WTHR_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_WR_WTHR_O_DDRDZ = D_M3_WTH_WTHR_O_DDTDZ(PM3_WR_WTHR,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST)
#else
!$acc data present( PM3_WR_WTHR, PREDR1, PREDTH1, PD, PBLL_O_E, PEMOIST, PD_M3_WR_WTHR_O_DDRDZ )
CALL D_M3_WTH_WTHR_O_DDTDZ(PM3_WR_WTHR,PREDR1,PREDTH1,PD,PBLL_O_E,PEMOIST,PD_M3_WR_WTHR_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_WR_WTHR_O_DDRDZ
#else
END SUBROUTINE D_M3_WR_WTHR_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_R2_W2R(PREDR1,PREDTH1,PD,PDRDZ,PLM,PLEPS,PTKE) RESULT(PM3_R2_W2R)
#else
SUBROUTINE M3_R2_W2R(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PDRDZ,PLM,PLEPS,PTKE,PM3_R2_W2R)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_R2_W2R
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_R2_W2R
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_R2_W2R', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_R2_W2R = M3_TH2_W2TH(PREDR1,PREDTH1,PD,PDRDZ,PLM,PLEPS,PTKE)
#else
!$acc data present( PREDR1, PREDTH1, PD, PDRDZ, PLM, PLEPS, PTKE, PM3_R2_W2R )
CALL M3_TH2_W2TH(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PDRDZ,PLM,PLEPS,PTKE,PM3_R2_W2R)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_R2_W2R
#else
END SUBROUTINE M3_R2_W2R
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_R2_W2R_O_DDRDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,OUSERV) RESULT(PD_M3_R2_W2R_O_DDRDZ)
#else
SUBROUTINE D_M3_R2_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,OUSERV,PD_M3_R2_W2R_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE LOGICAL, INTENT(IN) :: OUSERV
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_R2_W2R_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_R2_W2R_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_R2_W2R_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_R2_W2R_O_DDRDZ = D_M3_TH2_W2TH_O_DDTDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,OUSERV)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLM, PLEPS, PTKE,OUSERV, PD_M3_R2_W2R_O_DDRDZ )
CALL D_M3_TH2_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,OUSERV,PD_M3_R2_W2R_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_R2_W2R_O_DDRDZ
#else
END SUBROUTINE D_M3_R2_W2R_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_R2_WR2(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE) RESULT(PM3_R2_WR2)
#else
SUBROUTINE M3_R2_WR2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PM3_R2_WR2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_R2_WR2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_R2_WR2
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_R2_WR2', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_R2_WR2 = M3_TH2_WTH2(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PM3_R2_WR2 )
CALL M3_TH2_WTH2(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PM3_R2_WR2)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_R2_WR2
#else
END SUBROUTINE M3_R2_WR2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_R2_WR2_O_DDRDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST) RESULT(PD_M3_R2_WR2_O_DDRDZ)
#else
SUBROUTINE D_M3_R2_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PD_M3_R2_WR2_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1 REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_R2_WR2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_R2_WR2_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_R2_WR2_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_R2_WR2_O_DDRDZ = D_M3_TH2_WTH2_O_DDTDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PD_M3_R2_WR2_O_DDRDZ )
CALL D_M3_TH2_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PD_M3_R2_WR2_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_R2_WR2_O_DDRDZ
#else
END SUBROUTINE D_M3_R2_WR2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_R2_W2TH(PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PM3_R2_W2TH)
#else
SUBROUTINE M3_R2_W2TH(KKA,KKU,KKL,PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ,PM3_R2_W2TH)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_R2_W2TH
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_R2_W2TH
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_R2_W2TH', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_R2_W2TH = M3_TH2_W2R(PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PD, PLM, PLEPS, PTKE, PBLL_O_E, PETHETA, PDRDZ, PM3_R2_W2TH )
CALL M3_TH2_W2R(KKA,KKU,KKL,PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ,PM3_R2_W2TH)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_R2_W2TH
#else
END SUBROUTINE M3_R2_W2TH
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_R2_W2TH_O_DDRDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PD_M3_R2_W2TH_O_DDRDZ)
#else
SUBROUTINE D_M3_R2_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_R2_W2TH_O_DDRDZ) INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_R2_W2TH_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_R2_W2TH_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_R2_W2TH_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_R2_W2TH_O_DDRDZ = D_M3_TH2_W2R_O_DDTDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLM, PLEPS, PTKE, PBLL_O_E, PETHETA, PDRDZ, PD_M3_R2_W2TH_O_DDRDZ )
CALL D_M3_TH2_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_R2_W2TH_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_R2_W2TH_O_DDRDZ
#else
END SUBROUTINE D_M3_R2_W2TH_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_R2_WTH2(PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PM3_R2_WTH2)
#else
SUBROUTINE M3_R2_WTH2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PM3_R2_WTH2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_R2_WTH2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_R2_WTH2
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_R2_WTH2', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_R2_WTH2 = M3_TH2_WR2(PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PDRDZ, PM3_R2_WTH2 )
CALL M3_TH2_WR2(KKA,KKU,KKL,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PM3_R2_WTH2)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_R2_WTH2
#elseEND SUBROUTINE M3_R2_WTH2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_R2_WTH2_O_DDRDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PD_M3_R2_WTH2_O_DDRDZ)
#else
SUBROUTINE D_M3_R2_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_R2_WTH2_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_R2_WTH2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_R2_WTH2_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_R2_WTH2_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_R2_WTH2_O_DDRDZ = D_M3_TH2_WR2_O_DDTDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PDRDZ, PD_M3_R2_WTH2_O_DDRDZ )
CALL D_M3_TH2_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_R2_WTH2_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_R2_WTH2_O_DDRDZ
#else
END SUBROUTINE D_M3_R2_WTH2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_R2_WTHR(PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PM3_R2_WTHR)
#else
SUBROUTINE M3_R2_WTHR(KKA,KKU,KKL,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PM3_R2_WTHR)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_R2_WTHR
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_R2_WTHR
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_R2_WTHR', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_R2_WTHR = M3_TH2_WTHR(PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PDRDZ, PM3_R2_WTHR )CALL M3_TH2_WTHR(KKA,KKU,KKL,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PM3_R2_WTHR)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_R2_WTHR
#else
END SUBROUTINE M3_R2_WTHR
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_R2_WTHR_O_DDRDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ) RESULT(PD_M3_R2_WTHR_O_DDRDZ)
#else
SUBROUTINE D_M3_R2_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_R2_WTHR_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PETHETA
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDRDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_R2_WTHR_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_R2_WTHR_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_R2_WTHR_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_R2_WTHR_O_DDRDZ = D_M3_TH2_WTHR_O_DDTDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PETHETA, PDRDZ, PD_M3_R2_WTHR_O_DDRDZ )
CALL D_M3_TH2_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PETHETA,PDRDZ,PD_M3_R2_WTHR_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_R2_WTHR_O_DDRDZ
#else
END SUBROUTINE D_M3_R2_WTHR_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_WTHR_O_DDRDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST) RESULT(PD_M3_THR_WTHR_O_DDRDZ)
#else
SUBROUTINE D_M3_THR_WTHR_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PD_M3_THR_WTHR_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_WTHR_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_THR_WTHR_O_DDRDZ
#endif
!#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_WTHR_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_THR_WTHR_O_DDRDZ = D_M3_THR_WTHR_O_DDTDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PD_M3_THR_WTHR_O_DDRDZ )
CALL D_M3_THR_WTHR_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PD_M3_THR_WTHR_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_WTHR_O_DDRDZ
#else
END SUBROUTINE D_M3_THR_WTHR_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_THR_WR2(PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PM3_THR_WR2)
#else
SUBROUTINE M3_THR_WR2(KKA,KKU,KKL,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PM3_THR_WR2)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_THR_WR2
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_THR_WR2
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_THR_WR2', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_THR_WR2 = M3_THR_WTH2(PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ)
#else
!$acc data present( PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PDTDZ, PM3_THR_WR2 )
CALL M3_THR_WTH2(KKA,KKU,KKL,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PM3_THR_WR2)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_THR_WR2
#else
END SUBROUTINE M3_THR_WR2
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_WR2_O_DDRDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ) RESULT(PD_M3_THR_WR2_O_DDRDZ)
#else
SUBROUTINE D_M3_THR_WR2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PD_M3_THR_WR2_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_WR2_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_THR_WR2_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_WR2_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_THR_WR2_O_DDRDZ = D_M3_THR_WTH2_O_DDTDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PDTDZ, PD_M3_THR_WR2_O_DDRDZ )
CALL D_M3_THR_WTH2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PDTDZ,PD_M3_THR_WR2_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_WR2_O_DDRDZ
#else
END SUBROUTINE D_M3_THR_WR2_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_WR2_O_DDTDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST) RESULT(PD_M3_THR_WR2_O_DDTDZ)
#else
SUBROUTINE D_M3_THR_WR2_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PD_M3_THR_WR2_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PSQRT_TKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_WR2_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_THR_WR2_O_DDTDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_WR2_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_THR_WR2_O_DDTDZ = D_M3_THR_WTH2_O_DDRDZ(PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLEPS, PSQRT_TKE, PBLL_O_E, PEMOIST, PD_M3_THR_WR2_O_DDTDZ )
CALL D_M3_THR_WTH2_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLEPS,PSQRT_TKE,PBLL_O_E,PEMOIST,PD_M3_THR_WR2_O_DDTDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_WR2_O_DDTDZ
#else
END SUBROUTINE D_M3_THR_WR2_O_DDTDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION M3_THR_W2R(PREDTH1,PD,PLM,PLEPS,PTKE,PDTDZ) RESULT(PM3_THR_W2R)
#else
SUBROUTINE M3_THR_W2R(KKA,KKU,KKL,PREDTH1,PD,PLM,PLEPS,PTKE,PDTDZ,PM3_THR_W2R)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PM3_THR_W2R
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PM3_THR_W2R
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'M3_THR_W2R', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PM3_THR_W2R = M3_THR_W2TH(PREDTH1,PD,PLM,PLEPS,PTKE,PDTDZ)
#else
!$acc data present( PREDTH1, PD, PLM, PLEPS, PTKE, PDTDZ, PM3_THR_W2R )
CALL M3_THR_W2TH(KKA,KKU,KKL,PREDTH1,PD,PLM,PLEPS,PTKE,PDTDZ,PM3_THR_W2R)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION M3_THR_W2R
#else
END SUBROUTINE M3_THR_W2R
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACC
FUNCTION D_M3_THR_W2R_O_DDRDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PDTDZ,PEMOIST) RESULT(PD_M3_THR_W2R_O_DDRDZ)
#else
SUBROUTINE D_M3_THR_W2R_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PDTDZ,PEMOIST,PD_M3_THR_W2R_O_DDRDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
REAL, DIMENSION(:,:,:), INTENT(IN) :: PBLL_O_E
REAL, DIMENSION(:,:,:), INTENT(IN) :: PDTDZ
REAL, DIMENSION(:,:,:), INTENT(IN) :: PEMOIST
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_W2R_O_DDRDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_THR_W2R_O_DDRDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_W2R_O_DDRDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_THR_W2R_O_DDRDZ = D_M3_THR_W2TH_O_DDTDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PDTDZ,PEMOIST)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLM, PLEPS, PTKE, PBLL_O_E, PDTDZ, PEMOIST, PD_M3_THR_W2R_O_DDRDZ )
CALL D_M3_THR_W2TH_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PBLL_O_E,PDTDZ,PEMOIST,PD_M3_THR_W2R_O_DDRDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_W2R_O_DDRDZ
#else
END SUBROUTINE D_M3_THR_W2R_O_DDRDZ
#endif
!----------------------------------------------------------------------------
#ifndef MNH_OPENACCFUNCTION D_M3_THR_W2R_O_DDTDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE) RESULT(PD_M3_THR_W2R_O_DDTDZ)
#else
SUBROUTINE D_M3_THR_W2R_O_DDTDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PD_M3_THR_W2R_O_DDTDZ)
INTEGER, INTENT(IN) :: KKA
INTEGER, INTENT(IN) :: KKU
INTEGER, INTENT(IN) :: KKL
#endif
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDR1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PREDTH1
REAL, DIMENSION(:,:,:), INTENT(IN) :: PD
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLM
REAL, DIMENSION(:,:,:), INTENT(IN) :: PLEPS
REAL, DIMENSION(:,:,:), INTENT(IN) :: PTKE
#ifndef MNH_OPENACC
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)) :: PD_M3_THR_W2R_O_DDTDZ
#else
REAL, DIMENSION(SIZE(PD,1),SIZE(PD,2),SIZE(PD,3)), INTENT(OUT) :: PD_M3_THR_W2R_O_DDTDZ
#endif
!
#ifdef MNH_OPENACC
call Print_msg( NVERB_WARNING, 'GEN', 'D_M3_THR_W2R_O_DDTDZ', 'OpenACC: not yet tested' )
#endif
#ifndef MNH_OPENACC
PD_M3_THR_W2R_O_DDTDZ = D_M3_THR_W2TH_O_DDRDZ(PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE)
#else
!$acc data present( PREDR1, PREDTH1, PD, PLM, PLEPS, PTKE, PD_M3_THR_W2R_O_DDTDZ )
CALL D_M3_THR_W2TH_O_DDRDZ(KKA,KKU,KKL,PREDR1,PREDTH1,PD,PLM,PLEPS,PTKE,PD_M3_THR_W2R_O_DDTDZ)
!$acc end data
#endif
!
#ifndef MNH_OPENACC
END FUNCTION D_M3_THR_W2R_O_DDTDZ
#else
END SUBROUTINE D_M3_THR_W2R_O_DDTDZ
#endif
!----------------------------------------------------------------------------
!
END MODULE MODE_PRANDTL