diff --git a/src/MNH/rain_ice_sedimentation_split.f90 b/src/MNH/rain_ice_sedimentation_split.f90
index db4078db3021849dfdb9a1df9ad3933326dc9e06..6a5024378325e3868bac49ae960f5fdaee584999 100644
--- a/src/MNH/rain_ice_sedimentation_split.f90
+++ b/src/MNH/rain_ice_sedimentation_split.f90
@@ -7,6 +7,7 @@
! P. Wautelet 25/02/2019: split rain_ice (cleaner and easier to maintain/debug)
! P. Wautelet 26/04/2019: replace non-standard FLOAT function by REAL function
! P. Wautelet 28/05/2019: move COUNTJV function to tools.f90
+! P. Wautelet 25/06/2019: OpenACC: optimisation of rain_ice_sedimentation_split
!-----------------------------------------------------------------
MODULE MODE_RAIN_ICE_SEDIMENTATION_SPLIT
@@ -18,10 +19,11 @@ MODULE MODE_RAIN_ICE_SEDIMENTATION_SPLIT
CONTAINS
-SUBROUTINE RAIN_ICE_SEDIMENTATION_SPLIT(KIB, KIE, KJB, KJE, KKB, KKE, KKTB, KKTE, KKT, KKL,&
- KSPLITR,PTSTEP, &
- KRR,OSEDIC,ODEPOSC,PINPRC,PINDEP,PINPRR,PINPRS,PINPRG,PDZZ,PRHODREF,PPABST,PTHT,PRHODJ,&
- PINPRR3D,PRCS,PRCT,PRRS,PRRT,PRIS,PRIT,PRSS,PRST,PRGS,PRGT,PSEA,PTOWN,PINPRH,PRHS,PRHT,PFPR)
+SUBROUTINE RAIN_ICE_SEDIMENTATION_SPLIT( KIB, KIE, KJB, KJE, KKB, KKE, KKTB, KKTE, KKT, KKL, &
+ KSPLITR, PTSTEP, KRR, OSEDIC, ODEPOSC, &
+ PINPRC, PINDEP, PINPRR, PINPRS, PINPRG, PDZZ, PRHODREF, PPABST, PTHT, PRHODJ, &
+ PINPRR3D, PRCS, PRCT, PRRS, PRRT, PRIS, PRIT, PRSS, PRST, PRGS, PRGT, &
+ PSEA, PTOWN, PINPRH, PRHS, PRHT, PFPR )
!
!* 0. DECLARATIONS
! ------------
@@ -103,80 +105,53 @@ REAL, DIMENSION(:,:,:,:), OPTIONAL, INTENT(OUT) :: PFPR ! upper-air precipi
!* 0.2 declaration of local variables
!
!
-INTEGER, SAVE :: IOLDALLOCC = 6000
-INTEGER, SAVE :: IOLDALLOCR = 6000
-INTEGER, SAVE :: IOLDALLOCI = 6000
-INTEGER, SAVE :: IOLDALLOCS = 6000
-INTEGER, SAVE :: IOLDALLOCG = 6000
-INTEGER, SAVE :: IOLDALLOCH = 6000
-INTEGER :: ILENALLOCC,ILENALLOCR,ILENALLOCI,ILENALLOCS,ILENALLOCG,ILENALLOCH
-INTEGER :: ILISTLENC,ILISTLENR,ILISTLENI,ILISTLENS,ILISTLENG,ILISTLENH
-INTEGER :: ISEDIMR,ISEDIMC, ISEDIMI, ISEDIMS, ISEDIMG, ISEDIMH
-INTEGER :: JK ! Vertical loop index for the rain sedimentation
-INTEGER :: JN ! Temporal loop index for the rain sedimentation
-INTEGER :: JJ ! Loop index for the interpolation
-INTEGER :: JL
-INTEGER, DIMENSION(:), ALLOCATABLE :: IC1,IC2,IC3 ! Used to replace the COUNT
-INTEGER, DIMENSION(:), ALLOCATABLE :: IR1,IR2,IR3 ! Used to replace the COUNT
-INTEGER, DIMENSION(:), ALLOCATABLE :: IS1,IS2,IS3 ! Used to replace the COUNT
-INTEGER, DIMENSION(:), ALLOCATABLE :: II1,II2,II3 ! Used to replace the COUNT
-INTEGER, DIMENSION(:), ALLOCATABLE :: IG1,IG2,IG3 ! Used to replace the COUNT
-INTEGER, DIMENSION(:), ALLOCATABLE :: IH1,IH2,IH3 ! Used to replace the COUNT
-INTEGER, DIMENSION(:), ALLOCATABLE :: ILISTR,ILISTC,ILISTI,ILISTS,ILISTG,ILISTH
-LOGICAL :: GPRESENT_PFPR, GPRESENT_PSEA
-LOGICAL, DIMENSION(:,:), ALLOCATABLE :: GDEP
-LOGICAL, DIMENSION(:,:,:), ALLOCATABLE &
- :: GSEDIMR,GSEDIMC, GSEDIMI, GSEDIMS, GSEDIMG, GSEDIMH ! Test where to compute the SED processes
-REAL :: ZINVTSTEP
-REAL :: ZTSPLITR ! Small time step for rain sedimentation
-REAL :: ZTMP1, ZTMP2 ! Intermediate variables
-REAL, DIMENSION(:), ALLOCATABLE :: ZRTMIN
+INTEGER :: ISEDIMR, ISEDIMC, ISEDIMI, ISEDIMS, ISEDIMG, ISEDIMH
+INTEGER :: JI, JJ, JK ! Loop indices on grid
+INTEGER :: JN ! Temporal loop index for the rain sedimentation
+INTEGER :: JL
+INTEGER, DIMENSION(:), ALLOCATABLE :: IC1, IC2, IC3 ! Used to replace the COUNT
+INTEGER, DIMENSION(:), ALLOCATABLE :: IR1, IR2, IR3 ! Used to replace the COUNT
+INTEGER, DIMENSION(:), ALLOCATABLE :: IS1, IS2, IS3 ! Used to replace the COUNT
+INTEGER, DIMENSION(:), ALLOCATABLE :: II1, II2, II3 ! Used to replace the COUNT
+INTEGER, DIMENSION(:), ALLOCATABLE :: IG1, IG2, IG3 ! Used to replace the COUNT
+INTEGER, DIMENSION(:), ALLOCATABLE :: IH1, IH2, IH3 ! Used to replace the COUNT
+LOGICAL :: GPRESENT_PFPR, GPRESENT_PSEA
+LOGICAL, DIMENSION(:,:), ALLOCATABLE :: GDEP
+LOGICAL, DIMENSION(:,:,:), ALLOCATABLE :: GSEDIMR, GSEDIMC, GSEDIMI, GSEDIMS, GSEDIMG, GSEDIMH ! Where to compute the SED processes
+REAL :: ZINVTSTEP
+REAL :: ZTSPLITR ! Small time step for rain sedimentation
+REAL :: ZTMP1, ZTMP2, ZTMP3 ! Intermediate variables
+REAL :: ZRHODREFLOC ! RHO Dry REFerence
+REAL :: ZRSLOC, ZRTLOC ! Intermediate variables
+REAL, DIMENSION(:), ALLOCATABLE :: ZRTMIN
! XRTMIN = Minimum value for the mixing ratio
! ZRTMIN = Minimum value for the source (tendency)
-REAL, DIMENSION(:), ALLOCATABLE :: ZRCS ! Cloud water m.r. source
-REAL, DIMENSION(:), ALLOCATABLE :: ZRRS ! Rain water m.r. source
-REAL, DIMENSION(:), ALLOCATABLE :: ZRIS ! Pristine ice m.r. source
-REAL, DIMENSION(:), ALLOCATABLE :: ZRSS ! Snow/aggregate m.r. source
-REAL, DIMENSION(:), ALLOCATABLE :: ZRGS ! Graupel m.r. source
-REAL, DIMENSION(:), ALLOCATABLE :: ZRHS ! Hail m.r. source
-REAL, DIMENSION(:), ALLOCATABLE :: ZRCT ! Cloud water m.r. at t
-REAL, DIMENSION(:), ALLOCATABLE :: ZRHODREFC,& ! RHO Dry REFerence
- ZRHODREFR,& ! RHO Dry REFerence
- ZRHODREFI,& ! RHO Dry REFerence
- ZRHODREFS,& ! RHO Dry REFerence
- ZRHODREFG,& ! RHO Dry REFerence
- ZRHODREFH,& ! RHO Dry REFerence
- ZCC, & ! terminal velocity
- ZFSEDC1D, & ! For cloud sedimentation
- ZWLBDC, & ! Slope parameter of the droplet distribution
- ZCONC, & ! Concentration des aerosols
- ZRAY1D, & ! Mean radius
- ZWLBDA, & ! Libre parcours moyen
- ZZT, & ! Temperature
- ZPRES ! Pressure
-REAL, DIMENSION(:,:), ALLOCATABLE &
- :: ZCONC_TMP ! Weighted concentration
-REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZCONC3D ! droplet condensation
-REAL, DIMENSION(:,:,:), ALLOCATABLE :: &
- ZRAY, & ! Cloud Mean radius
- ZLBC, & ! XLBC weighted by sea fraction
- ZFSEDC
-REAL, DIMENSION(:,:,:), ALLOCATABLE &
- :: ZPRCS,ZPRRS,ZPRSS,ZPRGS,ZPRHS ! Mixing ratios created during the time step
-REAL, DIMENSION(:,:,:), ALLOCATABLE &
- :: ZW ! work array
-REAL, DIMENSION(:,:,:), ALLOCATABLE &
- :: ZWSED ! sedimentation fluxes
-!
-! !$acc declare device_resident(IC1, IC2, IC3, IR1, IR2, IR3, IS1, IS2, IS3, II1, II2, II3, IG1, IG2, IG3, IH1, IH2, IH3, &
-!$acc declare create(IC1, IC2, IC3, IR1, IR2, IR3, IS1, IS2, IS3, II1, II2, II3, IG1, IG2, IG3, IH1, IH2, IH3, &
-!$acc & ILISTR, ILISTC, ILISTI, ILISTS, ILISTG, ILISTH, &
+REAL :: ZCC, & ! terminal velocity
+ ZFSEDC1D, & ! For cloud sedimentation
+ ZWLBDC, & ! Slope parameter of the droplet distribution
+ ZCONC, & ! Concentration des aerosols
+ ZRAY1D, & ! Mean radius
+ ZWLBDA, & ! Free mean path
+ ZZT, & ! Temperature
+ ZPRES ! Pressure
+REAL, DIMENSION(:,:), ALLOCATABLE :: ZCONC_TMP ! Weighted concentration
+REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZCONC3D ! Doplet condensation
+REAL, DIMENSION(:,:), ALLOCATABLE :: ZOMPSEA,ZTMP1_2D,ZTMP2_2D,ZTMP3_2D,ZTMP4_2D !Work arrays
+REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZRAY, & ! Cloud Mean radius
+ ZLBC, & ! XLBC weighted by sea fraction
+ ZFSEDC
+REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZPRCS,ZPRRS,ZPRSS,ZPRGS,ZPRHS ! Mixing ratios created during the time step
+REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZW ! Work array
+REAL, DIMENSION(:,:,:), ALLOCATABLE :: ZWSED ! sedimentation fluxes
+!
+!$acc declare device_resident(IC1, IC2, IC3, IR1, IR2, IR3, IS1, IS2, IS3, II1, II2, II3, IG1, IG2, IG3, IH1, IH2, IH3, &
!$acc & GDEP, GSEDIMR, GSEDIMC, GSEDIMI, GSEDIMS, GSEDIMG, GSEDIMH, &
-! !$acc & ZTMP1, ZTMP2, &
-!$acc & ZRTMIN, ZRCS, ZRRS, ZRIS, ZRSS, ZRGS, ZRHS, ZRCT, &
-!$acc & ZRHODREFC, ZRHODREFR, ZRHODREFI, ZRHODREFS, ZRHODREFG, ZRHODREFH, &
-!$acc & ZCC, ZFSEDC1D, ZWLBDC, ZCONC, ZRAY1D, ZWLBDA, ZZT, ZPRES, &
-!$acc & ZCONC_TMP, ZCONC3D, ZRAY, ZLBC, ZFSEDC, &
+!PW:BUG: do not uncomment to get correct results !$acc & ZTMP1, ZTMP2, &
+!PW:BUG: do not uncomment to get correct results !$acc & ZRHODREFLOC, ZRSLOC, ZRTLOC, &
+!PW:BUG: do not uncomment to get correct results !$acc & ZCC, ZFSEDC1D, ZWLBDC, ZCONC, ZRAY1D, ZWLBDA, ZZT, ZPRES, &
+!$acc & ZRTMIN, ZCONC_TMP, ZCONC3D, &
+!$acc & ZOMPSEA, ZTMP1_2D, ZTMP2_2D, ZTMP3_2D, ZTMP4_2D, &
+!$acc & ZRAY, ZLBC, ZFSEDC, &
!$acc & ZPRCS, ZPRRS, ZPRSS, ZPRGS, ZPRHS, ZW, ZWSED)
!
!$acc declare copyin(XFSEDC, XLBC, XLBEXC, XRTMIN)
@@ -223,6 +198,11 @@ ALLOCATE( GSEDIMG(SIZE(PRCS,1),SIZE(PRCS,2),SIZE(PRCS,3)) )
ALLOCATE( GSEDIMH(SIZE(PRCS,1),SIZE(PRCS,2),SIZE(PRCS,3)) )
ALLOCATE( ZRTMIN(SIZE(XRTMIN)) )
ALLOCATE( ZCONC_TMP(SIZE(PRCS,1),SIZE(PRCS,2)) )
+ALLOCATE( ZOMPSEA (SIZE(PRCS,1),SIZE(PRCS,2)) )
+ALLOCATE( ZTMP1_2D (SIZE(PRCS,1),SIZE(PRCS,2)) )
+ALLOCATE( ZTMP2_2D (SIZE(PRCS,1),SIZE(PRCS,2)) )
+ALLOCATE( ZTMP3_2D (SIZE(PRCS,1),SIZE(PRCS,2)) )
+ALLOCATE( ZTMP4_2D (SIZE(PRCS,1),SIZE(PRCS,2)) )
ALLOCATE( ZCONC3D(SIZE(PRCS,1),SIZE(PRCS,2),SIZE(PRCS,3)) )
ALLOCATE( ZRAY (SIZE(PRCS,1),SIZE(PRCS,2),SIZE(PRCS,3)) )
ALLOCATE( ZLBC (SIZE(PRCS,1),SIZE(PRCS,2),SIZE(PRCS,3)) )
@@ -252,43 +232,53 @@ END IF
ZINVTSTEP=1./PTSTEP
ZTSPLITR= PTSTEP / REAL(KSPLITR)
!
-IF (OSEDIC) PINPRC (:,:) = 0.
-IF (ODEPOSC) PINDEP (:,:) = 0.
-PINPRR (:,:) = 0.
+IF ( OSEDIC ) PINPRC (:,:) = 0.
+IF ( ODEPOSC ) PINDEP (:,:) = 0.
+PINPRR (:,:) = 0.
PINPRR3D (:,:,:) = 0.
-PINPRS (:,:) = 0.
-PINPRG (:,:) = 0.
+PINPRS (:,:) = 0.
+PINPRG (:,:) = 0.
IF ( KRR == 7 ) PINPRH (:,:) = 0.
IF ( GPRESENT_PFPR ) PFPR(:,:,:,:) = 0.
!
!* 1. Parameters for cloud sedimentation
!
- IF (OSEDIC) THEN
- ZTMP1 = 0.5*GAMMA(XNUC+ 1.0/XALPHAC )/(GAMMA(XNUC ))
- ZTMP2 = 0.5*GAMMA(XNUC2+1.0/XALPHAC2)/(GAMMA(XNUC2))
+IF ( OSEDIC ) THEN
+ ZTMP1 = 0.5 * GAMMA( XNUC + 1.0 / XALPHAC ) / ( GAMMA( XNUC ) )
+ ZTMP2 = 0.5 * GAMMA( XNUC2 + 1.0 / XALPHAC2 ) / ( GAMMA( XNUC2 ) )
- ZRAY(:,:,:) = 0.
- ZLBC(:,:,:) = XLBC(1)
- ZFSEDC(:,:,:) = XFSEDC(1)
- ZCONC3D(:,:,:)= XCONC_LAND
- ZCONC_TMP(:,:)= XCONC_LAND
- IF ( GPRESENT_PSEA ) THEN
- ZCONC_TMP(:,:)=PSEA(:,:)*XCONC_SEA+(1.-PSEA(:,:))*XCONC_LAND
+ IF ( GPRESENT_PSEA ) THEN
+ !$acc loop independent collapse(2)
+ DO JJ = 1, SIZE( PRCS, 2 )
+ DO JI = 1, SIZE( PRCS, 1 )
+ ZOMPSEA (JI,JJ) = 1.-PSEA(JI,JJ)
+ ZTMP1_2D (JI,JJ) = PSEA(JI,JJ)*XLBC(2) +ZOMPSEA(JI,JJ)*XLBC(1)
+ ZTMP2_2D (JI,JJ) = PSEA(JI,JJ)*XFSEDC(2)+ZOMPSEA(JI,JJ)*XFSEDC(1)
+ ZCONC_TMP(JI,JJ) = PSEA(JI,JJ)*XCONC_SEA+ZOMPSEA(JI,JJ)*XCONC_LAND
+ ZTMP3_2D (JI,JJ) = (1.-PTOWN(JI,JJ))*ZCONC_TMP(JI,JJ)+PTOWN(JI,JJ)*XCONC_URBAN
+ ZTMP4_2D (JI,JJ) = MAX( 1. , ZOMPSEA(JI,JJ)*ZTMP1 + PSEA(JI,JJ)*ZTMP2 )
+ END DO
+ END DO
- DO JK=KKTB,KKTE
- ZLBC(:,:,JK) = PSEA(:,:)*XLBC(2)+(1.-PSEA(:,:))*XLBC(1)
- ZFSEDC(:,:,JK) = (PSEA(:,:)*XFSEDC(2)+(1.-PSEA(:,:))*XFSEDC(1))
- ZFSEDC(:,:,JK) = MAX(MIN(XFSEDC(1),XFSEDC(2)),ZFSEDC(:,:,JK))
- ZCONC3D(:,:,JK)= (1.-PTOWN(:,:))*ZCONC_TMP(:,:)+PTOWN(:,:)*XCONC_URBAN
- ZRAY(:,:,JK) = (1.-PSEA(:,:)) * ZTMP1 + PSEA(:,:) * ZTMP2
+!$acc loop independent collapse(3)
+ DO JK = KKTB, KKTE
+ DO JJ = 1, SIZE( PRCS, 2 )
+ DO JI = 1, SIZE( PRCS, 1 )
+ ZLBC (JI,JJ,JK) = ZTMP1_2D(JI,JJ)
+ ZFSEDC (JI,JJ,JK) = ZTMP2_2D(JI,JJ)
+ ZCONC3D(JI,JJ,JK) = ZTMP3_2D(JI,JJ)
+ ZRAY (JI,JJ,JK) = ZTMP4_2D(JI,JJ)
+ END DO
END DO
- ELSE
- ZCONC3D(:,:,:) = XCONC_LAND
- ZRAY (:,:,:) = ZTMP1
- END IF
- ZRAY(:,:,:) = MAX(1.,ZRAY(:,:,:))
- ZLBC(:,:,:) = MAX(MIN(XLBC(1),XLBC(2)),ZLBC(:,:,:))
- ENDIF
+ END DO
+ ELSE
+ ZLBC (:,:,:) = XLBC(1)
+ ZFSEDC (:,:,:) = XFSEDC(1)
+ ZCONC3D(:,:,:) = XCONC_LAND
+ ZTMP3 = MAX(1.,ZTMP1)
+ ZRAY (:,:,:) = ZTMP3
+ END IF
+END IF
!
!* 2. compute the fluxes
!
@@ -296,30 +286,23 @@ IF ( GPRESENT_PFPR ) PFPR(:,:,:,:) = 0.
! the precipitating fields are larger than a minimal value only !!!
! For optimization we consider each variable separately
-ZRTMIN(:) = XRTMIN(:) * ZINVTSTEP
-IF (OSEDIC) GSEDIMC(:,:,:) = .FALSE.
+ZRTMIN(:) = XRTMIN(:) * ZINVTSTEP
+IF ( OSEDIC ) GSEDIMC(:,:,:) = .FALSE.
GSEDIMR(:,:,:) = .FALSE.
GSEDIMI(:,:,:) = .FALSE.
GSEDIMS(:,:,:) = .FALSE.
GSEDIMG(:,:,:) = .FALSE.
IF ( KRR == 7 ) GSEDIMH(:,:,:) = .FALSE.
!
-ILENALLOCR = 0
-IF (OSEDIC) ILENALLOCC = 0
-ILENALLOCI = 0
-ILENALLOCS = 0
-ILENALLOCG = 0
-IF ( KRR == 7 ) ILENALLOCH = 0
-!
! ZPiS = Specie i source creating during the current time step
! PRiS = Source of the previous time step
!
-IF (OSEDIC) THEN
+IF ( OSEDIC ) THEN
ZPRCS(:,:,:) = 0.0
- ZPRCS(:,:,:) = PRCS(:,:,:)-PRCT(:,:,:)* ZINVTSTEP
- PRCS(:,:,:) = PRCT(:,:,:)* ZINVTSTEP
+ ZPRCS(:,:,:) = PRCS(:,:,:) - PRCT(:,:,:) * ZINVTSTEP
+ PRCS (:,:,:) = PRCT(:,:,:)* ZINVTSTEP
END IF
-!
+#if 0
ZPRRS(:,:,:) = PRRS(:,:,:)-PRRT(:,:,:)* ZINVTSTEP
ZPRSS(:,:,:) = PRSS(:,:,:)-PRST(:,:,:)* ZINVTSTEP
ZPRGS(:,:,:) = PRGS(:,:,:)-PRGT(:,:,:)* ZINVTSTEP
@@ -328,6 +311,32 @@ PRRS(:,:,:) = PRRT(:,:,:)* ZINVTSTEP
PRSS(:,:,:) = PRST(:,:,:)* ZINVTSTEP
PRGS(:,:,:) = PRGT(:,:,:)* ZINVTSTEP
IF ( KRR == 7 ) PRHS(:,:,:) = PRHT(:,:,:)* ZINVTSTEP
+#else
+!$acc loop collapse(3) independent
+DO JK = 1, SIZE( PRRS, 3 )
+ DO JJ = 1, SIZE( PRRS, 2 )
+ DO JI = 1, SIZE( PRRS, 1 )
+ ZPRRS(JI,JJ,JK) = PRRS(JI,JJ,JK) - PRRT(JI,JJ,JK) * ZINVTSTEP
+ ZPRSS(JI,JJ,JK) = PRSS(JI,JJ,JK) - PRST(JI,JJ,JK) * ZINVTSTEP
+ ZPRGS(JI,JJ,JK) = PRGS(JI,JJ,JK) - PRGT(JI,JJ,JK) * ZINVTSTEP
+ PRRS (JI,JJ,JK) = PRRT(JI,JJ,JK) * ZINVTSTEP
+ PRSS (JI,JJ,JK) = PRST(JI,JJ,JK) * ZINVTSTEP
+ PRGS (JI,JJ,JK) = PRGT(JI,JJ,JK) * ZINVTSTEP
+ END DO
+ END DO
+END DO
+IF ( KRR == 7 ) THEN
+!$acc loop collapse(3) independent
+DO JK = 1, SIZE( PRHS, 3 )
+ DO JJ = 1, SIZE( PRHS, 2 )
+ DO JI = 1, SIZE( PRHS, 1 )
+ ZPRHS(JI,JJ,JK) = PRHS(JI,JJ,JK) - PRHT(JI,JJ,JK) * ZINVTSTEP
+ PRHS (JI,JJ,JK) = PRHT(JI,JJ,JK) * ZINVTSTEP
+ END DO
+ END DO
+ END DO
+END IF
+#endif
!$acc end kernels
!
! PRiS = Source of the previous time step + source created during the subtime
@@ -335,456 +344,279 @@ IF ( KRR == 7 ) PRHS(:,:,:) = PRHT(:,:,:)* ZINVTSTEP
!
DO JN = 1 , KSPLITR
!$acc kernels
- IF( JN==1 ) THEN
- IF (OSEDIC) PRCS(:,:,:) = PRCS(:,:,:) + ZPRCS(:,:,:)/KSPLITR
- PRRS(:,:,:) = PRRS(:,:,:) + ZPRRS(:,:,:)/KSPLITR
- PRSS(:,:,:) = PRSS(:,:,:) + ZPRSS(:,:,:)/KSPLITR
- PRGS(:,:,:) = PRGS(:,:,:) + ZPRGS(:,:,:)/KSPLITR
- IF ( KRR == 7 ) PRHS(:,:,:) = PRHS(:,:,:) + ZPRHS(:,:,:)/KSPLITR
- DO JK = KKTB , KKTE
- ZW(:,:,JK) =ZTSPLITR/(PRHODREF(:,:,JK)* PDZZ(:,:,JK))
- END DO
- ELSE
- IF (OSEDIC) PRCS(:,:,:) = PRCS(:,:,:) + ZPRCS(:,:,:)*ZTSPLITR
- PRRS(:,:,:) = PRRS(:,:,:) + ZPRRS(:,:,:)*ZTSPLITR
- PRSS(:,:,:) = PRSS(:,:,:) + ZPRSS(:,:,:)*ZTSPLITR
- PRGS(:,:,:) = PRGS(:,:,:) + ZPRGS(:,:,:)*ZTSPLITR
- IF ( KRR == 7 ) PRHS(:,:,:) = PRHS(:,:,:) + ZPRHS(:,:,:)*ZTSPLITR
- END IF
- !
- IF (OSEDIC) GSEDIMC(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
- PRCS(KIB:KIE,KJB:KJE,KKTB:KKTE)>ZRTMIN(2)
- GSEDIMR(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
- PRRS(KIB:KIE,KJB:KJE,KKTB:KKTE)>ZRTMIN(3)
- GSEDIMI(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
- PRIS(KIB:KIE,KJB:KJE,KKTB:KKTE)>ZRTMIN(4)
- GSEDIMS(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
- PRSS(KIB:KIE,KJB:KJE,KKTB:KKTE)>ZRTMIN(5)
- GSEDIMG(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
- PRGS(KIB:KIE,KJB:KJE,KKTB:KKTE)>ZRTMIN(6)
- IF ( KRR == 7 ) GSEDIMH(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
- PRHS(KIB:KIE,KJB:KJE,KKTB:KKTE)>ZRTMIN(7)
+ IF( JN == 1 ) THEN
+ IF ( OSEDIC ) PRCS(:,:,:) = PRCS(:,:,:) + ZPRCS(:,:,:) / KSPLITR
+ PRRS(:,:,:) = PRRS(:,:,:) + ZPRRS(:,:,:) / KSPLITR
+ PRSS(:,:,:) = PRSS(:,:,:) + ZPRSS(:,:,:) / KSPLITR
+ PRGS(:,:,:) = PRGS(:,:,:) + ZPRGS(:,:,:) / KSPLITR
+ IF ( KRR == 7 ) PRHS(:,:,:) = PRHS(:,:,:) + ZPRHS(:,:,:) / KSPLITR
+ DO JK = KKTB , KKTE
+ ZW(:,:,JK) = ZTSPLITR / ( PRHODREF(:,:,JK) * PDZZ(:,:,JK) )
+ END DO
+ ELSE
+ IF ( OSEDIC ) PRCS(:,:,:) = PRCS(:,:,:) + ZPRCS(:,:,:) * ZTSPLITR
+ PRRS(:,:,:) = PRRS(:,:,:) + ZPRRS(:,:,:) * ZTSPLITR
+ PRSS(:,:,:) = PRSS(:,:,:) + ZPRSS(:,:,:) * ZTSPLITR
+ PRGS(:,:,:) = PRGS(:,:,:) + ZPRGS(:,:,:) * ZTSPLITR
+ IF ( KRR == 7 ) PRHS(:,:,:) = PRHS(:,:,:) + ZPRHS(:,:,:) * ZTSPLITR
+ END IF
+ !
+ IF ( OSEDIC ) GSEDIMC(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
+ PRCS(KIB:KIE,KJB:KJE,KKTB:KKTE) > ZRTMIN(2)
+ GSEDIMR(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
+ PRRS(KIB:KIE,KJB:KJE,KKTB:KKTE) > ZRTMIN(3)
+ GSEDIMI(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
+ PRIS(KIB:KIE,KJB:KJE,KKTB:KKTE) > ZRTMIN(4)
+ GSEDIMS(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
+ PRSS(KIB:KIE,KJB:KJE,KKTB:KKTE) > ZRTMIN(5)
+ GSEDIMG(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
+ PRGS(KIB:KIE,KJB:KJE,KKTB:KKTE) > ZRTMIN(6)
+ IF ( KRR == 7 ) GSEDIMH(KIB:KIE,KJB:KJE,KKTB:KKTE) = &
+ PRHS(KIB:KIE,KJB:KJE,KKTB:KKTE) > ZRTMIN(7)
!$acc end kernels
!
#ifndef _OPENACC
-IF (OSEDIC) ISEDIMC = COUNTJV( GSEDIMC(:,:,:),IC1(:),IC2(:),IC3(:))
- ISEDIMR = COUNTJV( GSEDIMR(:,:,:),IR1(:),IR2(:),IR3(:))
- ISEDIMI = COUNTJV( GSEDIMI(:,:,:),II1(:),II2(:),II3(:))
- ISEDIMS = COUNTJV( GSEDIMS(:,:,:),IS1(:),IS2(:),IS3(:))
- ISEDIMG = COUNTJV( GSEDIMG(:,:,:),IG1(:),IG2(:),IG3(:))
- IF ( KRR == 7 ) ISEDIMH = COUNTJV( GSEDIMH(:,:,:),IH1(:),IH2(:),IH3(:))
+ IF ( OSEDIC ) ISEDIMC = COUNTJV( GSEDIMC(:,:,:), IC1(:), IC2(:), IC3(:) )
+ ISEDIMR = COUNTJV( GSEDIMR(:,:,:), IR1(:), IR2(:), IR3(:) )
+ ISEDIMI = COUNTJV( GSEDIMI(:,:,:), II1(:), II2(:), II3(:) )
+ ISEDIMS = COUNTJV( GSEDIMS(:,:,:), IS1(:), IS2(:), IS3(:) )
+ ISEDIMG = COUNTJV( GSEDIMG(:,:,:), IG1(:), IG2(:), IG3(:) )
+ IF ( KRR == 7 ) ISEDIMH = COUNTJV( GSEDIMH(:,:,:), IH1(:), IH2(:), IH3(:) )
#else
- IF (OSEDIC) CALL COUNTJV_DEVICE(GSEDIMC,IC1,IC2,IC3,ISEDIMC)
- CALL COUNTJV_DEVICE(GSEDIMR,IR1,IR2,IR3,ISEDIMR)
- CALL COUNTJV_DEVICE(GSEDIMI,II1,II2,II3,ISEDIMI)
- CALL COUNTJV_DEVICE(GSEDIMS,IS1,IS2,IS3,ISEDIMS)
- CALL COUNTJV_DEVICE(GSEDIMG,IG1,IG2,IG3,ISEDIMG)
- IF ( KRR == 7 ) CALL COUNTJV_DEVICE(GSEDIMH,IH1,IH2,IH3,ISEDIMH)
+ IF ( OSEDIC ) CALL COUNTJV_DEVICE( GSEDIMC, IC1, IC2, IC3, ISEDIMC )
+ CALL COUNTJV_DEVICE( GSEDIMR, IR1, IR2, IR3, ISEDIMR )
+ CALL COUNTJV_DEVICE( GSEDIMI, II1, II2, II3, ISEDIMI )
+ CALL COUNTJV_DEVICE( GSEDIMS, IS1, IS2, IS3, ISEDIMS )
+ CALL COUNTJV_DEVICE( GSEDIMG, IG1, IG2, IG3, ISEDIMG )
+ IF ( KRR == 7 ) CALL COUNTJV_DEVICE( GSEDIMH, IH1, IH2, IH3, ISEDIMH )
#endif
!
!* 2.1 for cloud
!
-IF (OSEDIC) THEN
-!$acc kernels
- ZWSED(:,:,:) = 0.
- IF( JN==1 ) PRCS(:,:,:) = PRCS(:,:,:) * PTSTEP
-!$acc end kernels
- IF( ISEDIMC >= 1 ) THEN
- IF ( ISEDIMC .GT. ILENALLOCC ) THEN
- IF ( ILENALLOCC .GT. 0 ) THEN
- DEALLOCATE (ZRCS, ZRHODREFC, ILISTC,ZWLBDC,ZCONC,ZRCT, &
- ZZT,ZPRES,ZRAY1D,ZFSEDC1D,ZWLBDA,ZCC )
- END IF
- ILENALLOCC = MAX (IOLDALLOCC, 2*ISEDIMC )
- IOLDALLOCC = ILENALLOCC
- ALLOCATE(ZRCS(ILENALLOCC), ZRHODREFC(ILENALLOCC), ILISTC(ILENALLOCC), &
- ZWLBDC(ILENALLOCC), ZCONC(ILENALLOCC), ZRCT(ILENALLOCC), ZZT(ILENALLOCC), &
- ZPRES(ILENALLOCC), ZRAY1D(ILENALLOCC), ZFSEDC1D(ILENALLOCC), &
- ZWLBDA(ILENALLOCC), ZCC(ILENALLOCC) )
-!$acc kernels
-ZRCS (:) = 0.
-ZRHODREFC(:) = 0.
-ILISTC (:) = 0
-ZWLBDC (:) = 0.
-ZCONC (:) = 0.
-ZRCT (:) = 0.
-ZZT (:) = 0.
-ZPRES (:) = 0.
-ZRAY1D (:) = 0.
-ZFSEDC1D (:) = 0.
-ZWLBDA (:) = 0.
-ZCC (:) = 0.
-!$acc end kernels
- END IF
-!
!$acc kernels
- DO JL=1,ISEDIMC
- ZRCS(JL) = PRCS(IC1(JL),IC2(JL),IC3(JL))
- ZRHODREFC(JL) = PRHODREF(IC1(JL),IC2(JL),IC3(JL))
- ZWLBDC(JL) = ZLBC(IC1(JL),IC2(JL),IC3(JL))
- ZCONC(JL) = ZCONC3D(IC1(JL),IC2(JL),IC3(JL))
- ZRCT(JL) = PRCT(IC1(JL),IC2(JL),IC3(JL))
- ZZT(JL) = PTHT(IC1(JL),IC2(JL),IC3(JL))
- ZPRES(JL) = PPABST(IC1(JL),IC2(JL),IC3(JL))
- ZRAY1D(JL) = ZRAY(IC1(JL),IC2(JL),IC3(JL))
- ZFSEDC1D(JL) = ZFSEDC(IC1(JL),IC2(JL),IC3(JL))
- END DO
-!
- ILISTLENC = 0
- DO JL=1,ISEDIMC
- IF( ZRCS(JL) .GT. ZRTMIN(2) ) THEN
- ILISTLENC = ILISTLENC + 1
- ILISTC(ILISTLENC) = JL
- END IF
- END DO
- DO JJ = 1, ILISTLENC
- JL = ILISTC(JJ)
- IF (ZRCS(JL) .GT. ZRTMIN(2) .AND. ZRCT(JL) .GT. XRTMIN(2)) THEN
+ IF ( OSEDIC ) THEN
+ ZWSED(:,:,:) = 0.
+ IF( JN==1 ) PRCS(:,:,:) = PRCS(:,:,:) * PTSTEP
+!$acc loop independent
+ DO JL=1,ISEDIMC
+ ZRSLOC = PRCS(IC1(JL),IC2(JL),IC3(JL))
+ ZRTLOC = PRCT(IC1(JL),IC2(JL),IC3(JL))
+ IF (ZRSLOC > ZRTMIN(2) .AND. ZRTLOC > XRTMIN(2)) THEN
+ ZRHODREFLOC = PRHODREF(IC1(JL),IC2(JL),IC3(JL))
+ ZFSEDC1D = ZFSEDC(IC1(JL),IC2(JL),IC3(JL))
+ ZWLBDC = ZLBC(IC1(JL),IC2(JL),IC3(JL))
+ ZCONC = ZCONC3D(IC1(JL),IC2(JL),IC3(JL))
+ ZRAY1D = ZRAY(IC1(JL),IC2(JL),IC3(JL))
+ ZZT = PTHT(IC1(JL),IC2(JL),IC3(JL))
+ ZPRES = PPABST(IC1(JL),IC2(JL),IC3(JL))
!Problems with PGI (18.10). OK if 2 lines are merged!
-! ZWLBDC(JL) = ZWLBDC(JL) * ZCONC(JL) / (ZRHODREFC(JL) * ZRCT(JL))
+! ZWLBDC = ZWLBDC * ZCONC / (ZRHODREFLOC * ZRTLOC)
! #ifndef MNH_BITREP
-! ZWLBDC(JL) = ZWLBDC(JL)**XLBEXC
+! ZWLBDC = ZWLBDC**XLBEXC
! #else
-! ZWLBDC(JL) = BR_POW(ZWLBDC(JL),XLBEXC)
+! ZWLBDC = BR_POW(ZWLBDC,XLBEXC)
! #endif
#ifndef MNH_BITREP
- ZWLBDC(JL) = (ZWLBDC(JL) * ZCONC(JL) / (ZRHODREFC(JL) * ZRCT(JL)))**XLBEXC
+ ZWLBDC = (ZWLBDC * ZCONC / (ZRHODREFLOC * ZRTLOC))**XLBEXC
#else
- ZWLBDC(JL) = BR_POW(ZWLBDC(JL) * ZCONC(JL) / (ZRHODREFC(JL) * ZRCT(JL)),XLBEXC)
+ ZWLBDC = BR_POW(ZWLBDC * ZCONC / (ZRHODREFLOC * ZRTLOC),XLBEXC)
#endif
- ZRAY1D(JL) = ZRAY1D(JL) / ZWLBDC(JL) !! ZRAY : mean diameter=M(1)/2
+ ZRAY1D = ZRAY1D / ZWLBDC !! ZRAY : mean diameter=M(1)/2
#ifndef MNH_BITREP
- ZZT(JL) = ZZT(JL) * (ZPRES(JL)/XP00)**(XRD/XCPD)
+ ZZT = ZZT * (ZPRES/XP00)**(XRD/XCPD)
#else
- ZZT(JL) = ZZT(JL) * BR_POW(ZPRES(JL)/XP00,XRD/XCPD)
+ ZZT = ZZT * BR_POW(ZPRES/XP00,XRD/XCPD)
#endif
- ZWLBDA(JL) = 6.6E-8*(101325./ZPRES(JL))*(ZZT(JL)/293.15)
- ZCC(JL) = XCC*(1.+1.26*ZWLBDA(JL)/ZRAY1D(JL)) !! XCC modified for cloud
+ ZWLBDA = 6.6E-8*(101325./ZPRES)*(ZZT/293.15)
+ ZCC = XCC*(1.+1.26*ZWLBDA/ZRAY1D) !! XCC modified for cloud
#ifndef MNH_BITREP
- ZWSED (IC1(JL),IC2(JL),IC3(JL))= ZRHODREFC(JL)**(-XCEXVT +1 ) * &
- ZWLBDC(JL)**(-XDC)*ZCC(JL)*ZFSEDC1D(JL) * ZRCS(JL)
+ ZWSED (IC1(JL),IC2(JL),IC3(JL)) = ZRHODREFLOC**(-XCEXVT +1 ) &
+ * ZWLBDC**(-XDC)*ZCC*ZFSEDC1D * ZRSLOC
#else
- ZWSED (IC1(JL),IC2(JL),IC3(JL))= BR_POW(ZRHODREFC(JL),-XCEXVT +1 ) * &
- BR_POW(ZWLBDC(JL),-XDC)*ZCC(JL)*ZFSEDC1D(JL) * ZRCS(JL)
+ ZWSED (IC1(JL),IC2(JL),IC3(JL)) = BR_POW(ZRHODREFLOC,-XCEXVT +1 ) &
+ * BR_POW(ZWLBDC,-XDC)*ZCC*ZFSEDC1D * ZRSLOC
#endif
- END IF
- END DO
-!$acc end kernels
- END IF
-!$acc kernels
- DO JK = KKTB , KKTE
- PRCS(:,:,JK) = PRCS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
- END DO
- IF ( GPRESENT_PFPR ) THEN
- DO JK = KKTB , KKTE
- PFPR(:,:,JK,2)=ZWSED(:,:,JK)
- ENDDO
- ENDIF
- PINPRC(:,:) = PINPRC(:,:) + ZWSED(:,:,KKB) / XRHOLW / KSPLITR
- IF( JN==KSPLITR ) THEN
- PRCS(:,:,:) = PRCS(:,:,:) * ZINVTSTEP
END IF
-!$acc end kernels
- END IF
+ END DO
+ DO JK = KKTB , KKTE
+ PRCS(:,:,JK) = PRCS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
+ END DO
+ IF ( GPRESENT_PFPR ) THEN
+ DO JK = KKTB , KKTE
+ PFPR(:,:,JK,2)=ZWSED(:,:,JK)
+ ENDDO
+ ENDIF
+ PINPRC(:,:) = PINPRC(:,:) + ZWSED(:,:,KKB) / XRHOLW / KSPLITR
+ IF( JN == KSPLITR ) THEN
+ PRCS(:,:,:) = PRCS(:,:,:) * ZINVTSTEP
+ END IF
+ END IF
!
!* 2.2 for rain
!
-!$acc kernels
IF( JN==1 ) PRRS(:,:,:) = PRRS(:,:,:) * PTSTEP
ZWSED(:,:,:) = 0.
-!$acc end kernels
- IF( ISEDIMR >= 1 ) THEN
- IF ( ISEDIMR .GT. ILENALLOCR ) THEN
- IF ( ILENALLOCR .GT. 0 ) THEN
- DEALLOCATE (ZRRS, ZRHODREFR, ILISTR)
- END IF
- ILENALLOCR = MAX (IOLDALLOCR, 2*ISEDIMR )
- IOLDALLOCR = ILENALLOCR
- ALLOCATE(ZRRS(ILENALLOCR), ZRHODREFR(ILENALLOCR), ILISTR(ILENALLOCR))
- END IF
-!
-!$acc kernels
- DO JL=1,ISEDIMR
- ZRRS(JL) = PRRS(IR1(JL),IR2(JL),IR3(JL))
- ZRHODREFR(JL) = PRHODREF(IR1(JL),IR2(JL),IR3(JL))
- END DO
-!
- ILISTLENR = 0
- DO JL=1,ISEDIMR
- IF( ZRRS(JL) .GT. ZRTMIN(3) ) THEN
- ILISTLENR = ILISTLENR + 1
- ILISTR(ILISTLENR) = JL
- END IF
- END DO
- DO JJ = 1, ILISTLENR
- JL = ILISTR(JJ)
+!$acc loop independent
+ DO JL=1,ISEDIMR
+ ZRSLOC = PRRS(IR1(JL),IR2(JL),IR3(JL))
+ IF( ZRSLOC > ZRTMIN(3) ) THEN
+ ZRHODREFLOC = PRHODREF(IR1(JL),IR2(JL),IR3(JL))
+
#ifndef MNH_BITREP
- ZWSED (IR1(JL),IR2(JL),IR3(JL))= XFSEDR * ZRRS(JL)**XEXSEDR * &
- ZRHODREFR(JL)**(XEXSEDR-XCEXVT)
+ ZWSED (IR1(JL),IR2(JL),IR3(JL))= XFSEDR * ZRSLOC**XEXSEDR * &
+ ZRHODREFLOC**(XEXSEDR-XCEXVT)
#else
- ZWSED (IR1(JL),IR2(JL),IR3(JL))= XFSEDR * BR_POW(ZRRS(JL),XEXSEDR) * &
- BR_POW(ZRHODREFR(JL),XEXSEDR-XCEXVT)
+ ZWSED (IR1(JL),IR2(JL),IR3(JL))= XFSEDR * BR_POW(ZRSLOC,XEXSEDR) * &
+ BR_POW(ZRHODREFLOC,XEXSEDR-XCEXVT)
#endif
- END DO
-!$acc end kernels
+ END IF
+ END DO
+ DO JK = KKTB , KKTE
+ PRRS(:,:,JK) = PRRS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
+ END DO
+ IF ( GPRESENT_PFPR ) THEN
+ DO JK = KKTB , KKTE
+ PFPR(:,:,JK,3)=ZWSED(:,:,JK)
+ ENDDO
+ ENDIF
+ PINPRR(:,:) = PINPRR(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
+ PINPRR3D(:,:,:) = PINPRR3D(:,:,:) + ZWSED(:,:,1:KKT)/XRHOLW/KSPLITR
+ IF( JN == KSPLITR ) THEN
+ PRRS(:,:,:) = PRRS(:,:,:) * ZINVTSTEP
END IF
-!$acc kernels
- DO JK = KKTB , KKTE
- PRRS(:,:,JK) = PRRS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
- END DO
- IF ( GPRESENT_PFPR ) THEN
- DO JK = KKTB , KKTE
- PFPR(:,:,JK,3)=ZWSED(:,:,JK)
- ENDDO
- ENDIF
- PINPRR(:,:) = PINPRR(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
- PINPRR3D(:,:,:) = PINPRR3D(:,:,:) + ZWSED(:,:,1:KKT)/XRHOLW/KSPLITR
- IF( JN==KSPLITR ) THEN
- PRRS(:,:,:) = PRRS(:,:,:) * ZINVTSTEP
- END IF
-!$acc end kernels
!
!* 2.3 for pristine ice
!
-!$acc kernels
IF( JN==1 ) PRIS(:,:,:) = PRIS(:,:,:) * PTSTEP
ZWSED(:,:,:) = 0.
-!$acc end kernels
- IF( ISEDIMI >= 1 ) THEN
- IF ( ISEDIMI .GT. ILENALLOCI ) THEN
- IF ( ILENALLOCI .GT. 0 ) THEN
- DEALLOCATE (ZRIS, ZRHODREFI, ILISTI)
- END IF
- ILENALLOCI = MAX (IOLDALLOCI, 2*ISEDIMI )
- IOLDALLOCI = ILENALLOCI
- ALLOCATE(ZRIS(ILENALLOCI), ZRHODREFI(ILENALLOCI), ILISTI(ILENALLOCI))
- END IF
-!
-!$acc kernels
- DO JL=1,ISEDIMI
- ZRIS(JL) = PRIS(II1(JL),II2(JL),II3(JL))
- ZRHODREFI(JL) = PRHODREF(II1(JL),II2(JL),II3(JL))
- END DO
-!
- ILISTLENI = 0
- DO JL=1,ISEDIMI
- IF( ZRIS(JL) .GT. MAX(ZRTMIN(4),1.0E-7 )) THEN ! limitation of the McF&H formula
- ILISTLENI = ILISTLENI + 1
- ILISTI(ILISTLENI) = JL
- END IF
- END DO
- DO JJ = 1, ILISTLENI
- JL = ILISTI(JJ)
+!$acc loop independent
+ DO JL=1,ISEDIMI
+ ZRSLOC = PRIS(II1(JL),II2(JL),II3(JL))
+ IF( ZRSLOC > MAX(ZRTMIN(4),1.0E-7 )) THEN ! limitation of the McF&H formula
+ ZRHODREFLOC = PRHODREF(II1(JL),II2(JL),II3(JL))
#ifndef MNH_BITREP
- ZWSED (II1(JL),II2(JL),II3(JL))= XFSEDI * ZRIS(JL) * &
- ZRHODREFI(JL)**(1.0-XCEXVT) * & ! McF&H
- MAX( 0.05E6,-0.15319E6-0.021454E6* &
- ALOG(ZRHODREFI(JL)*ZRIS(JL)) )**XEXCSEDI
+ ZWSED (II1(JL),II2(JL),II3(JL)) = XFSEDI * ZRSLOC * &
+ ZRHODREFLOC**(1.0-XCEXVT) * & ! McF&H
+ MAX( 0.05E6,-0.15319E6-0.021454E6* &
+ ALOG(ZRHODREFLOC*ZRSLOC) )**XEXCSEDI
#else
- ZWSED (II1(JL),II2(JL),II3(JL))= XFSEDI * ZRIS(JL) * &
- BR_POW(ZRHODREFI(JL),1.0-XCEXVT) * & ! McF&H
- BR_POW( MAX( 0.05E6,-0.15319E6-0.021454E6* &
- BR_LOG(ZRHODREFI(JL)*ZRIS(JL)) ), XEXCSEDI)
+ ZWSED (II1(JL),II2(JL),II3(JL)) = XFSEDI * ZRSLOC * &
+ BR_POW(ZRHODREFLOC,1.0-XCEXVT) * & ! McF&H
+ BR_POW( MAX( 0.05E6,-0.15319E6-0.021454E6* &
+ BR_LOG(ZRHODREFLOC*ZRSLOC) ), XEXCSEDI)
#endif
- END DO
-!$acc end kernels
+ END IF
+ END DO
+ DO JK = KKTB , KKTE
+ PRIS(:,:,JK) = PRIS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
+ END DO
+ IF ( GPRESENT_PFPR ) THEN
+ DO JK = KKTB , KKTE
+ PFPR(:,:,JK,4)=ZWSED(:,:,JK)
+ ENDDO
+ ENDIF
+ IF( JN == KSPLITR ) THEN
+ PRIS(:,:,:) = PRIS(:,:,:) * ZINVTSTEP
END IF
-!$acc kernels
- DO JK = KKTB , KKTE
- PRIS(:,:,JK) = PRIS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
- END DO
- IF ( GPRESENT_PFPR ) THEN
- DO JK = KKTB , KKTE
- PFPR(:,:,JK,4)=ZWSED(:,:,JK)
- ENDDO
- ENDIF
- IF( JN==KSPLITR ) THEN
- PRIS(:,:,:) = PRIS(:,:,:) * ZINVTSTEP
- END IF
-!$acc end kernels
!
!* 2.4 for aggregates/snow
!
-!$acc kernels
IF( JN==1 ) PRSS(:,:,:) = PRSS(:,:,:) * PTSTEP
ZWSED(:,:,:) = 0.
-!$acc end kernels
- IF( ISEDIMS >= 1 ) THEN
- IF ( ISEDIMS .GT. ILENALLOCS ) THEN
- IF ( ILENALLOCS .GT. 0 ) THEN
- DEALLOCATE (ZRSS, ZRHODREFS, ILISTS)
- END IF
- ILENALLOCS = MAX (IOLDALLOCS, 2*ISEDIMS )
- IOLDALLOCS = ILENALLOCS
- ALLOCATE(ZRSS(ILENALLOCS), ZRHODREFS(ILENALLOCS), ILISTS(ILENALLOCS))
- END IF
-!
-!$acc kernels
- DO JL=1,ISEDIMS
- ZRSS(JL) = PRSS(IS1(JL),IS2(JL),IS3(JL))
- ZRHODREFS(JL) = PRHODREF(IS1(JL),IS2(JL),IS3(JL))
- END DO
-!
- ILISTLENS = 0
- DO JL=1,ISEDIMS
- IF( ZRSS(JL) .GT. ZRTMIN(5) ) THEN
- ILISTLENS = ILISTLENS + 1
- ILISTS(ILISTLENS) = JL
- END IF
- END DO
- DO JJ = 1, ILISTLENS
- JL = ILISTS(JJ)
+!$acc loop independent
+ DO JL=1,ISEDIMS
+ ZRSLOC = PRSS(IS1(JL),IS2(JL),IS3(JL))
+ IF( ZRSLOC > ZRTMIN(5) ) THEN
+ ZRHODREFLOC = PRHODREF(IS1(JL),IS2(JL),IS3(JL))
#ifndef MNH_BITREP
- ZWSED (IS1(JL),IS2(JL),IS3(JL))= XFSEDS * ZRSS(JL)**XEXSEDS * &
- ZRHODREFS(JL)**(XEXSEDS-XCEXVT)
+ ZWSED (IS1(JL),IS2(JL),IS3(JL)) = XFSEDS * ZRSLOC**XEXSEDS * &
+ ZRHODREFLOC**(XEXSEDS-XCEXVT)
#else
- ZWSED (IS1(JL),IS2(JL),IS3(JL))= XFSEDS * BR_POW(ZRSS(JL),XEXSEDS) * &
- BR_POW(ZRHODREFS(JL),XEXSEDS-XCEXVT)
+ ZWSED (IS1(JL),IS2(JL),IS3(JL)) = XFSEDS * BR_POW(ZRSLOC,XEXSEDS) * &
+ BR_POW(ZRHODREFLOC,XEXSEDS-XCEXVT)
#endif
- END DO
-!$acc end kernels
+ END IF
+ END DO
+ DO JK = KKTB , KKTE
+ PRSS(:,:,JK) = PRSS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
+ END DO
+ IF ( GPRESENT_PFPR ) THEN
+ DO JK = KKTB , KKTE
+ PFPR(:,:,JK,5)=ZWSED(:,:,JK)
+ ENDDO
+ ENDIF
+ PINPRS(:,:) = PINPRS(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
+ IF( JN == KSPLITR ) THEN
+ PRSS(:,:,:) = PRSS(:,:,:) * ZINVTSTEP
END IF
-!$acc kernels
- DO JK = KKTB , KKTE
- PRSS(:,:,JK) = PRSS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
- END DO
- IF ( GPRESENT_PFPR ) THEN
- DO JK = KKTB , KKTE
- PFPR(:,:,JK,5)=ZWSED(:,:,JK)
- ENDDO
- ENDIF
- PINPRS(:,:) = PINPRS(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
- IF( JN==KSPLITR ) THEN
- PRSS(:,:,:) = PRSS(:,:,:) * ZINVTSTEP
- END IF
-!$acc end kernels
!
!* 2.5 for graupeln
!
-!$acc kernels
ZWSED(:,:,:) = 0.
IF( JN==1 ) PRGS(:,:,:) = PRGS(:,:,:) * PTSTEP
-!$acc end kernels
- IF( ISEDIMG >= 1 ) THEN
- IF ( ISEDIMG .GT. ILENALLOCG ) THEN
- IF ( ILENALLOCG .GT. 0 ) THEN
- DEALLOCATE (ZRGS, ZRHODREFG, ILISTG)
- END IF
- ILENALLOCG = MAX (IOLDALLOCG, 2*ISEDIMG )
- IOLDALLOCG = ILENALLOCG
- ALLOCATE(ZRGS(ILENALLOCG), ZRHODREFG(ILENALLOCG), ILISTG(ILENALLOCG))
- END IF
-!
-!$acc kernels
- DO JL=1,ISEDIMG
- ZRGS(JL) = PRGS(IG1(JL),IG2(JL),IG3(JL))
- ZRHODREFG(JL) = PRHODREF(IG1(JL),IG2(JL),IG3(JL))
- END DO
-!
- ILISTLENG = 0
- DO JL=1,ISEDIMG
- IF( ZRGS(JL) .GT. ZRTMIN(6) ) THEN
- ILISTLENG = ILISTLENG + 1
- ILISTG(ILISTLENG) = JL
- END IF
- END DO
- DO JJ = 1, ILISTLENG
- JL = ILISTG(JJ)
+!$acc loop independent
+ DO JL=1,ISEDIMG
+ ZRSLOC = PRGS(IG1(JL),IG2(JL),IG3(JL))
+ IF( ZRSLOC > ZRTMIN(6) ) THEN
+ ZRHODREFLOC = PRHODREF(IG1(JL),IG2(JL),IG3(JL))
#ifndef MNH_BITREP
- ZWSED (IG1(JL),IG2(JL),IG3(JL))= XFSEDG * ZRGS(JL)**XEXSEDG * &
- ZRHODREFG(JL)**(XEXSEDG-XCEXVT)
+ ZWSED (IG1(JL),IG2(JL),IG3(JL)) = XFSEDG * ZRSLOC**XEXSEDG * &
+ ZRHODREFLOC**(XEXSEDG-XCEXVT)
#else
- ZWSED (IG1(JL),IG2(JL),IG3(JL))= XFSEDG * BR_POW(ZRGS(JL),XEXSEDG) * &
- BR_POW(ZRHODREFG(JL),XEXSEDG-XCEXVT)
+ ZWSED (IG1(JL),IG2(JL),IG3(JL)) = XFSEDG * BR_POW(ZRSLOC,XEXSEDG) * &
+ BR_POW(ZRHODREFLOC,XEXSEDG-XCEXVT)
#endif
- END DO
-!$acc end kernels
-END IF
-!$acc kernels
- DO JK = KKTB , KKTE
- PRGS(:,:,JK) = PRGS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
- END DO
- IF ( GPRESENT_PFPR ) THEN
- DO JK = KKTB , KKTE
- PFPR(:,:,JK,6)=ZWSED(:,:,JK)
- ENDDO
- ENDIF
- PINPRG(:,:) = PINPRG(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
- IF( JN==KSPLITR ) THEN
- PRGS(:,:,:) = PRGS(:,:,:) * ZINVTSTEP
- END IF
-!$acc end kernels
-!
-!* 2.6 for hail
-!
- IF ( KRR == 7 ) THEN
-!$acc kernels
- IF( JN==1 ) PRHS(:,:,:) = PRHS(:,:,:) * PTSTEP
- ZWSED(:,:,:) = 0.
-!$acc end kernels
- IF( ISEDIMH >= 1 ) THEN
- IF ( ISEDIMH .GT. ILENALLOCH ) THEN
- IF ( ILENALLOCH .GT. 0 ) THEN
- DEALLOCATE (ZRHS, ZRHODREFH, ILISTH)
- END IF
- ILENALLOCH = MAX (IOLDALLOCH, 2*ISEDIMH )
- IOLDALLOCH = ILENALLOCH
- ALLOCATE(ZRHS(ILENALLOCH), ZRHODREFH(ILENALLOCH), ILISTH(ILENALLOCH))
END IF
+ END DO
+ DO JK = KKTB , KKTE
+ PRGS(:,:,JK) = PRGS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
+ END DO
+ IF ( GPRESENT_PFPR ) THEN
+ DO JK = KKTB , KKTE
+ PFPR(:,:,JK,6)=ZWSED(:,:,JK)
+ ENDDO
+ ENDIF
+ PINPRG(:,:) = PINPRG(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
+ IF( JN == KSPLITR ) THEN
+ PRGS(:,:,:) = PRGS(:,:,:) * ZINVTSTEP
+ END IF
!
-!$acc kernels
- DO JL=1,ISEDIMH
- ZRHS(JL) = PRHS(IH1(JL),IH2(JL),IH3(JL))
- ZRHODREFH(JL) = PRHODREF(IH1(JL),IH2(JL),IH3(JL))
- END DO
+!* 2.6 for hail
!
- ILISTLENH = 0
+ IF ( KRR == 7 ) THEN
+ IF( JN==1 ) PRHS(:,:,:) = PRHS(:,:,:) * PTSTEP
+ ZWSED(:,:,:) = 0.
+!$acc loop independent
DO JL=1,ISEDIMH
- IF( ZRHS(JL) .GT. ZRTMIN(7) ) THEN
- ILISTLENH = ILISTLENH + 1
- ILISTH(ILISTLENH) = JL
- END IF
- END DO
- DO JJ = 1, ILISTLENH
- JL = ILISTH(JJ)
+ ZRSLOC = PRHS(IH1(JL),IH2(JL),IH3(JL))
+ IF( ZRSLOC > ZRTMIN(7) ) THEN
+ ZRHODREFLOC = PRHODREF(IH1(JL),IH2(JL),IH3(JL))
#ifndef MNH_BITREP
- ZWSED (IH1(JL),IH2(JL),IH3(JL))= XFSEDH * ZRHS(JL)**XEXSEDH * &
- ZRHODREFH(JL)**(XEXSEDH-XCEXVT)
+ ZWSED (IH1(JL),IH2(JL),IH3(JL)) = XFSEDH * ZRSLOC**XEXSEDH * &
+ ZRHODREFLOC**(XEXSEDH-XCEXVT)
#else
- ZWSED (IH1(JL),IH2(JL),IH3(JL))= XFSEDH * BR_POW(ZRHS(JL),XEXSEDH) * &
- BR_POW(ZRHODREFH(JL),XEXSEDH-XCEXVT)
+ ZWSED (IH1(JL),IH2(JL),IH3(JL)) = XFSEDH * BR_POW(ZRSLOC,XEXSEDH) * &
+ BR_POW(ZRHODREFLOC,XEXSEDH-XCEXVT)
#endif
- END DO
-!$acc end kernels
- END IF
-!$acc kernels
- DO JK = KKTB , KKTE
- PRHS(:,:,JK) = PRHS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
- END DO
- IF ( GPRESENT_PFPR ) THEN
- DO JK = KKTB , KKTE
- PFPR(:,:,JK,7)=ZWSED(:,:,JK)
- ENDDO
- ENDIF
- PINPRH(:,:) = PINPRH(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
- IF( JN==KSPLITR ) THEN
- PRHS(:,:,:) = PRHS(:,:,:) * ZINVTSTEP
END IF
+ END DO
+ DO JK = KKTB , KKTE
+ PRHS(:,:,JK) = PRHS(:,:,JK) + ZW(:,:,JK)*(ZWSED(:,:,JK+KKL)-ZWSED(:,:,JK))
+ END DO
+ IF ( GPRESENT_PFPR ) THEN
+ DO JK = KKTB , KKTE
+ PFPR(:,:,JK,7)=ZWSED(:,:,JK)
+ ENDDO
+ ENDIF
+ PINPRH(:,:) = PINPRH(:,:) + ZWSED(:,:,KKB)/XRHOLW/KSPLITR
+ IF( JN == KSPLITR ) THEN
+ PRHS(:,:,:) = PRHS(:,:,:) * ZINVTSTEP
+ END IF
+ END IF
!$acc end kernels
- END IF
!
END DO
!
-IF (OSEDIC) THEN
- IF (ILENALLOCC .GT. 0) DEALLOCATE (ZRCS, ZRHODREFC, &
- ILISTC,ZWLBDC,ZCONC,ZRCT, ZZT,ZPRES,ZRAY1D,ZFSEDC1D, ZWLBDA,ZCC)
-END IF
-IF (ILENALLOCR .GT. 0 ) DEALLOCATE(ZRHODREFR,ZRRS,ILISTR)
-IF (ILENALLOCI .GT. 0 ) DEALLOCATE(ZRHODREFI,ZRIS,ILISTI)
-IF (ILENALLOCS .GT. 0 ) DEALLOCATE(ZRHODREFS,ZRSS,ILISTS)
-IF (ILENALLOCG .GT. 0 ) DEALLOCATE(ZRHODREFG,ZRGS,ILISTG)
-IF (KRR == 7 .AND. (ILENALLOCH .GT. 0 )) DEALLOCATE(ZRHODREFH,ZRHS,ILISTH)
-!
!* 2.3 budget storage
!
IF (LBUDGET_RC .AND. OSEDIC) THEN
@@ -821,9 +653,9 @@ IF (ODEPOSC) THEN
GDEP(:,:) = .FALSE.
GDEP(KIB:KIE,KJB:KJE) = PRCS(KIB:KIE,KJB:KJE,KKB) >0
WHERE (GDEP)
- PRCS(:,:,KKB) = PRCS(:,:,KKB) - XVDEPOSC * PRCT(:,:,KKB) / PDZZ(:,:,KKB)
- PINPRC(:,:) = PINPRC(:,:) + XVDEPOSC * PRCT(:,:,KKB) * PRHODREF(:,:,KKB) /XRHOLW
- PINDEP(:,:) = XVDEPOSC * PRCT(:,:,KKB) * PRHODREF(:,:,KKB) /XRHOLW
+ PRCS(:,:,KKB) = PRCS(:,:,KKB) - XVDEPOSC * PRCT(:,:,KKB) / PDZZ(:,:,KKB)
+ PINPRC(:,:) = PINPRC(:,:) + XVDEPOSC * PRCT(:,:,KKB) * PRHODREF(:,:,KKB) /XRHOLW
+ PINDEP(:,:) = XVDEPOSC * PRCT(:,:,KKB) * PRHODREF(:,:,KKB) /XRHOLW
END WHERE
END IF
!$acc end kernels
@@ -858,6 +690,6 @@ IF (MPPDB_INITIALIZED) THEN
END IF
END IF
- END SUBROUTINE RAIN_ICE_SEDIMENTATION_SPLIT
+END SUBROUTINE RAIN_ICE_SEDIMENTATION_SPLIT
END MODULE MODE_RAIN_ICE_SEDIMENTATION_SPLIT