scale_atmos_dyn_fvm_flux.F90

Go to the documentation of this file.

!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
module scale_atmos_dyn_fvm_flux
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
  use scale_stdio
  use scale_prof
  use scale_grid_index
  use scale_index
  use scale_tracer
  use scale_process
#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_grid_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_grid_index
       implicit none
       real(RP), intent(out) :: 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, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_grid_index
       implicit none
       real(RP), intent(out) :: 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)
       integer,  intent(in)  :: iis, iie, jjs, jje
     end subroutine flux_mom
     subroutine flux_z( &
          flux, &
          mom, val, DENS, &
          GSQRT, J33G, &
          num_diff, &
          CDZ, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_grid_index
       implicit none
       real(RP), intent(out) :: 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)
       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_grid_index
       implicit none
       real(RP), intent(out) :: 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, &
          IIS, IIE, JJS, JJE )
       use scale_precision
       use scale_grid_index
       implicit none
       real(RP), intent(out) :: 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)
       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_process, only: &
         prc_mpistop

   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

    implicit none
    character(len=*), intent(in) :: scheme
    character(len=*), intent(in) :: scheme_tracer

    select case ( scheme )

    case ( "CD2" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "UD3" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "UD3KOREN1993" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "CD4" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "UD5" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 3 ) then
         write(*,*) 'xxx IHALO must be >= ', 3
         call prc_mpistop
      end if
      if ( jhalo < 3 ) then
         write(*,*) 'xxx JHALO must be >= ', 3
         call prc_mpistop
      end if


    case ( "CD6" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 3 ) then
         write(*,*) 'xxx IHALO must be >= ', 3
         call prc_mpistop
      end if
      if ( jhalo < 3 ) then
         write(*,*) 'xxx JHALO must be >= ', 3
         call prc_mpistop
      end if


    case default
       write(*,*) 'xxx scheme is invalid: ', scheme
       call prc_mpistop
    end select

    select case ( scheme_tracer )

    case ( "CD2" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "UD3" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "UD3KOREN1993" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "CD4" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 2 ) then
         write(*,*) 'xxx IHALO must be >= ', 2
         call prc_mpistop
      end if
      if ( jhalo < 2 ) then
         write(*,*) 'xxx JHALO must be >= ', 2
         call prc_mpistop
      end if


    case ( "UD5" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 3 ) then
         write(*,*) 'xxx IHALO must be >= ', 3
         call prc_mpistop
      end if
      if ( jhalo < 3 ) then
         write(*,*) 'xxx JHALO must be >= ', 3
         call prc_mpistop
      end if


    case ( "CD6" )
      if( io_l ) write(io_fid_log,*) '*** 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 ( ihalo < 3 ) then
         write(*,*) 'xxx IHALO must be >= ', 3
         call prc_mpistop
      end if
      if ( jhalo < 3 ) then
         write(*,*) 'xxx JHALO must be >= ', 3
         call prc_mpistop
      end if


    case default
       write(*,*) 'xxx scheme is invalid: ', scheme_tracer
       call prc_mpistop
    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:
!
!++