scale_atmos_dyn_fvm_flux.F90

Go to the documentation of this file.

 
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
#include "scalelib.h"
module scale_atmos_dyn_fvm_flux
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_io
  use scale_prof
  use scale_atmos_grid_cartesc_index
  use scale_index
  use scale_tracer
  use scale_prc
#ifdef DEBUG
  use scale_debug, only: &
     check
  use scale_const, only: &
     undef  => const_undef, &
     iundef => const_undef2
#endif
  !-----------------------------------------------------------------------------
  implicit none
  private
  !-----------------------------------------------------------------------------
  !
  !++ Public procedure
  !
  public :: atmos_dyn_fvm_flux_setup
 
  abstract interface
     subroutine valuew( &
          valW, &
          mflx, val, GSQRT, &
          CDZ )
       use scale_precision
       use scale_atmos_grid_cartesc_index
       implicit none
       real(RP), intent(out) :: valW (KA)
       real(RP), intent(in)  :: mflx (KA)
       real(RP), intent(in)  :: val  (KA)
       real(RP), intent(in)  :: GSQRT(KA)
       real(RP), intent(in)  :: CDZ(KA)
     end subroutine valuew
     subroutine flux_phi( &
          flux, &
          mflx, val, GSQRT, &
          num_diff, &
          CDZ, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_atmos_grid_cartesc_index
       implicit none
       real(RP), intent(inout) :: flux    (KA,IA,JA)
       real(RP), intent(in)  :: mflx    (KA,IA,JA)
       real(RP), intent(in)  :: val     (KA,IA,JA)
       real(RP), intent(in)  :: GSQRT   (KA,IA,JA)
       real(RP), intent(in)  :: num_diff(KA,IA,JA)
       real(RP), intent(in)  :: CDZ(KA)
       integer,  intent(in)  :: IIS, IIE, JJS, JJE
     end subroutine flux_phi
     subroutine flux_mom( &
          flux, &
          mom, val, DENS, &
          GSQRT, MAPF, &
          num_diff, &
          CDZ, TwoD, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_atmos_grid_cartesc_index
       implicit none
       real(RP), intent(inout) :: flux    (KA,IA,JA)
       real(RP), intent(in)  :: mom     (KA,IA,JA)
       real(RP), intent(in)  :: val     (KA,IA,JA)
       real(RP), intent(in)  :: DENS    (KA,IA,JA)
       real(RP), intent(in)  :: GSQRT   (KA,IA,JA)
       real(RP), intent(in)  :: MAPF    (   IA,JA,2)
       real(RP), intent(in)  :: num_diff(KA,IA,JA)
       real(RP), intent(in)  :: CDZ(KA)
       logical,  intent(in)  :: TwoD
       integer,  intent(in)  :: IIS, IIE, JJS, JJE
     end subroutine flux_mom
     subroutine flux_z( &
          flux, &
          mom, val, DENS, &
          GSQRT, J33G, &
          num_diff, &
          CDZ, TwoD, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_atmos_grid_cartesc_index
       implicit none
       real(RP), intent(inout) :: flux    (KA,IA,JA)
       real(RP), intent(in)  :: mom     (KA,IA,JA)
       real(RP), intent(in)  :: val     (KA,IA,JA)
       real(RP), intent(in)  :: DENS    (KA,IA,JA)
       real(RP), intent(in)  :: GSQRT   (KA,IA,JA)
       real(RP), intent(in)  :: J33G
       real(RP), intent(in)  :: num_diff(KA,IA,JA)
       real(RP), intent(in)  :: CDZ(KA)
       logical,  intent(in)  :: TwoD
       integer,  intent(in)  :: IIS, IIE, JJS, JJE
     end subroutine flux_z
     subroutine flux_wz( &
          flux, &
          mom, val, DENS, &
          GSQRT, J33G, &
          num_diff, &
          CDZ, FDZ, &
          dtrk, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_atmos_grid_cartesc_index
       implicit none
       real(RP), intent(inout) :: flux    (KA,IA,JA)
       real(RP), intent(in)  :: mom     (KA,IA,JA)
       real(RP), intent(in)  :: val     (KA,IA,JA)
       real(RP), intent(in)  :: DENS    (KA,IA,JA)
       real(RP), intent(in)  :: GSQRT   (KA,IA,JA)
       real(RP), intent(in)  :: J33G
       real(RP), intent(in)  :: num_diff(KA,IA,JA)
       real(RP), intent(in)  :: CDZ(KA)
       real(RP), intent(in)  :: FDZ(KA-1)
       real(RP), intent(in)  :: dtrk
       integer,  intent(in)  :: IIS, IIE, JJS, JJE
     end subroutine flux_wz
     subroutine flux_j( &
          flux, &
          mom, val, DENS, &
          GSQRT, JG, MAPF, &
          CDZ, TwoD, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_atmos_grid_cartesc_index
       implicit none
       real(RP), intent(inout) :: flux    (KA,IA,JA)
       real(RP), intent(in)  :: mom     (KA,IA,JA)
       real(RP), intent(in)  :: val     (KA,IA,JA)
       real(RP), intent(in)  :: DENS    (KA,IA,JA)
       real(RP), intent(in)  :: GSQRT   (KA,IA,JA)
       real(RP), intent(in)  :: JG      (KA,IA,JA)
       real(RP), intent(in)  :: MAPF    (   IA,JA,2)
       real(RP), intent(in)  :: CDZ(KA)
       logical,  intent(in)  :: TwoD
       integer,  intent(in)  :: IIS, IIE, JJS, JJE
     end subroutine flux_j
  end interface
 
  procedure(valuew), pointer :: atmos_dyn_fvm_flux_valuew_z => null()
  public :: atmos_dyn_fvm_flux_valuew_z
 
 
  procedure(flux_phi), pointer :: atmos_dyn_fvm_fluxz_xyz => null()
  public :: atmos_dyn_fvm_fluxz_xyz
  procedure(flux_phi), pointer :: atmos_dyn_fvm_fluxz_xyz_tracer => null()
  public :: atmos_dyn_fvm_fluxz_xyz_tracer
 
  procedure(flux_phi), pointer :: atmos_dyn_fvm_fluxx_xyz => null()
  public :: atmos_dyn_fvm_fluxx_xyz
  procedure(flux_phi), pointer :: atmos_dyn_fvm_fluxx_xyz_tracer => null()
  public :: atmos_dyn_fvm_fluxx_xyz_tracer
 
  procedure(flux_phi), pointer :: atmos_dyn_fvm_fluxy_xyz => null()
  public :: atmos_dyn_fvm_fluxy_xyz
  procedure(flux_phi), pointer :: atmos_dyn_fvm_fluxy_xyz_tracer => null()
  public :: atmos_dyn_fvm_fluxy_xyz_tracer
 
 
 
  procedure(flux_wz), pointer :: atmos_dyn_fvm_fluxz_xyw => null()
  public :: atmos_dyn_fvm_fluxz_xyw
  procedure(flux_wz), pointer :: atmos_dyn_fvm_fluxz_xyw_tracer => null()
  public :: atmos_dyn_fvm_fluxz_xyw_tracer
 
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxx_xyw => null()
  public :: atmos_dyn_fvm_fluxx_xyw
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxx_xyw_tracer => null()
  public :: atmos_dyn_fvm_fluxx_xyw_tracer
 
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxy_xyw => null()
  public :: atmos_dyn_fvm_fluxy_xyw
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxy_xyw_tracer => null()
  public :: atmos_dyn_fvm_fluxy_xyw_tracer
 
 
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj13_xyw => null()
  public :: atmos_dyn_fvm_fluxj13_xyw
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj13_xyw_tracer => null()
  public :: atmos_dyn_fvm_fluxj13_xyw_tracer
 
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj23_xyw => null()
  public :: atmos_dyn_fvm_fluxj23_xyw
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj23_xyw_tracer => null()
  public :: atmos_dyn_fvm_fluxj23_xyw_tracer
 
 
  procedure(flux_z), pointer :: atmos_dyn_fvm_fluxz_uyz => null()
  public :: atmos_dyn_fvm_fluxz_uyz
  procedure(flux_z), pointer :: atmos_dyn_fvm_fluxz_uyz_tracer => null()
  public :: atmos_dyn_fvm_fluxz_uyz_tracer
 
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxx_uyz => null()
  public :: atmos_dyn_fvm_fluxx_uyz
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxx_uyz_tracer => null()
  public :: atmos_dyn_fvm_fluxx_uyz_tracer
 
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxy_uyz => null()
  public :: atmos_dyn_fvm_fluxy_uyz
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxy_uyz_tracer => null()
  public :: atmos_dyn_fvm_fluxy_uyz_tracer
 
 
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj13_uyz => null()
  public :: atmos_dyn_fvm_fluxj13_uyz
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj13_uyz_tracer => null()
  public :: atmos_dyn_fvm_fluxj13_uyz_tracer
 
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj23_uyz => null()
  public :: atmos_dyn_fvm_fluxj23_uyz
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj23_uyz_tracer => null()
  public :: atmos_dyn_fvm_fluxj23_uyz_tracer
 
 
  procedure(flux_z), pointer :: atmos_dyn_fvm_fluxz_xvz => null()
  public :: atmos_dyn_fvm_fluxz_xvz
  procedure(flux_z), pointer :: atmos_dyn_fvm_fluxz_xvz_tracer => null()
  public :: atmos_dyn_fvm_fluxz_xvz_tracer
 
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxx_xvz => null()
  public :: atmos_dyn_fvm_fluxx_xvz
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxx_xvz_tracer => null()
  public :: atmos_dyn_fvm_fluxx_xvz_tracer
 
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxy_xvz => null()
  public :: atmos_dyn_fvm_fluxy_xvz
  procedure(flux_mom), pointer :: atmos_dyn_fvm_fluxy_xvz_tracer => null()
  public :: atmos_dyn_fvm_fluxy_xvz_tracer
 
 
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj13_xvz => null()
  public :: atmos_dyn_fvm_fluxj13_xvz
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj13_xvz_tracer => null()
  public :: atmos_dyn_fvm_fluxj13_xvz_tracer
 
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj23_xvz => null()
  public :: atmos_dyn_fvm_fluxj23_xvz
  procedure(flux_j), pointer :: atmos_dyn_fvm_fluxj23_xvz_tracer => null()
  public :: atmos_dyn_fvm_fluxj23_xvz_tracer
 
 
 
  !-----------------------------------------------------------------------------
  !
  !++ Public parameters & variables
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private procedure
  !
  !-----------------------------------------------------------------------------
  !
  !++ Private parameters & variables
  !
  !-----------------------------------------------------------------------------
contains
  
  !-----------------------------------------------------------------------------
  subroutine atmos_dyn_fvm_flux_setup( &
       scheme, scheme_tracer )
    use scale_prc, only: &
         prc_abort
    use scale_prc_cartesc, only: &
         prc_twod
 
   use scale_atmos_dyn_fvm_flux_ud1, only: &
      atmos_dyn_fvm_flux_valuew_z_ud1, &
      atmos_dyn_fvm_fluxz_xyz_ud1, &
      atmos_dyn_fvm_fluxx_xyz_ud1, &
      atmos_dyn_fvm_fluxy_xyz_ud1, &
      atmos_dyn_fvm_fluxz_xyw_ud1, &
      atmos_dyn_fvm_fluxx_xyw_ud1, &
      atmos_dyn_fvm_fluxy_xyw_ud1, &
      atmos_dyn_fvm_fluxj13_xyw_ud1, &
      atmos_dyn_fvm_fluxj23_xyw_ud1, &
      atmos_dyn_fvm_fluxz_uyz_ud1, &
      atmos_dyn_fvm_fluxx_uyz_ud1, &
      atmos_dyn_fvm_fluxy_uyz_ud1, &
      atmos_dyn_fvm_fluxj13_uyz_ud1, &
      atmos_dyn_fvm_fluxj23_uyz_ud1, &
      atmos_dyn_fvm_fluxz_xvz_ud1, &
      atmos_dyn_fvm_fluxx_xvz_ud1, &
      atmos_dyn_fvm_fluxy_xvz_ud1, &
      atmos_dyn_fvm_fluxj13_xvz_ud1, &
      atmos_dyn_fvm_fluxj23_xvz_ud1
 
   use scale_atmos_dyn_fvm_flux_cd2, only: &
      atmos_dyn_fvm_flux_valuew_z_cd2, &
      atmos_dyn_fvm_fluxz_xyz_cd2, &
      atmos_dyn_fvm_fluxx_xyz_cd2, &
      atmos_dyn_fvm_fluxy_xyz_cd2, &
      atmos_dyn_fvm_fluxz_xyw_cd2, &
      atmos_dyn_fvm_fluxx_xyw_cd2, &
      atmos_dyn_fvm_fluxy_xyw_cd2, &
      atmos_dyn_fvm_fluxj13_xyw_cd2, &
      atmos_dyn_fvm_fluxj23_xyw_cd2, &
      atmos_dyn_fvm_fluxz_uyz_cd2, &
      atmos_dyn_fvm_fluxx_uyz_cd2, &
      atmos_dyn_fvm_fluxy_uyz_cd2, &
      atmos_dyn_fvm_fluxj13_uyz_cd2, &
      atmos_dyn_fvm_fluxj23_uyz_cd2, &
      atmos_dyn_fvm_fluxz_xvz_cd2, &
      atmos_dyn_fvm_fluxx_xvz_cd2, &
      atmos_dyn_fvm_fluxy_xvz_cd2, &
      atmos_dyn_fvm_fluxj13_xvz_cd2, &
      atmos_dyn_fvm_fluxj23_xvz_cd2
 
   use scale_atmos_dyn_fvm_flux_ud3, only: &
      atmos_dyn_fvm_flux_valuew_z_ud3, &
      atmos_dyn_fvm_fluxz_xyz_ud3, &
      atmos_dyn_fvm_fluxx_xyz_ud3, &
      atmos_dyn_fvm_fluxy_xyz_ud3, &
      atmos_dyn_fvm_fluxz_xyw_ud3, &
      atmos_dyn_fvm_fluxx_xyw_ud3, &
      atmos_dyn_fvm_fluxy_xyw_ud3, &
      atmos_dyn_fvm_fluxj13_xyw_ud3, &
      atmos_dyn_fvm_fluxj23_xyw_ud3, &
      atmos_dyn_fvm_fluxz_uyz_ud3, &
      atmos_dyn_fvm_fluxx_uyz_ud3, &
      atmos_dyn_fvm_fluxy_uyz_ud3, &
      atmos_dyn_fvm_fluxj13_uyz_ud3, &
      atmos_dyn_fvm_fluxj23_uyz_ud3, &
      atmos_dyn_fvm_fluxz_xvz_ud3, &
      atmos_dyn_fvm_fluxx_xvz_ud3, &
      atmos_dyn_fvm_fluxy_xvz_ud3, &
      atmos_dyn_fvm_fluxj13_xvz_ud3, &
      atmos_dyn_fvm_fluxj23_xvz_ud3
 
   use scale_atmos_dyn_fvm_flux_ud3koren1993, only: &
      atmos_dyn_fvm_flux_valuew_z_ud3koren1993, &
      atmos_dyn_fvm_fluxz_xyz_ud3koren1993, &
      atmos_dyn_fvm_fluxx_xyz_ud3koren1993, &
      atmos_dyn_fvm_fluxy_xyz_ud3koren1993, &
      atmos_dyn_fvm_fluxz_xyw_ud3koren1993, &
      atmos_dyn_fvm_fluxx_xyw_ud3koren1993, &
      atmos_dyn_fvm_fluxy_xyw_ud3koren1993, &
      atmos_dyn_fvm_fluxj13_xyw_ud3koren1993, &
      atmos_dyn_fvm_fluxj23_xyw_ud3koren1993, &
      atmos_dyn_fvm_fluxz_uyz_ud3koren1993, &
      atmos_dyn_fvm_fluxx_uyz_ud3koren1993, &
      atmos_dyn_fvm_fluxy_uyz_ud3koren1993, &
      atmos_dyn_fvm_fluxj13_uyz_ud3koren1993, &
      atmos_dyn_fvm_fluxj23_uyz_ud3koren1993, &
      atmos_dyn_fvm_fluxz_xvz_ud3koren1993, &
      atmos_dyn_fvm_fluxx_xvz_ud3koren1993, &
      atmos_dyn_fvm_fluxy_xvz_ud3koren1993, &
      atmos_dyn_fvm_fluxj13_xvz_ud3koren1993, &
      atmos_dyn_fvm_fluxj23_xvz_ud3koren1993
 
   use scale_atmos_dyn_fvm_flux_cd4, only: &
      atmos_dyn_fvm_flux_valuew_z_cd4, &
      atmos_dyn_fvm_fluxz_xyz_cd4, &
      atmos_dyn_fvm_fluxx_xyz_cd4, &
      atmos_dyn_fvm_fluxy_xyz_cd4, &
      atmos_dyn_fvm_fluxz_xyw_cd4, &
      atmos_dyn_fvm_fluxx_xyw_cd4, &
      atmos_dyn_fvm_fluxy_xyw_cd4, &
      atmos_dyn_fvm_fluxj13_xyw_cd4, &
      atmos_dyn_fvm_fluxj23_xyw_cd4, &
      atmos_dyn_fvm_fluxz_uyz_cd4, &
      atmos_dyn_fvm_fluxx_uyz_cd4, &
      atmos_dyn_fvm_fluxy_uyz_cd4, &
      atmos_dyn_fvm_fluxj13_uyz_cd4, &
      atmos_dyn_fvm_fluxj23_uyz_cd4, &
      atmos_dyn_fvm_fluxz_xvz_cd4, &
      atmos_dyn_fvm_fluxx_xvz_cd4, &
      atmos_dyn_fvm_fluxy_xvz_cd4, &
      atmos_dyn_fvm_fluxj13_xvz_cd4, &
      atmos_dyn_fvm_fluxj23_xvz_cd4
 
   use scale_atmos_dyn_fvm_flux_ud5, only: &
      atmos_dyn_fvm_flux_valuew_z_ud5, &
      atmos_dyn_fvm_fluxz_xyz_ud5, &
      atmos_dyn_fvm_fluxx_xyz_ud5, &
      atmos_dyn_fvm_fluxy_xyz_ud5, &
      atmos_dyn_fvm_fluxz_xyw_ud5, &
      atmos_dyn_fvm_fluxx_xyw_ud5, &
      atmos_dyn_fvm_fluxy_xyw_ud5, &
      atmos_dyn_fvm_fluxj13_xyw_ud5, &
      atmos_dyn_fvm_fluxj23_xyw_ud5, &
      atmos_dyn_fvm_fluxz_uyz_ud5, &
      atmos_dyn_fvm_fluxx_uyz_ud5, &
      atmos_dyn_fvm_fluxy_uyz_ud5, &
      atmos_dyn_fvm_fluxj13_uyz_ud5, &
      atmos_dyn_fvm_fluxj23_uyz_ud5, &
      atmos_dyn_fvm_fluxz_xvz_ud5, &
      atmos_dyn_fvm_fluxx_xvz_ud5, &
      atmos_dyn_fvm_fluxy_xvz_ud5, &
      atmos_dyn_fvm_fluxj13_xvz_ud5, &
      atmos_dyn_fvm_fluxj23_xvz_ud5
 
   use scale_atmos_dyn_fvm_flux_cd6, only: &
      atmos_dyn_fvm_flux_valuew_z_cd6, &
      atmos_dyn_fvm_fluxz_xyz_cd6, &
      atmos_dyn_fvm_fluxx_xyz_cd6, &
      atmos_dyn_fvm_fluxy_xyz_cd6, &
      atmos_dyn_fvm_fluxz_xyw_cd6, &
      atmos_dyn_fvm_fluxx_xyw_cd6, &
      atmos_dyn_fvm_fluxy_xyw_cd6, &
      atmos_dyn_fvm_fluxj13_xyw_cd6, &
      atmos_dyn_fvm_fluxj23_xyw_cd6, &
      atmos_dyn_fvm_fluxz_uyz_cd6, &
      atmos_dyn_fvm_fluxx_uyz_cd6, &
      atmos_dyn_fvm_fluxy_uyz_cd6, &
      atmos_dyn_fvm_fluxj13_uyz_cd6, &
      atmos_dyn_fvm_fluxj23_uyz_cd6, &
      atmos_dyn_fvm_fluxz_xvz_cd6, &
      atmos_dyn_fvm_fluxx_xvz_cd6, &
      atmos_dyn_fvm_fluxy_xvz_cd6, &
      atmos_dyn_fvm_fluxj13_xvz_cd6, &
      atmos_dyn_fvm_fluxj23_xvz_cd6
 
   use scale_atmos_dyn_fvm_flux_ud7, only: &
      atmos_dyn_fvm_flux_valuew_z_ud7, &
      atmos_dyn_fvm_fluxz_xyz_ud7, &
      atmos_dyn_fvm_fluxx_xyz_ud7, &
      atmos_dyn_fvm_fluxy_xyz_ud7, &
      atmos_dyn_fvm_fluxz_xyw_ud7, &
      atmos_dyn_fvm_fluxx_xyw_ud7, &
      atmos_dyn_fvm_fluxy_xyw_ud7, &
      atmos_dyn_fvm_fluxj13_xyw_ud7, &
      atmos_dyn_fvm_fluxj23_xyw_ud7, &
      atmos_dyn_fvm_fluxz_uyz_ud7, &
      atmos_dyn_fvm_fluxx_uyz_ud7, &
      atmos_dyn_fvm_fluxy_uyz_ud7, &
      atmos_dyn_fvm_fluxj13_uyz_ud7, &
      atmos_dyn_fvm_fluxj23_uyz_ud7, &
      atmos_dyn_fvm_fluxz_xvz_ud7, &
      atmos_dyn_fvm_fluxx_xvz_ud7, &
      atmos_dyn_fvm_fluxy_xvz_ud7, &
      atmos_dyn_fvm_fluxj13_xvz_ud7, &
      atmos_dyn_fvm_fluxj23_xvz_ud7
 
   use scale_atmos_dyn_fvm_flux_cd8, only: &
      atmos_dyn_fvm_flux_valuew_z_cd8, &
      atmos_dyn_fvm_fluxz_xyz_cd8, &
      atmos_dyn_fvm_fluxx_xyz_cd8, &
      atmos_dyn_fvm_fluxy_xyz_cd8, &
      atmos_dyn_fvm_fluxz_xyw_cd8, &
      atmos_dyn_fvm_fluxx_xyw_cd8, &
      atmos_dyn_fvm_fluxy_xyw_cd8, &
      atmos_dyn_fvm_fluxj13_xyw_cd8, &
      atmos_dyn_fvm_fluxj23_xyw_cd8, &
      atmos_dyn_fvm_fluxz_uyz_cd8, &
      atmos_dyn_fvm_fluxx_uyz_cd8, &
      atmos_dyn_fvm_fluxy_uyz_cd8, &
      atmos_dyn_fvm_fluxj13_uyz_cd8, &
      atmos_dyn_fvm_fluxj23_uyz_cd8, &
      atmos_dyn_fvm_fluxz_xvz_cd8, &
      atmos_dyn_fvm_fluxx_xvz_cd8, &
      atmos_dyn_fvm_fluxy_xvz_cd8, &
      atmos_dyn_fvm_fluxj13_xvz_cd8, &
      atmos_dyn_fvm_fluxj23_xvz_cd8
 
    implicit none
    character(len=*), intent(in) :: scheme
    character(len=*), intent(in) :: scheme_tracer
 
    select case( scheme )
 
    case( "UD1" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud1 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_ud1
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_ud1
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_ud1
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_ud1
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_ud1
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_ud1
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_ud1
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_ud1
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_ud1
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_ud1
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_ud1
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_ud1
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_ud1
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_ud1
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_ud1
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_ud1
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_ud1
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_ud1
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_ud1
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 1
         call prc_abort
      end if
      if ( jhalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 1
         call prc_abort
      end if
 
 
    case( "CD2" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd2 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_cd2
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_cd2
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_cd2
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_cd2
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_cd2
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_cd2
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_cd2
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_cd2
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_cd2
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_cd2
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_cd2
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_cd2
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_cd2
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_cd2
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_cd2
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_cd2
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_cd2
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_cd2
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_cd2
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 1
         call prc_abort
      end if
      if ( jhalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 1
         call prc_abort
      end if
 
 
    case( "UD3" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud3 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_ud3
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_ud3
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_ud3
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_ud3
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_ud3
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_ud3
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_ud3
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_ud3
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_ud3
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_ud3
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_ud3
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_ud3
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_ud3
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_ud3
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_ud3
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_ud3
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_ud3
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_ud3
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_ud3
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 2
         call prc_abort
      end if
      if ( jhalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 2
         call prc_abort
      end if
 
 
    case( "UD3KOREN1993" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud3Koren1993 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_ud3koren1993
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_ud3koren1993
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_ud3koren1993
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_ud3koren1993
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_ud3koren1993
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 2
         call prc_abort
      end if
      if ( jhalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 2
         call prc_abort
      end if
 
 
    case( "CD4" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd4 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_cd4
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_cd4
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_cd4
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_cd4
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_cd4
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_cd4
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_cd4
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_cd4
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_cd4
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_cd4
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_cd4
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_cd4
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_cd4
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_cd4
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_cd4
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_cd4
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_cd4
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_cd4
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_cd4
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 2
         call prc_abort
      end if
      if ( jhalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 2
         call prc_abort
      end if
 
 
    case( "UD5" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud5 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_ud5
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_ud5
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_ud5
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_ud5
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_ud5
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_ud5
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_ud5
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_ud5
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_ud5
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_ud5
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_ud5
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_ud5
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_ud5
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_ud5
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_ud5
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_ud5
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_ud5
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_ud5
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_ud5
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 3
         call prc_abort
      end if
      if ( jhalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 3
         call prc_abort
      end if
 
 
    case( "CD6" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd6 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_cd6
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_cd6
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_cd6
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_cd6
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_cd6
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_cd6
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_cd6
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_cd6
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_cd6
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_cd6
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_cd6
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_cd6
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_cd6
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_cd6
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_cd6
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_cd6
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_cd6
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_cd6
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_cd6
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 3
         call prc_abort
      end if
      if ( jhalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 3
         call prc_abort
      end if
 
 
    case( "UD7" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud7 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_ud7
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_ud7
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_ud7
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_ud7
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_ud7
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_ud7
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_ud7
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_ud7
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_ud7
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_ud7
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_ud7
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_ud7
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_ud7
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_ud7
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_ud7
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_ud7
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_ud7
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_ud7
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_ud7
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 4
         call prc_abort
      end if
      if ( jhalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 4
         call prc_abort
      end if
 
 
    case( "CD8" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd8 scheme is used for flux calculation'
 
      atmos_dyn_fvm_flux_valuew_z => atmos_dyn_fvm_flux_valuew_z_cd8
 
      atmos_dyn_fvm_fluxz_xyz => atmos_dyn_fvm_fluxz_xyz_cd8
 
      atmos_dyn_fvm_fluxx_xyz => atmos_dyn_fvm_fluxx_xyz_cd8
 
      atmos_dyn_fvm_fluxy_xyz => atmos_dyn_fvm_fluxy_xyz_cd8
 
      atmos_dyn_fvm_fluxz_xyw => atmos_dyn_fvm_fluxz_xyw_cd8
 
      atmos_dyn_fvm_fluxx_xyw => atmos_dyn_fvm_fluxx_xyw_cd8
 
      atmos_dyn_fvm_fluxy_xyw => atmos_dyn_fvm_fluxy_xyw_cd8
 
      atmos_dyn_fvm_fluxj13_xyw => atmos_dyn_fvm_fluxj13_xyw_cd8
 
      atmos_dyn_fvm_fluxj23_xyw => atmos_dyn_fvm_fluxj23_xyw_cd8
 
      atmos_dyn_fvm_fluxz_uyz => atmos_dyn_fvm_fluxz_uyz_cd8
 
      atmos_dyn_fvm_fluxx_uyz => atmos_dyn_fvm_fluxx_uyz_cd8
 
      atmos_dyn_fvm_fluxy_uyz => atmos_dyn_fvm_fluxy_uyz_cd8
 
      atmos_dyn_fvm_fluxj13_uyz => atmos_dyn_fvm_fluxj13_uyz_cd8
 
      atmos_dyn_fvm_fluxj23_uyz => atmos_dyn_fvm_fluxj23_uyz_cd8
 
      atmos_dyn_fvm_fluxz_xvz => atmos_dyn_fvm_fluxz_xvz_cd8
 
      atmos_dyn_fvm_fluxx_xvz => atmos_dyn_fvm_fluxx_xvz_cd8
 
      atmos_dyn_fvm_fluxy_xvz => atmos_dyn_fvm_fluxy_xvz_cd8
 
      atmos_dyn_fvm_fluxj13_xvz => atmos_dyn_fvm_fluxj13_xvz_cd8
 
      atmos_dyn_fvm_fluxj23_xvz => atmos_dyn_fvm_fluxj23_xvz_cd8
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 4
         call prc_abort
      end if
      if ( jhalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 4
         call prc_abort
      end if
 
 
    case default
       log_error("ATMOS_DYN_FVM_flux_setup",*) 'scheme is invalid: ', scheme
       call prc_abort
    end select
 
    select case( scheme_tracer )
 
    case( "UD1" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud1 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_ud1
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_ud1
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_ud1
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_ud1
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_ud1
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_ud1
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_ud1
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_ud1
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_ud1
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_ud1
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_ud1
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_ud1
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_ud1
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_ud1
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_ud1
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_ud1
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_ud1
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_ud1
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 1
         call prc_abort
      end if
      if ( jhalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 1
         call prc_abort
      end if
 
 
    case( "CD2" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd2 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_cd2
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_cd2
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_cd2
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_cd2
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_cd2
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_cd2
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_cd2
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_cd2
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_cd2
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_cd2
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_cd2
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_cd2
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_cd2
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_cd2
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_cd2
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_cd2
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_cd2
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_cd2
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 1
         call prc_abort
      end if
      if ( jhalo < 1 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 1
         call prc_abort
      end if
 
 
    case( "UD3" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud3 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_ud3
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_ud3
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_ud3
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_ud3
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_ud3
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_ud3
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_ud3
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_ud3
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_ud3
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_ud3
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_ud3
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_ud3
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_ud3
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_ud3
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_ud3
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_ud3
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_ud3
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_ud3
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 2
         call prc_abort
      end if
      if ( jhalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 2
         call prc_abort
      end if
 
 
    case( "UD3KOREN1993" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud3Koren1993 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_ud3koren1993
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_ud3koren1993
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_ud3koren1993
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_ud3koren1993
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_ud3koren1993
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_ud3koren1993
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_ud3koren1993
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 2
         call prc_abort
      end if
      if ( jhalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 2
         call prc_abort
      end if
 
 
    case( "CD4" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd4 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_cd4
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_cd4
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_cd4
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_cd4
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_cd4
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_cd4
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_cd4
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_cd4
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_cd4
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_cd4
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_cd4
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_cd4
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_cd4
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_cd4
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_cd4
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_cd4
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_cd4
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_cd4
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 2
         call prc_abort
      end if
      if ( jhalo < 2 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 2
         call prc_abort
      end if
 
 
    case( "UD5" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud5 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_ud5
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_ud5
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_ud5
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_ud5
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_ud5
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_ud5
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_ud5
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_ud5
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_ud5
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_ud5
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_ud5
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_ud5
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_ud5
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_ud5
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_ud5
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_ud5
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_ud5
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_ud5
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 3
         call prc_abort
      end if
      if ( jhalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 3
         call prc_abort
      end if
 
 
    case( "CD6" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd6 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_cd6
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_cd6
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_cd6
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_cd6
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_cd6
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_cd6
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_cd6
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_cd6
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_cd6
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_cd6
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_cd6
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_cd6
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_cd6
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_cd6
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_cd6
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_cd6
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_cd6
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_cd6
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 3
         call prc_abort
      end if
      if ( jhalo < 3 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 3
         call prc_abort
      end if
 
 
    case( "UD7" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the ud7 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_ud7
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_ud7
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_ud7
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_ud7
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_ud7
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_ud7
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_ud7
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_ud7
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_ud7
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_ud7
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_ud7
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_ud7
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_ud7
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_ud7
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_ud7
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_ud7
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_ud7
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_ud7
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 4
         call prc_abort
      end if
      if ( jhalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 4
         call prc_abort
      end if
 
 
    case( "CD8" )
      log_info("ATMOS_DYN_FVM_flux_setup",*) 'the cd8 scheme is used for flux calculation of tracer'
 
      atmos_dyn_fvm_fluxz_xyz_tracer => atmos_dyn_fvm_fluxz_xyz_cd8
 
      atmos_dyn_fvm_fluxx_xyz_tracer => atmos_dyn_fvm_fluxx_xyz_cd8
 
      atmos_dyn_fvm_fluxy_xyz_tracer => atmos_dyn_fvm_fluxy_xyz_cd8
 
      atmos_dyn_fvm_fluxz_xyw_tracer => atmos_dyn_fvm_fluxz_xyw_cd8
 
      atmos_dyn_fvm_fluxx_xyw_tracer => atmos_dyn_fvm_fluxx_xyw_cd8
 
      atmos_dyn_fvm_fluxy_xyw_tracer => atmos_dyn_fvm_fluxy_xyw_cd8
 
      atmos_dyn_fvm_fluxj13_xyw_tracer => atmos_dyn_fvm_fluxj13_xyw_cd8
 
      atmos_dyn_fvm_fluxj23_xyw_tracer => atmos_dyn_fvm_fluxj23_xyw_cd8
 
      atmos_dyn_fvm_fluxz_uyz_tracer => atmos_dyn_fvm_fluxz_uyz_cd8
 
      atmos_dyn_fvm_fluxx_uyz_tracer => atmos_dyn_fvm_fluxx_uyz_cd8
 
      atmos_dyn_fvm_fluxy_uyz_tracer => atmos_dyn_fvm_fluxy_uyz_cd8
 
      atmos_dyn_fvm_fluxj13_uyz_tracer => atmos_dyn_fvm_fluxj13_uyz_cd8
 
      atmos_dyn_fvm_fluxj23_uyz_tracer => atmos_dyn_fvm_fluxj23_uyz_cd8
 
      atmos_dyn_fvm_fluxz_xvz_tracer => atmos_dyn_fvm_fluxz_xvz_cd8
 
      atmos_dyn_fvm_fluxx_xvz_tracer => atmos_dyn_fvm_fluxx_xvz_cd8
 
      atmos_dyn_fvm_fluxy_xvz_tracer => atmos_dyn_fvm_fluxy_xvz_cd8
 
      atmos_dyn_fvm_fluxj13_xvz_tracer => atmos_dyn_fvm_fluxj13_xvz_cd8
 
      atmos_dyn_fvm_fluxj23_xvz_tracer => atmos_dyn_fvm_fluxj23_xvz_cd8
 
 
 
      if ( ( .not. prc_twod ) .and. ihalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'IHALO must be >= ', 4
         call prc_abort
      end if
      if ( jhalo < 4 ) then
         log_error("ATMOS_DYN_FVM_flux_setup",*) 'JHALO must be >= ', 4
         call prc_abort
      end if
 
 
    case default
       log_error("ATMOS_DYN_FVM_flux_setup",*) 'scheme is invalid: ', scheme_tracer
       call prc_abort
    end select
 
  end subroutine atmos_dyn_fvm_flux_setup
 
end module scale_atmos_dyn_fvm_flux
 
!--
! vi:set readonly sw=4 ts=8
!
!Local Variables:
!mode: f90
!buffer-read-only: t
!End:
!
!++