75 #define F2H(k,p,q) (CDZ(k+p-1)*GSQRT(k+p-1,i,j)/(CDZ(k)*GSQRT(k,i,j)+CDZ(k+1)*GSQRT(k+1,i,j))) 
   77 #define F2H(k,p,q) 0.5_RP 
   84   real(RP), 
parameter :: F2  =  0.5_rp          
 
   87   real(RP), 
parameter :: F31  = -1.0_rp/12.0_rp
 
   88   real(RP), 
parameter :: F32  =  7.0_rp/12.0_rp
 
   89   real(RP), 
parameter :: F33  =  3.0_rp/12.0_rp
 
   92   real(RP), 
parameter :: F51  =  1.0_rp/60.0_rp
 
   93   real(RP), 
parameter :: F52  = -8.0_rp/60.0_rp
 
   94   real(RP), 
parameter :: F53  = 37.0_rp/60.0_rp
 
   95   real(RP), 
parameter :: F54  = -5.0_rp/60.0_rp
 
   96   real(RP), 
parameter :: F55  = 10.0_rp/60.0_rp
 
  111     real(rp), 
intent(out) :: valw (
ka)
 
  112     real(rp), 
intent(in)  :: mflx (
ka)
 
  113     real(rp), 
intent(in)  :: val  (
ka)
 
  114     real(rp), 
intent(in)  :: gsqrt(
ka)
 
  115     real(rp), 
intent(in)  :: cdz  (
ka)
 
  122        call check( __line__, mflx(
k) )
 
  124        call check( __line__, val(
k) )
 
  125        call check( __line__, val(
k+1) )
 
  127        call check( __line__, val(
k-1) )
 
  128        call check( __line__, val(
k+2) )
 
  130        call check( __line__, val(
k-2) )
 
  131        call check( __line__, val(
k+3) )
 
  134        valw(
k)       = ( f51 * ( val(
k+3)+val(
k-2) ) &
 
  135                        + f52 * ( val(
k+2)+val(
k-1) ) &
 
  136                        + f53 * ( val(
k+1)+val(
k) ) ) &
 
  137                      - ( f51 * ( val(
k+3)-val(
k-2) ) &
 
  138                        + f54 * ( val(
k+2)-val(
k-1) ) &
 
  139                        + f55 * ( val(
k+1)-val(
k) ) ) * sign(1.0_rp,mflx(
k))
 
  147        call check( __line__, mflx(
ks) )
 
  148        call check( __line__, val(
ks  ) )
 
  149        call check( __line__, val(
ks+1) )
 
  150        call check( __line__, mflx(
ke-1) )
 
  151        call check( __line__, val(
ke  ) )
 
  152        call check( __line__, val(
ke-1) )
 
  154        call check( __line__, mflx(
ks+1) )
 
  155        call check( __line__, val(
ks+2  ) )
 
  156        call check( __line__, val(
ks+3) )
 
  157        call check( __line__, mflx(
ke-2) )
 
  158        call check( __line__, val(
ke-2  ) )
 
  159        call check( __line__, val(
ke-3) )
 
  163        valw(
ks) = f2 * ( val(
ks+1)+val(
ks) ) &
 
  164                      * ( 0.5_rp + sign(0.5_rp,mflx(
ks)) ) &
 
  165                 + ( 2.0_rp * val(
ks) + 5.0_rp * val(
ks+1) - val(
ks+2) ) / 6.0_rp &
 
  166                      * ( 0.5_rp - sign(0.5_rp,mflx(
ks)) )
 
  167        valw(
ke-1) = ( 2.0_rp * val(
ke) + 5.0_rp * val(
ke-1) - val(
ke-2) ) / 6.0_rp &
 
  168                      * ( 0.5_rp + sign(0.5_rp,mflx(
ke-1)) ) &
 
  169                 + f2 * ( val(
ke)+val(
ke-1) ) &
 
  170                      * ( 0.5_rp - sign(0.5_rp,mflx(
ke-1)) )
 
  172        valw(
ks+1) = ( 2.0_rp * val(
ks+2) + 5.0_rp * val(
ks+1) - val(
ks) ) / 6.0_rp &
 
  173                      * ( 0.5_rp + sign(0.5_rp,mflx(
ks+1)) ) &
 
  174                 + ( -  3.0_rp * val(
ks)  &
 
  175                          + 27.0_rp * val(
ks+1)  &
 
  176                          + 47.0_rp * val(
ks+2)  &
 
  177                          - 13.0_rp * val(
ks+3) &
 
  178                          + 2.0_rp * val(
ks+4) ) / 60.0_rp &
 
  179                      * ( 0.5_rp - sign(0.5_rp,mflx(
ks+1)) )
 
  180        valw(
ke-2) = ( -  3.0_rp * val(
ke)  &
 
  181                          + 27.0_rp * val(
ke-1)  &
 
  182                          + 47.0_rp * val(
ke-2)  &
 
  183                          - 13.0_rp * val(
ke-3) &
 
  184                          + 2.0_rp * val(
ke-4) ) / 60.0_rp &
 
  185                      * ( 0.5_rp + sign(0.5_rp,mflx(
ke-2)) ) &
 
  186                 + ( 2.0_rp * val(
ke-2) + 5.0_rp * val(
ke-1) - val(
ke) ) / 6.0_rp &
 
  187                      * ( 0.5_rp - sign(0.5_rp,mflx(
ke-2)) )
 
  205     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  206     real(rp), 
intent(in)  :: mflx    (
ka,
ia,
ja)
 
  207     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  208     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  209     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  210     real(rp), 
intent(in)  :: cdz     (
ka)
 
  211     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  225        call check( __line__, mflx(
k,i,j) )
 
  227        call check( __line__, val(
k,i,j) )
 
  228        call check( __line__, val(
k+1,i,j) )
 
  230        call check( __line__, val(
k-1,i,j) )
 
  231        call check( __line__, val(
k+2,i,j) )
 
  233        call check( __line__, val(
k-2,i,j) )
 
  234        call check( __line__, val(
k+3,i,j) )
 
  239                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
  240                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
  241                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
  242                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
  243                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
  244                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
  245                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
  251     k = iundef; i = iundef; j = iundef
 
  259        call check( __line__, mflx(
ks,i,j) )
 
  260        call check( __line__, val(
ks  ,i,j) )
 
  261        call check( __line__, val(
ks+1,i,j) )
 
  262        call check( __line__, mflx(
ke-1,i,j) )
 
  263        call check( __line__, val(
ke  ,i,j) )
 
  264        call check( __line__, val(
ke-1,i,j) )
 
  266        call check( __line__, mflx(
ks+1,i,j) )
 
  267        call check( __line__, val(
ks+2  ,i,j) )
 
  268        call check( __line__, val(
ks+3,i,j) )
 
  269        call check( __line__, mflx(
ke-2,i,j) )
 
  270        call check( __line__, val(
ke-2  ,i,j) )
 
  271        call check( __line__, val(
ke-3,i,j) )
 
  274        flux(
ks-1,i,j) = 0.0_rp
 
  278                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
  279                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  280                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
  281                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  282                    + gsqrt(
ks,i,j) * num_diff(
ks,i,j)
 
  284        flux(
ke-1,i,j) = vel &
 
  285                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
  286                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  287                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
  288                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  289                    + gsqrt(
ke-1,i,j) * num_diff(
ke-1,i,j)
 
  292        flux(
ks+1,i,j) = vel &
 
  293                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
  294                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  295                 + ( -  3.0_rp * val(
ks,i,j)  &
 
  296                          + 27.0_rp * val(
ks+1,i,j)  &
 
  297                          + 47.0_rp * val(
ks+2,i,j)  &
 
  298                          - 13.0_rp * val(
ks+3,i,j) &
 
  299                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
  300                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  301                    + gsqrt(
ks+1,i,j) * num_diff(
ks+1,i,j)
 
  303        flux(
ke-2,i,j) = vel &
 
  304                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
  305                          + 27.0_rp * val(
ke-1,i,j)  &
 
  306                          + 47.0_rp * val(
ke-2,i,j)  &
 
  307                          - 13.0_rp * val(
ke-3,i,j) &
 
  308                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
  309                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  310                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
  311                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  312                    + gsqrt(
ke-2,i,j) * num_diff(
ke-2,i,j)
 
  314        flux(
ke  ,i,j) = 0.0_rp
 
  321     k = iundef; i = iundef; j = iundef
 
  337     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  338     real(rp), 
intent(in)  :: mflx    (
ka,
ia,
ja)
 
  339     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  340     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  341     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  342     real(rp), 
intent(in)  :: cdz(
ka)
 
  343     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  356        call check( __line__, mflx(
k,i,j) )
 
  358        call check( __line__, val(
k,i,j) )
 
  359        call check( __line__, val(
k,i+1,j) )
 
  361        call check( __line__, val(
k,i-1,j) )
 
  362        call check( __line__, val(
k,i+2,j) )
 
  364        call check( __line__, val(
k,i-2,j) )
 
  365        call check( __line__, val(
k,i+3,j) )
 
  370                    * ( ( f51 * ( val(
k,i+3,j)+val(
k,i-2,j) ) &
 
  371                        + f52 * ( val(
k,i+2,j)+val(
k,i-1,j) ) &
 
  372                        + f53 * ( val(
k,i+1,j)+val(
k,i,j) ) ) &
 
  373                      - ( f51 * ( val(
k,i+3,j)-val(
k,i-2,j) ) &
 
  374                        + f54 * ( val(
k,i+2,j)-val(
k,i-1,j) ) &
 
  375                        + f55 * ( val(
k,i+1,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
  376                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
  381     k = iundef; i = iundef; j = iundef
 
  397     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  398     real(rp), 
intent(in)  :: mflx    (
ka,
ia,
ja)
 
  399     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  400     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  401     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  402     real(rp), 
intent(in)  :: cdz(
ka)
 
  403     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  416        call check( __line__, mflx(
k,i,j) )
 
  418        call check( __line__, val(
k,i,j) )
 
  419        call check( __line__, val(
k,i,j+1) )
 
  421        call check( __line__, val(
k,i,j-1) )
 
  422        call check( __line__, val(
k,i,j+2) )
 
  424        call check( __line__, val(
k,i,j-2) )
 
  425        call check( __line__, val(
k,i,j+3) )
 
  430                    * ( ( f51 * ( val(
k,i,j+3)+val(
k,i,j-2) ) &
 
  431                        + f52 * ( val(
k,i,j+2)+val(
k,i,j-1) ) &
 
  432                        + f53 * ( val(
k,i,j+1)+val(
k,i,j) ) ) &
 
  433                      - ( f51 * ( val(
k,i,j+3)-val(
k,i,j-2) ) &
 
  434                        + f54 * ( val(
k,i,j+2)-val(
k,i,j-1) ) &
 
  435                        + f55 * ( val(
k,i,j+1)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
  436                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
  441     k = iundef; i = iundef; j = iundef
 
  460     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  461     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
  462     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  463     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
  464     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  465     real(rp), 
intent(in)  :: j33g
 
  466     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  467     real(rp), 
intent(in)  :: cdz     (
ka)
 
  468     real(rp), 
intent(in)  :: fdz     (
ka-1)
 
  469     real(rp), 
intent(in)  :: dtrk
 
  470     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  486        call check( __line__, mom(
k-1,i,j) )
 
  487        call check( __line__, mom(
k  ,i,j) )
 
  489        call check( __line__, val(
k-1,i,j) )
 
  490        call check( __line__, val(
k,i,j) )
 
  492        call check( __line__, val(
k-2,i,j) )
 
  493        call check( __line__, val(
k+1,i,j) )
 
  495        call check( __line__, val(
k-3,i,j) )
 
  496        call check( __line__, val(
k+2,i,j) )
 
  499        vel = ( 0.5_rp * ( mom(
k-1,i,j) &
 
  502        flux(
k-1,i,j) = j33g * vel &
 
  503                    * ( ( f51 * ( val(
k+2,i,j)+val(
k-3,i,j) ) &
 
  504                        + f52 * ( val(
k+1,i,j)+val(
k-2,i,j) ) &
 
  505                        + f53 * ( val(
k,i,j)+val(
k-1,i,j) ) ) &
 
  506                      - ( f51 * ( val(
k+2,i,j)-val(
k-3,i,j) ) &
 
  507                        + f54 * ( val(
k+1,i,j)-val(
k-2,i,j) ) &
 
  508                        + f55 * ( val(
k,i,j)-val(
k-1,i,j) ) ) * sign(1.0_rp,vel) ) &
 
  509                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
  515     k = iundef; i = iundef; j = iundef
 
  523        call check( __line__, val(
ks,i,j) )
 
  524        call check( __line__, val(
ks+1,i,j) )
 
  525        call check( __line__, val(
ks+2,i,j) )
 
  526        call check( __line__, val(
ks+3,i,j) )
 
  527        call check( __line__, val(
ks+4,i,j) )
 
  530        call check( __line__, val(
ke-4,i,j) )
 
  531        call check( __line__, val(
ke-3,i,j) )
 
  532        call check( __line__, val(
ke-2,i,j) )
 
  533        call check( __line__, val(
ke-1,i,j) )
 
  539        flux(
ks-1,i,j) = 0.0_rp 
 
  541        vel = ( 0.5_rp * ( mom(
ks,i,j) &
 
  542                         + mom(
ks+1,i,j) ) ) &
 
  544        flux(
ks,i,j) = j33g * vel &
 
  545                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
  546                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  547                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
  548                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  549                    + gsqrt(
ks+1,i,j) * num_diff(
ks+1,i,j) 
 
  551        vel = ( 0.5_rp * ( mom(
ks+1,i,j) &
 
  552                         + mom(
ks+2,i,j) ) ) &
 
  554        flux(
ks+1,i,j) = j33g * vel &
 
  555                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
  556                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  557                 + ( -  3.0_rp * val(
ks,i,j)  &
 
  558                          + 27.0_rp * val(
ks+1,i,j)  &
 
  559                          + 47.0_rp * val(
ks+2,i,j)  &
 
  560                          - 13.0_rp * val(
ks+3,i,j) &
 
  561                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
  562                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  563                    + gsqrt(
ks+2,i,j) * num_diff(
ks+2,i,j) 
 
  567        vel = ( 0.5_rp * ( mom(
ke-2,i,j) &
 
  568                         + mom(
ke-1,i,j) ) ) &
 
  570        flux(
ke-2,i,j) = j33g * vel &
 
  571                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
  572                          + 27.0_rp * val(
ke-1,i,j)  &
 
  573                          + 47.0_rp * val(
ke-2,i,j)  &
 
  574                          - 13.0_rp * val(
ke-3,i,j) &
 
  575                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
  576                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  577                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
  578                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
  579                    + gsqrt(
ke-1,i,j) * num_diff(
ke-1,i,j) 
 
  581        flux(
ke-1,i,j) = 0.0_rp 
 
  582        flux(
ke  ,i,j) = 0.0_rp 
 
  603     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  604     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
  605     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  606     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
  607     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  608     real(rp), 
intent(in)  :: j13g    (
ka,
ia,
ja)
 
  609     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
  610     real(rp), 
intent(in)  :: cdz     (
ka)
 
  611     logical,  
intent(in)  :: twod
 
  612     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  625        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i-1,j) ) ) &
 
  627        vel = vel * j13g(
k,i,j)
 
  628        flux(
k-1,i,j) = vel / mapf(i,j,+2) &
 
  629                    * ( ( f51 * ( val(
k+2,i,j)+val(
k-3,i,j) ) &
 
  630                        + f52 * ( val(
k+1,i,j)+val(
k-2,i,j) ) &
 
  631                        + f53 * ( val(
k,i,j)+val(
k-1,i,j) ) ) &
 
  632                      - ( f51 * ( val(
k+2,i,j)-val(
k-3,i,j) ) &
 
  633                        + f54 * ( val(
k+1,i,j)-val(
k-2,i,j) ) &
 
  634                        + f55 * ( val(
k,i,j)-val(
k-1,i,j) ) ) * sign(1.0_rp,vel) )
 
  646        flux(
ks-1,i,j) = 0.0_rp 
 
  649        vel = ( ( 0.5_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i-1,j) ) ) / dens(
ks+1,i,j) &
 
  650              + ( 0.5_rp * ( mom(
ks,i,j)+mom(
ks,i-1,j) ) ) / dens(
ks  ,i,j) ) * 0.5_rp
 
  653        vel = vel * j13g(
ks+1,i,j)
 
  654        flux(
ks,i,j) =  vel / mapf(i,j,+2) &
 
  655                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
  656                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  657                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
  658                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) 
 
  661        vel = ( 0.5_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i-1,j) ) ) &
 
  663        vel = vel * j13g(
ke-1,i,j)
 
  664        flux(
ke-2,i,j) = vel / mapf(i,j,+2) &
 
  665                    * ( ( 2.0_rp * val(
ke-1,i,j) + 5.0_rp * val(
ke-2,i,j) - val(
ke-3,i,j) ) / 6.0_rp &
 
  666                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  667                 + f2 * ( val(
ke-1,i,j)+val(
ke-2,i,j) ) &
 
  668                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) 
 
  670        flux(
ke-1,i,j) = 0.0_rp
 
  690     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  691     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
  692     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  693     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
  694     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  695     real(rp), 
intent(in)  :: j23g    (
ka,
ia,
ja)
 
  696     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
  697     real(rp), 
intent(in)  :: cdz     (
ka)
 
  698     logical,  
intent(in)  :: twod
 
  699     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  712        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i,j-1) ) ) &
 
  714        vel = vel * j23g(
k,i,j)
 
  715        flux(
k-1,i,j) = vel / mapf(i,j,+1) &
 
  716                    * ( ( f51 * ( val(
k+2,i,j)+val(
k-3,i,j) ) &
 
  717                        + f52 * ( val(
k+1,i,j)+val(
k-2,i,j) ) &
 
  718                        + f53 * ( val(
k,i,j)+val(
k-1,i,j) ) ) &
 
  719                      - ( f51 * ( val(
k+2,i,j)-val(
k-3,i,j) ) &
 
  720                        + f54 * ( val(
k+1,i,j)-val(
k-2,i,j) ) &
 
  721                        + f55 * ( val(
k,i,j)-val(
k-1,i,j) ) ) * sign(1.0_rp,vel) )
 
  733        flux(
ks-1,i,j) = 0.0_rp 
 
  736        vel = ( ( 0.5_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i,j-1) ) ) / dens(
ks+1,i,j) &
 
  737              + ( 0.5_rp * ( mom(
ks,i,j)+mom(
ks,i,j-1) ) ) / dens(
ks  ,i,j) ) * 0.5_rp
 
  740        vel = vel * j23g(
ks+1,i,j)
 
  741        flux(
ks,i,j) =  vel / mapf(i,j,+1) &
 
  742                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
  743                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  744                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
  745                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) 
 
  748        vel = ( 0.5_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i,j-1) ) ) &
 
  750        vel = vel * j23g(
ke-1,i,j)
 
  751        flux(
ke-2,i,j) = vel / mapf(i,j,+1) &
 
  752                    * ( ( 2.0_rp * val(
ke-1,i,j) + 5.0_rp * val(
ke-2,i,j) - val(
ke-3,i,j) ) / 6.0_rp &
 
  753                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
  754                 + f2 * ( val(
ke-1,i,j)+val(
ke-2,i,j) ) &
 
  755                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) 
 
  757        flux(
ke-1,i,j) = 0.0_rp
 
  779     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  780     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
  781     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  782     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
  783     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  784     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
  785     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  786     real(rp), 
intent(in)  :: cdz     (
ka)
 
  787     logical,  
intent(in)  :: twod
 
  788     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  803        call check( __line__, mom(
k  ,i,j) )
 
  804        call check( __line__, mom(
k+1,i,j) )
 
  806        call check( __line__, val(
k,i,j) )
 
  807        call check( __line__, val(
k,i+1,j) )
 
  809        call check( __line__, val(
k,i-1,j) )
 
  810        call check( __line__, val(
k,i+2,j) )
 
  812        call check( __line__, val(
k,i-2,j) )
 
  813        call check( __line__, val(
k,i+3,j) )
 
  821              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i+1,j) ) &
 
  823              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i+1,j) ) )
 
  824        flux(
k,i,j) = gsqrt(
k,i,j) / mapf(i,j,+2) * vel &
 
  825                    * ( ( f51 * ( val(
k,i+3,j)+val(
k,i-2,j) ) &
 
  826                        + f52 * ( val(
k,i+2,j)+val(
k,i-1,j) ) &
 
  827                        + f53 * ( val(
k,i+1,j)+val(
k,i,j) ) ) &
 
  828                      - ( f51 * ( val(
k,i+3,j)-val(
k,i-2,j) ) &
 
  829                        + f54 * ( val(
k,i+2,j)-val(
k,i-1,j) ) &
 
  830                        + f55 * ( val(
k,i+1,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
  831                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
  837     k = iundef; i = iundef; j = iundef
 
  843        flux(
ke,i,j) = 0.0_rp
 
  850     k = iundef; i = iundef; j = iundef
 
  867     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  868     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
  869     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  870     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
  871     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  872     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
  873     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  874     real(rp), 
intent(in)  :: cdz     (
ka)
 
  875     logical,  
intent(in)  :: twod
 
  876     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  891        call check( __line__, mom(
k  ,i,j) )
 
  892        call check( __line__, mom(
k+1,i,j) )
 
  894        call check( __line__, val(
k,i,j) )
 
  895        call check( __line__, val(
k,i,j+1) )
 
  897        call check( __line__, val(
k,i,j-1) )
 
  898        call check( __line__, val(
k,i,j+2) )
 
  900        call check( __line__, val(
k,i,j-2) )
 
  901        call check( __line__, val(
k,i,j+3) )
 
  909              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i,j+1) ) &
 
  911              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i,j+1) ) )
 
  912        flux(
k,i,j) = gsqrt(
k,i,j) / mapf(i,j,+1) * vel &
 
  913                    * ( ( f51 * ( val(
k,i,j+3)+val(
k,i,j-2) ) &
 
  914                        + f52 * ( val(
k,i,j+2)+val(
k,i,j-1) ) &
 
  915                        + f53 * ( val(
k,i,j+1)+val(
k,i,j) ) ) &
 
  916                      - ( f51 * ( val(
k,i,j+3)-val(
k,i,j-2) ) &
 
  917                        + f54 * ( val(
k,i,j+2)-val(
k,i,j-1) ) &
 
  918                        + f55 * ( val(
k,i,j+1)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
  919                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
  925     k = iundef; i = iundef; j = iundef
 
  931        flux(
ke,i,j) = 0.0_rp
 
  938     k = iundef; i = iundef; j = iundef
 
  956     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
  957     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
  958     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
  959     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
  960     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
  961     real(rp), 
intent(in)  :: j33g
 
  962     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
  963     real(rp), 
intent(in)  :: cdz     (
ka)
 
  964     logical,  
intent(in)  :: twod
 
  965     integer,  
intent(in)  :: iis, iie, jjs, jje
 
  982        call check( __line__, mom(
k,i,j) )
 
  984        call check( __line__, val(
k,i,j) )
 
  985        call check( __line__, val(
k+1,i,j) )
 
  987        call check( __line__, val(
k-1,i,j) )
 
  988        call check( __line__, val(
k+2,i,j) )
 
  990        call check( __line__, val(
k-2,i,j) )
 
  991        call check( __line__, val(
k+3,i,j) )
 
  995        vel = ( mom(
k,i,j) ) &
 
 1000        flux(
k,i,j) = j33g * vel &
 
 1001                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 1002                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 1003                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 1004                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 1005                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 1006                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
 1007                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 1012     k = iundef; i = iundef; j = iundef
 
 1019        call check( __line__, mom(
ks,i  ,j) )
 
 1020        call check( __line__, val(
ks+1,i,j) )
 
 1021        call check( __line__, val(
ks,i,j) )
 
 1023        call check( __line__, mom(
ks+1,i  ,j) )
 
 1024        call check( __line__, val(
ks+3,i,j) )
 
 1025        call check( __line__, val(
ks+2,i,j) )
 
 1032        flux(
ks-1,i,j) = 0.0_rp
 
 1034        vel = ( mom(
ks,i,j) ) &
 
 1039        flux(
ks,i,j) = j33g * vel &
 
 1040                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 1041                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1042                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 1043                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1044                    + gsqrt(
ks,i,j) * num_diff(
ks,i,j)
 
 1045        vel = ( mom(
ke-1,i,j) ) &
 
 1050        flux(
ke-1,i,j) = j33g * vel &
 
 1051                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 1052                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1053                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 1054                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1055                    + gsqrt(
ke-1,i,j) * num_diff(
ke-1,i,j)
 
 1057        vel = ( mom(
ks+1,i,j) ) &
 
 1062        flux(
ks+1,i,j) = j33g * vel &
 
 1063                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 1064                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1065                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 1066                          + 27.0_rp * val(
ks+1,i,j)  &
 
 1067                          + 47.0_rp * val(
ks+2,i,j)  &
 
 1068                          - 13.0_rp * val(
ks+3,i,j) &
 
 1069                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 1070                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1071                    + gsqrt(
ks+1,i,j) * num_diff(
ks+1,i,j)
 
 1072        vel = ( mom(
ke-2,i,j) ) &
 
 1077        flux(
ke-2,i,j) = j33g * vel &
 
 1078                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 1079                          + 27.0_rp * val(
ke-1,i,j)  &
 
 1080                          + 47.0_rp * val(
ke-2,i,j)  &
 
 1081                          - 13.0_rp * val(
ke-3,i,j) &
 
 1082                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 1083                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1084                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 1085                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1086                    + gsqrt(
ke-2,i,j) * num_diff(
ke-2,i,j)
 
 1088        flux(
ke,i,j) = 0.0_rp
 
 1100        call check( __line__, mom(
k,i,j) )
 
 1101        call check( __line__, mom(
k,i+1,j) )
 
 1103        call check( __line__, val(
k,i,j) )
 
 1104        call check( __line__, val(
k+1,i,j) )
 
 1106        call check( __line__, val(
k-1,i,j) )
 
 1107        call check( __line__, val(
k+2,i,j) )
 
 1109        call check( __line__, val(
k-2,i,j) )
 
 1110        call check( __line__, val(
k+3,i,j) )
 
 1113        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i+1,j) ) ) &
 
 1115              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i+1,j) ) &
 
 1117              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i+1,j) ) )
 
 1118        flux(
k,i,j) = j33g * vel &
 
 1119                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 1120                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 1121                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 1122                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 1123                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 1124                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
 1125                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 1131     k = iundef; i = iundef; j = iundef
 
 1139        call check( __line__, mom(
ks,i  ,j) )
 
 1140        call check( __line__, mom(
ks,i+1,j) )
 
 1141        call check( __line__, val(
ks+1,i,j) )
 
 1142        call check( __line__, val(
ks,i,j) )
 
 1144        call check( __line__, mom(
ks+1,i  ,j) )
 
 1145        call check( __line__, mom(
ks+1,i+1,j) )
 
 1146        call check( __line__, val(
ks+3,i,j) )
 
 1147        call check( __line__, val(
ks+2,i,j) )
 
 1153        flux(
ks-1,i,j) = 0.0_rp
 
 1155        vel = ( 0.5_rp * ( mom(
ks,i,j)+mom(
ks,i+1,j) ) ) &
 
 1157              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i+1,j) ) &
 
 1159              * 0.5_rp * ( dens(
ks,i,j)+dens(
ks,i+1,j) ) )
 
 1160        flux(
ks,i,j) = j33g * vel &
 
 1161                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 1162                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1163                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 1164                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1165                    + gsqrt(
ks,i,j) * num_diff(
ks,i,j)
 
 1166        vel = ( 0.5_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i+1,j) ) ) &
 
 1168              * 0.5_rp * ( dens(
ke,i,j)+dens(
ke,i+1,j) ) &
 
 1170              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i+1,j) ) )
 
 1171        flux(
ke-1,i,j) = j33g * vel &
 
 1172                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 1173                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1174                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 1175                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1176                    + gsqrt(
ke-1,i,j) * num_diff(
ke-1,i,j)
 
 1178        vel = ( 0.5_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i+1,j) ) ) &
 
 1180              * 0.5_rp * ( dens(
ks+2,i,j)+dens(
ks+2,i+1,j) ) &
 
 1182              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i+1,j) ) )
 
 1183        flux(
ks+1,i,j) = j33g * vel &
 
 1184                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 1185                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1186                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 1187                          + 27.0_rp * val(
ks+1,i,j)  &
 
 1188                          + 47.0_rp * val(
ks+2,i,j)  &
 
 1189                          - 13.0_rp * val(
ks+3,i,j) &
 
 1190                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 1191                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1192                    + gsqrt(
ks+1,i,j) * num_diff(
ks+1,i,j)
 
 1193        vel = ( 0.5_rp * ( mom(
ke-2,i,j)+mom(
ke-2,i+1,j) ) ) &
 
 1195              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i+1,j) ) &
 
 1197              * 0.5_rp * ( dens(
ke-2,i,j)+dens(
ke-2,i+1,j) ) )
 
 1198        flux(
ke-2,i,j) = j33g * vel &
 
 1199                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 1200                          + 27.0_rp * val(
ke-1,i,j)  &
 
 1201                          + 47.0_rp * val(
ke-2,i,j)  &
 
 1202                          - 13.0_rp * val(
ke-3,i,j) &
 
 1203                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 1204                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1205                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 1206                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1207                    + gsqrt(
ke-2,i,j) * num_diff(
ke-2,i,j)
 
 1209        flux(
ke,i,j) = 0.0_rp
 
 1219     k = iundef; i = iundef; j = iundef
 
 1230        GSQRT, J13G, MAPF, &
 
 1232        IIS, IIE, JJS, JJE )
 
 1235     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 1236     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 1237     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 1238     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 1239     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 1240     real(rp), 
intent(in)  :: j13g    (
ka,
ia,
ja)
 
 1241     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 1242     real(rp), 
intent(in)  :: cdz     (
ka)
 
 1243     logical,  
intent(in)  :: twod
 
 1244     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 1265              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i+1,j) ) &
 
 1267              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i+1,j) ) )
 
 1268        vel = vel * j13g(
k,i,j)
 
 1269        flux(
k,i,j) = vel / mapf(i,j,+2) &
 
 1270                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 1271                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 1272                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 1273                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 1274                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 1275                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) )
 
 1287        flux(
ks-1,i,j) = 0.0_rp
 
 1294              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i+1,j) ) &
 
 1296              * 0.5_rp * ( dens(
ks,i,j)+dens(
ks,i+1,j) ) )
 
 1297        vel = vel * j13g(
ks,i,j)
 
 1298        flux(
ks,i,j) = vel / mapf(i,j,+2) &
 
 1299                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 1300                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1301                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 1302                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1309              * 0.5_rp * ( dens(
ke,i,j)+dens(
ke,i+1,j) ) &
 
 1311              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i+1,j) ) )
 
 1312        vel = vel * j13g(
ke-1,i,j)
 
 1313        flux(
ke-1,i,j) = vel / mapf(i,j,+2) &
 
 1314                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 1315                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1316                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 1317                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1324              * 0.5_rp * ( dens(
ks+2,i,j)+dens(
ks+2,i+1,j) ) &
 
 1326              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i+1,j) ) )
 
 1327        vel = vel * j13g(
ks+1,i,j)
 
 1328        flux(
ks+1,i,j) = vel / mapf(i,j,+2) &
 
 1329                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 1330                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1331                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 1332                          + 27.0_rp * val(
ks+1,i,j)  &
 
 1333                          + 47.0_rp * val(
ks+2,i,j)  &
 
 1334                          - 13.0_rp * val(
ks+3,i,j) &
 
 1335                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 1336                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1343              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i+1,j) ) &
 
 1345              * 0.5_rp * ( dens(
ke-2,i,j)+dens(
ke-2,i+1,j) ) )
 
 1346        vel = vel * j13g(
ke-2,i,j)
 
 1347        flux(
ke-2,i,j) = vel / mapf(i,j,+2) &
 
 1348                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 1349                          + 27.0_rp * val(
ke-1,i,j)  &
 
 1350                          + 47.0_rp * val(
ke-2,i,j)  &
 
 1351                          - 13.0_rp * val(
ke-3,i,j) &
 
 1352                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 1353                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1354                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 1355                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1357        flux(
ke  ,i,j) = 0.0_rp
 
 1373        GSQRT, J23G, MAPF, &
 
 1375        IIS, IIE, JJS, JJE )
 
 1378     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 1379     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 1380     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 1381     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 1382     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 1383     real(rp), 
intent(in)  :: j23g    (
ka,
ia,
ja)
 
 1384     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 1385     real(rp), 
intent(in)  :: cdz     (
ka)
 
 1386     logical,  
intent(in)  :: twod
 
 1387     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 1405              * 0.5_rp * ( mom(
k+1,i,j)+mom(
k+1,i,j-1) ) &
 
 1407              * 0.5_rp * ( mom(
k,i,j)+mom(
k,i,j-1) ) ) &
 
 1412        vel = vel * j23g(
k,i,j)
 
 1413        flux(
k,i,j) = vel * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 1414                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 1415                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 1416                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 1417                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 1418                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) )
 
 1429        flux(
ks-1,i,j) = 0.0_rp
 
 1432              * 0.5_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i,j-1) ) &
 
 1434              * 0.5_rp * ( mom(
ks,i,j)+mom(
ks,i,j-1) ) ) &
 
 1439        vel = vel * j23g(
ks,i,j)
 
 1440        flux(
ks,i,j) = vel / mapf(i,j,+1) &
 
 1441                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 1442                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1443                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 1444                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1447              * 0.5_rp * ( mom(
ke,i,j)+mom(
ke,i,j-1) ) &
 
 1449              * 0.5_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i,j-1) ) ) &
 
 1454        vel = vel * j23g(
ke-1,i,j)
 
 1455        flux(
ke-1,i,j) = vel / mapf(i,j,+1) &
 
 1456                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 1457                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1458                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 1459                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1462              * 0.5_rp * ( mom(
ks+2,i,j)+mom(
ks+2,i,j-1) ) &
 
 1464              * 0.5_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i,j-1) ) ) &
 
 1469        vel = vel * j23g(
ks+1,i,j)
 
 1470        flux(
ks+1,i,j) = vel / mapf(i,j,+1) &
 
 1471                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 1472                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1473                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 1474                          + 27.0_rp * val(
ks+1,i,j)  &
 
 1475                          + 47.0_rp * val(
ks+2,i,j)  &
 
 1476                          - 13.0_rp * val(
ks+3,i,j) &
 
 1477                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 1478                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1481              * 0.5_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i,j-1) ) &
 
 1483              * 0.5_rp * ( mom(
ke-2,i,j)+mom(
ke-2,i,j-1) ) ) &
 
 1488        vel = vel * j23g(
ke-2,i,j)
 
 1489        flux(
ke-2,i,j) = vel / mapf(i,j,+1) &
 
 1490                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 1491                          + 27.0_rp * val(
ke-1,i,j)  &
 
 1492                          + 47.0_rp * val(
ke-2,i,j)  &
 
 1493                          - 13.0_rp * val(
ke-3,i,j) &
 
 1494                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 1495                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1496                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 1497                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1499        flux(
ke  ,i,j) = 0.0_rp
 
 1511              * 0.25_rp * ( mom(
k+1,i,j)+mom(
k+1,i+1,j)+mom(
k+1,i,j-1)+mom(
k+1,i+1,j-1) ) &
 
 1513              * 0.25_rp * ( mom(
k,i,j)+mom(
k,i+1,j)+mom(
k,i,j-1)+mom(
k,i+1,j-1) ) ) &
 
 1515              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i+1,j) ) &
 
 1517              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i+1,j) ) )
 
 1518        vel = vel * j23g(
k,i,j)
 
 1519        flux(
k,i,j) = vel / mapf(i,j,+1) &
 
 1520                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 1521                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 1522                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 1523                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 1524                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 1525                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) )
 
 1537        flux(
ks-1,i,j) = 0.0_rp
 
 1540              * 0.25_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i+1,j)+mom(
ks+1,i,j-1)+mom(
ks+1,i+1,j-1) ) &
 
 1542              * 0.25_rp * ( mom(
ks,i,j)+mom(
ks,i+1,j)+mom(
ks,i,j-1)+mom(
ks,i+1,j-1) ) ) &
 
 1544              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i+1,j) ) &
 
 1546              * 0.5_rp * ( dens(
ks,i,j)+dens(
ks,i+1,j) ) )
 
 1547        vel = vel * j23g(
ks,i,j)
 
 1548        flux(
ks,i,j) = vel / mapf(i,j,+1) &
 
 1549                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 1550                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1551                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 1552                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1555              * 0.25_rp * ( mom(
ke,i,j)+mom(
ke,i+1,j)+mom(
ke,i,j-1)+mom(
ke,i+1,j-1) ) &
 
 1557              * 0.25_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i+1,j)+mom(
ke-1,i,j-1)+mom(
ke-1,i+1,j-1) ) ) &
 
 1559              * 0.5_rp * ( dens(
ke,i,j)+dens(
ke,i+1,j) ) &
 
 1561              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i+1,j) ) )
 
 1562        vel = vel * j23g(
ke-1,i,j)
 
 1563        flux(
ke-1,i,j) = vel / mapf(i,j,+1) &
 
 1564                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 1565                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1566                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 1567                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1570              * 0.25_rp * ( mom(
ks+2,i,j)+mom(
ks+2,i+1,j)+mom(
ks+2,i,j-1)+mom(
ks+2,i+1,j-1) ) &
 
 1572              * 0.25_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i+1,j)+mom(
ks+1,i,j-1)+mom(
ks+1,i+1,j-1) ) ) &
 
 1574              * 0.5_rp * ( dens(
ks+2,i,j)+dens(
ks+2,i+1,j) ) &
 
 1576              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i+1,j) ) )
 
 1577        vel = vel * j23g(
ks+1,i,j)
 
 1578        flux(
ks+1,i,j) = vel / mapf(i,j,+1) &
 
 1579                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 1580                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1581                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 1582                          + 27.0_rp * val(
ks+1,i,j)  &
 
 1583                          + 47.0_rp * val(
ks+2,i,j)  &
 
 1584                          - 13.0_rp * val(
ks+3,i,j) &
 
 1585                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 1586                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1589              * 0.25_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i+1,j)+mom(
ke-1,i,j-1)+mom(
ke-1,i+1,j-1) ) &
 
 1591              * 0.25_rp * ( mom(
ke-2,i,j)+mom(
ke-2,i+1,j)+mom(
ke-2,i,j-1)+mom(
ke-2,i+1,j-1) ) ) &
 
 1593              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i+1,j) ) &
 
 1595              * 0.5_rp * ( dens(
ke-2,i,j)+dens(
ke-2,i+1,j) ) )
 
 1596        vel = vel * j23g(
ke-2,i,j)
 
 1597        flux(
ke-2,i,j) = vel / mapf(i,j,+1) &
 
 1598                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 1599                          + 27.0_rp * val(
ke-1,i,j)  &
 
 1600                          + 47.0_rp * val(
ke-2,i,j)  &
 
 1601                          - 13.0_rp * val(
ke-3,i,j) &
 
 1602                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 1603                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1604                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 1605                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 1607        flux(
ke  ,i,j) = 0.0_rp
 
 1628        IIS, IIE, JJS, JJE )
 
 1631     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 1632     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 1633     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 1634     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 1635     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 1636     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 1637     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
 1638     real(rp), 
intent(in)  :: cdz     (
ka)
 
 1639     logical,  
intent(in)  :: twod
 
 1640     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 1657        call check( __line__, mom(
k,i  ,j) )
 
 1658        call check( __line__, mom(
k,i-1,j) )
 
 1660        call check( __line__, val(
k,i-1,j) )
 
 1661        call check( __line__, val(
k,i,j) )
 
 1663        call check( __line__, val(
k,i-2,j) )
 
 1664        call check( __line__, val(
k,i+1,j) )
 
 1666        call check( __line__, val(
k,i-3,j) )
 
 1667        call check( __line__, val(
k,i+2,j) )
 
 1670        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i-1,j) ) ) &
 
 1672        flux(
k,i-1,j) = gsqrt(
k,i,j) / mapf(i,j,+2) * vel &
 
 1673                    * ( ( f51 * ( val(
k,i+2,j)+val(
k,i-3,j) ) &
 
 1674                        + f52 * ( val(
k,i+1,j)+val(
k,i-2,j) ) &
 
 1675                        + f53 * ( val(
k,i,j)+val(
k,i-1,j) ) ) &
 
 1676                      - ( f51 * ( val(
k,i+2,j)-val(
k,i-3,j) ) &
 
 1677                        + f54 * ( val(
k,i+1,j)-val(
k,i-2,j) ) &
 
 1678                        + f55 * ( val(
k,i,j)-val(
k,i-1,j) ) ) * sign(1.0_rp,vel) ) &
 
 1679                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 1684     k = iundef; i = iundef; j = iundef
 
 1700        IIS, IIE, JJS, JJE )
 
 1703     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 1704     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 1705     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 1706     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 1707     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 1708     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 1709     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
 1710     real(rp), 
intent(in)  :: cdz     (
ka)
 
 1711     logical,  
intent(in)  :: twod
 
 1712     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 1729        call check( __line__, mom(
k,i  ,j) )
 
 1731        call check( __line__, val(
k,i,j) )
 
 1732        call check( __line__, val(
k,i,j+1) )
 
 1734        call check( __line__, val(
k,i,j-1) )
 
 1735        call check( __line__, val(
k,i,j+2) )
 
 1737        call check( __line__, val(
k,i,j-2) )
 
 1738        call check( __line__, val(
k,i,j+3) )
 
 1741        vel = ( mom(
k,i,j) ) &
 
 1742            / ( 0.5_rp * ( dens(
k,i,j)+dens(
k,i,j+1) ) )
 
 1743        flux(
k,i,j) = gsqrt(
k,i,j) / mapf(i,j,+1) * vel &
 
 1744                    * ( ( f51 * ( val(
k,i,j+3)+val(
k,i,j-2) ) &
 
 1745                        + f52 * ( val(
k,i,j+2)+val(
k,i,j-1) ) &
 
 1746                        + f53 * ( val(
k,i,j+1)+val(
k,i,j) ) ) &
 
 1747                      - ( f51 * ( val(
k,i,j+3)-val(
k,i,j-2) ) &
 
 1748                        + f54 * ( val(
k,i,j+2)-val(
k,i,j-1) ) &
 
 1749                        + f55 * ( val(
k,i,j+1)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
 1750                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 1754     k = iundef; i = iundef; j = iundef
 
 1767        call check( __line__, mom(
k,i  ,j) )
 
 1768        call check( __line__, mom(
k,i-1,j) )
 
 1770        call check( __line__, val(
k,i,j) )
 
 1771        call check( __line__, val(
k,i,j+1) )
 
 1773        call check( __line__, val(
k,i,j-1) )
 
 1774        call check( __line__, val(
k,i,j+2) )
 
 1776        call check( __line__, val(
k,i,j-2) )
 
 1777        call check( __line__, val(
k,i,j+3) )
 
 1780        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i+1,j) ) ) &
 
 1781            / ( 0.25_rp * ( dens(
k,i,j)+dens(
k,i+1,j)+dens(
k,i,j+1)+dens(
k,i+1,j+1) ) )
 
 1782        flux(
k,i,j) = gsqrt(
k,i,j) / mapf(i,j,+1) * vel &
 
 1783                    * ( ( f51 * ( val(
k,i,j+3)+val(
k,i,j-2) ) &
 
 1784                        + f52 * ( val(
k,i,j+2)+val(
k,i,j-1) ) &
 
 1785                        + f53 * ( val(
k,i,j+1)+val(
k,i,j) ) ) &
 
 1786                      - ( f51 * ( val(
k,i,j+3)-val(
k,i,j-2) ) &
 
 1787                        + f54 * ( val(
k,i,j+2)-val(
k,i,j-1) ) &
 
 1788                        + f55 * ( val(
k,i,j+1)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
 1789                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 1794     k = iundef; i = iundef; j = iundef
 
 1814        IIS, IIE, JJS, JJE )
 
 1817     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 1818     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 1819     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 1820     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 1821     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 1822     real(rp), 
intent(in)  :: j33g
 
 1823     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
 1824     real(rp), 
intent(in)  :: cdz     (
ka)
 
 1825     logical,  
intent(in)  :: twod
 
 1826     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 1842        call check( __line__, mom(
k,i,j) )
 
 1843        call check( __line__, mom(
k,i,j+1) )
 
 1845        call check( __line__, val(
k,i,j) )
 
 1846        call check( __line__, val(
k+1,i,j) )
 
 1848        call check( __line__, val(
k-1,i,j) )
 
 1849        call check( __line__, val(
k+2,i,j) )
 
 1851        call check( __line__, val(
k-2,i,j) )
 
 1852        call check( __line__, val(
k+3,i,j) )
 
 1855        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i,j+1) ) ) &
 
 1857              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i,j+1) ) &
 
 1859              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i,j+1) ) )
 
 1860        flux(
k,i,j) = j33g * vel &
 
 1861                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 1862                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 1863                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 1864                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 1865                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 1866                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
 1867                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 1873     k = iundef; i = iundef; j = iundef
 
 1881        call check( __line__, mom(
ks,i  ,j) )
 
 1882        call check( __line__, mom(
ks,i,j+1) )
 
 1883        call check( __line__, val(
ks+1,i,j) )
 
 1884        call check( __line__, val(
ks,i,j) )
 
 1886        call check( __line__, mom(
ks+1,i  ,j) )
 
 1887        call check( __line__, mom(
ks+1,i,j+1) )
 
 1888        call check( __line__, val(
ks+3,i,j) )
 
 1889        call check( __line__, val(
ks+2,i,j) )
 
 1895        flux(
ks-1,i,j) = 0.0_rp
 
 1897        vel = ( 0.5_rp * ( mom(
ks,i,j)+mom(
ks,i,j+1) ) ) &
 
 1899              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i,j+1) ) &
 
 1901              * 0.5_rp * ( dens(
ks,i,j)+dens(
ks,i,j+1) ) )
 
 1902        flux(
ks,i,j) = j33g * vel &
 
 1903                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 1904                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1905                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 1906                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1907                    + gsqrt(
ks,i,j) * num_diff(
ks,i,j)
 
 1908        vel = ( 0.5_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i,j+1) ) ) &
 
 1910              * 0.5_rp * ( dens(
ke,i,j)+dens(
ke,i,j+1) ) &
 
 1912              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i,j+1) ) )
 
 1913        flux(
ke-1,i,j) = j33g * vel &
 
 1914                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 1915                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1916                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 1917                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1918                    + gsqrt(
ke-1,i,j) * num_diff(
ke-1,i,j)
 
 1920        vel = ( 0.5_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i,j+1) ) ) &
 
 1922              * 0.5_rp * ( dens(
ks+2,i,j)+dens(
ks+2,i,j+1) ) &
 
 1924              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i,j+1) ) )
 
 1925        flux(
ks+1,i,j) = j33g * vel &
 
 1926                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 1927                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1928                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 1929                          + 27.0_rp * val(
ks+1,i,j)  &
 
 1930                          + 47.0_rp * val(
ks+2,i,j)  &
 
 1931                          - 13.0_rp * val(
ks+3,i,j) &
 
 1932                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 1933                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1934                    + gsqrt(
ks+1,i,j) * num_diff(
ks+1,i,j)
 
 1935        vel = ( 0.5_rp * ( mom(
ke-2,i,j)+mom(
ke-2,i,j+1) ) ) &
 
 1937              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i,j+1) ) &
 
 1939              * 0.5_rp * ( dens(
ke-2,i,j)+dens(
ke-2,i,j+1) ) )
 
 1940        flux(
ke-2,i,j) = j33g * vel &
 
 1941                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 1942                          + 27.0_rp * val(
ke-1,i,j)  &
 
 1943                          + 47.0_rp * val(
ke-2,i,j)  &
 
 1944                          - 13.0_rp * val(
ke-3,i,j) &
 
 1945                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 1946                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 1947                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 1948                      * ( 0.5_rp - sign(0.5_rp,vel) ) ) &
 
 1949                    + gsqrt(
ke-2,i,j) * num_diff(
ke-2,i,j)
 
 1951        flux(
ke,i,j) = 0.0_rp
 
 1959     k = iundef; i = iundef; j = iundef
 
 1970        GSQRT, J13G, MAPF, &
 
 1972        IIS, IIE, JJS, JJE )
 
 1975     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 1976     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 1977     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 1978     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 1979     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 1980     real(rp), 
intent(in)  :: j13g    (
ka,
ia,
ja)
 
 1981     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 1982     real(rp), 
intent(in)  :: cdz     (
ka)
 
 1983     logical,  
intent(in)  :: twod
 
 1984     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 2001              * 0.25_rp * ( mom(
k+1,i,j)+mom(
k+1,i-1,j)+mom(
k+1,i,j+1)+mom(
k+1,i-1,j+1) ) &
 
 2003              * 0.25_rp * ( mom(
k,i,j)+mom(
k,i-1,j)+mom(
k,i,j+1)+mom(
k,i-1,j+1) ) ) &
 
 2005              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i,j+1) ) &
 
 2007              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i,j+1) ) )
 
 2008        vel = vel * j13g(
k,i,j)
 
 2009        flux(
k,i,j) = vel / mapf(i,j,+2) &
 
 2010                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 2011                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 2012                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 2013                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 2014                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 2015                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) )
 
 2027        flux(
ks-1,i,j) = 0.0_rp
 
 2030              * 0.25_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i-1,j)+mom(
ks+1,i,j+1)+mom(
ks+1,i-1,j+1) ) &
 
 2032              * 0.25_rp * ( mom(
ks,i,j)+mom(
ks,i-1,j)+mom(
ks,i,j+1)+mom(
ks,i-1,j+1) ) ) &
 
 2034              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i,j+1) ) &
 
 2036              * 0.5_rp * ( dens(
ks,i,j)+dens(
ks,i,j+1) ) )
 
 2037        vel = vel * j13g(
ks,i,j)
 
 2038        flux(
ks,i,j) = vel / mapf(i,j,+2) &
 
 2039                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 2040                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2041                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 2042                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2045              * 0.25_rp * ( mom(
ke,i,j)+mom(
ke,i-1,j)+mom(
ke,i,j+1)+mom(
ke,i-1,j+1) ) &
 
 2047              * 0.25_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i-1,j)+mom(
ke-1,i,j+1)+mom(
ke-1,i-1,j+1) ) ) &
 
 2049              * 0.5_rp * ( dens(
ke,i,j)+dens(
ke,i,j+1) ) &
 
 2051              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i,j+1) ) )
 
 2052        vel = vel * j13g(
ke-1,i,j)
 
 2053        flux(
ke-1,i,j) = vel / mapf(i,j,+2) &
 
 2054                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 2055                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2056                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 2057                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2060              * 0.25_rp * ( mom(
ks+2,i,j)+mom(
ks+2,i-1,j)+mom(
ks+2,i,j+1)+mom(
ks+2,i-1,j+1) ) &
 
 2062              * 0.25_rp * ( mom(
ks+1,i,j)+mom(
ks+1,i-1,j)+mom(
ks+1,i,j+1)+mom(
ks+1,i-1,j+1) ) ) &
 
 2064              * 0.5_rp * ( dens(
ks+2,i,j)+dens(
ks+2,i,j+1) ) &
 
 2066              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i,j+1) ) )
 
 2067        vel = vel * j13g(
ks+1,i,j)
 
 2068        flux(
ks+1,i,j) = vel / mapf(i,j,+2) &
 
 2069                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 2070                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2071                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 2072                          + 27.0_rp * val(
ks+1,i,j)  &
 
 2073                          + 47.0_rp * val(
ks+2,i,j)  &
 
 2074                          - 13.0_rp * val(
ks+3,i,j) &
 
 2075                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 2076                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2079              * 0.25_rp * ( mom(
ke-1,i,j)+mom(
ke-1,i-1,j)+mom(
ke-1,i,j+1)+mom(
ke-1,i-1,j+1) ) &
 
 2081              * 0.25_rp * ( mom(
ke-2,i,j)+mom(
ke-2,i-1,j)+mom(
ke-2,i,j+1)+mom(
ke-2,i-1,j+1) ) ) &
 
 2083              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i,j+1) ) &
 
 2085              * 0.5_rp * ( dens(
ke-2,i,j)+dens(
ke-2,i,j+1) ) )
 
 2086        vel = vel * j13g(
ke-2,i,j)
 
 2087        flux(
ke-2,i,j) = vel / mapf(i,j,+2) &
 
 2088                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 2089                          + 27.0_rp * val(
ke-1,i,j)  &
 
 2090                          + 47.0_rp * val(
ke-2,i,j)  &
 
 2091                          - 13.0_rp * val(
ke-3,i,j) &
 
 2092                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 2093                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2094                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 2095                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2097        flux(
ke  ,i,j) = 0.0_rp
 
 2113        GSQRT, J23G, MAPF, &
 
 2115        IIS, IIE, JJS, JJE )
 
 2118     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 2119     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 2120     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 2121     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 2122     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 2123     real(rp), 
intent(in)  :: j23g    (
ka,
ia,
ja)
 
 2124     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 2125     real(rp), 
intent(in)  :: cdz     (
ka)
 
 2126     logical,  
intent(in)  :: twod
 
 2127     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 2148              * 0.5_rp * ( dens(
k+1,i,j)+dens(
k+1,i,j+1) ) &
 
 2150              * 0.5_rp * ( dens(
k,i,j)+dens(
k,i,j+1) ) )
 
 2151        vel = vel * j23g(
k,i,j)
 
 2152        flux(
k,i,j) = vel / mapf(i,j,+1) &
 
 2153                    * ( ( f51 * ( val(
k+3,i,j)+val(
k-2,i,j) ) &
 
 2154                        + f52 * ( val(
k+2,i,j)+val(
k-1,i,j) ) &
 
 2155                        + f53 * ( val(
k+1,i,j)+val(
k,i,j) ) ) &
 
 2156                      - ( f51 * ( val(
k+3,i,j)-val(
k-2,i,j) ) &
 
 2157                        + f54 * ( val(
k+2,i,j)-val(
k-1,i,j) ) &
 
 2158                        + f55 * ( val(
k+1,i,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) )
 
 2170        flux(
ks-1,i,j) = 0.0_rp
 
 2177              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i,j+1) ) &
 
 2179              * 0.5_rp * ( dens(
ks,i,j)+dens(
ks,i,j+1) ) )
 
 2180        vel = vel * j23g(
ks,i,j)
 
 2181        flux(
ks,i,j) = vel / mapf(i,j,+1) &
 
 2182                    * ( f2 * ( val(
ks+1,i,j)+val(
ks,i,j) ) &
 
 2183                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2184                 + ( 2.0_rp * val(
ks,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks+2,i,j) ) / 6.0_rp &
 
 2185                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2192              * 0.5_rp * ( dens(
ke,i,j)+dens(
ke,i,j+1) ) &
 
 2194              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i,j+1) ) )
 
 2195        vel = vel * j23g(
ke-1,i,j)
 
 2196        flux(
ke-1,i,j) = vel / mapf(i,j,+1) &
 
 2197                    * ( ( 2.0_rp * val(
ke,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke-2,i,j) ) / 6.0_rp &
 
 2198                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2199                 + f2 * ( val(
ke,i,j)+val(
ke-1,i,j) ) &
 
 2200                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2207              * 0.5_rp * ( dens(
ks+2,i,j)+dens(
ks+2,i,j+1) ) &
 
 2209              * 0.5_rp * ( dens(
ks+1,i,j)+dens(
ks+1,i,j+1) ) )
 
 2210        vel = vel * j23g(
ks+1,i,j)
 
 2211        flux(
ks+1,i,j) = vel / mapf(i,j,+1) &
 
 2212                    * ( ( 2.0_rp * val(
ks+2,i,j) + 5.0_rp * val(
ks+1,i,j) - val(
ks,i,j) ) / 6.0_rp &
 
 2213                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2214                 + ( -  3.0_rp * val(
ks,i,j)  &
 
 2215                          + 27.0_rp * val(
ks+1,i,j)  &
 
 2216                          + 47.0_rp * val(
ks+2,i,j)  &
 
 2217                          - 13.0_rp * val(
ks+3,i,j) &
 
 2218                          + 2.0_rp * val(
ks+4,i,j) ) / 60.0_rp &
 
 2219                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2226              * 0.5_rp * ( dens(
ke-1,i,j)+dens(
ke-1,i,j+1) ) &
 
 2228              * 0.5_rp * ( dens(
ke-2,i,j)+dens(
ke-2,i,j+1) ) )
 
 2229        vel = vel * j23g(
ke-2,i,j)
 
 2230        flux(
ke-2,i,j) = vel / mapf(i,j,+1) &
 
 2231                    * ( ( -  3.0_rp * val(
ke,i,j)  &
 
 2232                          + 27.0_rp * val(
ke-1,i,j)  &
 
 2233                          + 47.0_rp * val(
ke-2,i,j)  &
 
 2234                          - 13.0_rp * val(
ke-3,i,j) &
 
 2235                          + 2.0_rp * val(
ke-4,i,j) ) / 60.0_rp &
 
 2236                      * ( 0.5_rp + sign(0.5_rp,vel) ) &
 
 2237                 + ( 2.0_rp * val(
ke-2,i,j) + 5.0_rp * val(
ke-1,i,j) - val(
ke,i,j) ) / 6.0_rp &
 
 2238                      * ( 0.5_rp - sign(0.5_rp,vel) ) )
 
 2240        flux(
ke  ,i,j) = 0.0_rp
 
 2259        IIS, IIE, JJS, JJE )
 
 2262     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 2263     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 2264     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 2265     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 2266     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 2267     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 2268     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
 2269     real(rp), 
intent(in)  :: cdz     (
ka)
 
 2270     logical,  
intent(in)  :: twod
 
 2271     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 2286        call check( __line__, mom(
k,i  ,j) )
 
 2287        call check( __line__, mom(
k,i,j-1) )
 
 2289        call check( __line__, val(
k,i,j) )
 
 2290        call check( __line__, val(
k,i+1,j) )
 
 2292        call check( __line__, val(
k,i-1,j) )
 
 2293        call check( __line__, val(
k,i+2,j) )
 
 2295        call check( __line__, val(
k,i-2,j) )
 
 2296        call check( __line__, val(
k,i+3,j) )
 
 2299        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i,j+1) ) ) &
 
 2300            / ( 0.25_rp * ( dens(
k,i,j)+dens(
k,i+1,j)+dens(
k,i,j+1)+dens(
k,i+1,j+1) ) )
 
 2301        flux(
k,i,j) = gsqrt(
k,i,j) / mapf(i,j,+2) * vel &
 
 2302                    * ( ( f51 * ( val(
k,i+3,j)+val(
k,i-2,j) ) &
 
 2303                        + f52 * ( val(
k,i+2,j)+val(
k,i-1,j) ) &
 
 2304                        + f53 * ( val(
k,i+1,j)+val(
k,i,j) ) ) &
 
 2305                      - ( f51 * ( val(
k,i+3,j)-val(
k,i-2,j) ) &
 
 2306                        + f54 * ( val(
k,i+2,j)-val(
k,i-1,j) ) &
 
 2307                        + f55 * ( val(
k,i+1,j)-val(
k,i,j) ) ) * sign(1.0_rp,vel) ) &
 
 2308                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 2313     k = iundef; i = iundef; j = iundef
 
 2329        IIS, IIE, JJS, JJE )
 
 2332     real(rp), 
intent(inout) :: flux    (
ka,
ia,
ja)
 
 2333     real(rp), 
intent(in)  :: mom     (
ka,
ia,
ja)
 
 2334     real(rp), 
intent(in)  :: val     (
ka,
ia,
ja)
 
 2335     real(rp), 
intent(in)  :: dens    (
ka,
ia,
ja)
 
 2336     real(rp), 
intent(in)  :: gsqrt   (
ka,
ia,
ja)
 
 2337     real(rp), 
intent(in)  :: mapf    (   
ia,
ja,2)
 
 2338     real(rp), 
intent(in)  :: num_diff(
ka,
ia,
ja)
 
 2339     real(rp), 
intent(in)  :: cdz     (
ka)
 
 2340     logical,  
intent(in)  :: twod
 
 2341     integer,  
intent(in)  :: iis, iie, jjs, jje
 
 2358        call check( __line__, mom(
k,i  ,j) )
 
 2359        call check( __line__, mom(
k,i,j-1) )
 
 2361        call check( __line__, val(
k,i,j-1) )
 
 2362        call check( __line__, val(
k,i,j) )
 
 2364        call check( __line__, val(
k,i,j-2) )
 
 2365        call check( __line__, val(
k,i,j+1) )
 
 2367        call check( __line__, val(
k,i,j-3) )
 
 2368        call check( __line__, val(
k,i,j+2) )
 
 2371        vel = ( 0.5_rp * ( mom(
k,i,j)+mom(
k,i,j-1) ) ) &
 
 2373        flux(
k,i,j-1) = gsqrt(
k,i,j) / mapf(i,j,+1) * vel &
 
 2374                    * ( ( f51 * ( val(
k,i,j+2)+val(
k,i,j-3) ) &
 
 2375                        + f52 * ( val(
k,i,j+1)+val(
k,i,j-2) ) &
 
 2376                        + f53 * ( val(
k,i,j)+val(
k,i,j-1) ) ) &
 
 2377                      - ( f51 * ( val(
k,i,j+2)-val(
k,i,j-3) ) &
 
 2378                        + f54 * ( val(
k,i,j+1)-val(
k,i,j-2) ) &
 
 2379                        + f55 * ( val(
k,i,j)-val(
k,i,j-1) ) ) * sign(1.0_rp,vel) ) &
 
 2380                    + gsqrt(
k,i,j) * num_diff(
k,i,j)
 
 2385     k = iundef; i = iundef; j = iundef