mod_realinput_wrfarw Module Reference

module REAL input WRF-ARW More...

Functions/Subroutines
subroutine, public	parentatomsetupwrfarw (dims, timelen, basename_org)
	Atmos Setup. More...
subroutine, public	parentatomopenwrfarw
subroutine, public	parentatominputwrfarw (velz_org, llvelx_org, llvely_org, pres_org, temp_org, qtrc_org, lon_org, lat_org, cz_org, basename, mptype_parent, dims, it)
subroutine, public	parentlandsetupwrfarw (ldims, basename_land)
	Land Setup. More...
subroutine, public	parentlandinputwrfarw (tg_org, sh2o_org, lst_org, ust_org, albg_org, topo_org, lmask_org, llon_org, llat_org, lz_org, basename, ldims, use_file_landwater, it)
subroutine, public	parentoceansetupwrfarw (odims, timelen, basename_org)
	Ocean Setup. More...
subroutine, public	parentoceanopenwrfarw
subroutine, public	parentoceaninputwrfarw (tw_org, sst_org, albw_org, z0w_org, omask_org, olon_org, olat_org, basename, odims, it)
subroutine	wrf_arwpost_calc_uvmet (u_latlon, v_latlon, u_on_map, v_on_map, xlon, xlat, basename, K1, I1, J1)
	convert vector varibles from map-projected grid on wrf model to lat-lon grid More...

Detailed Description

module REAL input WRF-ARW

Description

read data from WRF-ARW file for real atmospheric simulations

Author

Team SCALE

History

• 2015-05-24 (S.Nishizawa) [new] split from mod_realinput.f90

NAMELIST

• PARAM_MKINIT_REAL_WRFARW

  name	type	default value	comment
  WRF_FILE_TYPE	logical	.false.	wrf filetype: T=wrfout, F=wrfrst

  
  

History Output

No history output

Function/Subroutine Documentation

parentatomsetupwrfarw()

subroutine, public mod_realinput_wrfarw::parentatomsetupwrfarw	(	integer, dimension(6), intent(out)	dims,
		integer, intent(out)	timelen,
		character(len=h_long), intent(in)	basename_org
	)

Atmos Setup.

Definition at line 92 of file mod_realinput_wrfarw.f90.

References scale_external_io::externalfilegetshape(), scale_stdio::io_fid_conf, scale_stdio::io_fid_log, scale_stdio::io_l, scale_stdio::io_lnml, scale_external_io::iwrfarw, and scale_process::prc_mpistop().

Referenced by mod_realinput::parentatomsetup().

    use scale_external_io, only: &
         iwrfarw, &
         externalfilegetshape
    implicit none

    integer,               intent(out) :: dims(6)
    integer,               intent(out) :: timelen
    character(len=H_LONG), intent(in) :: basename_org

    logical :: wrf_file_type = .false.   ! wrf filetype: T=wrfout, F=wrfrst

    namelist / param_mkinit_real_wrfarw / &
         wrf_file_type

    integer :: dims_wrf(7)
    integer :: ierr
    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*) '+++ Real Case/Atom Input File Type: WRF-ARW'

    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_mkinit_real_wrfarw,iostat=ierr)
    if( ierr > 0 ) then
       write(*,*) 'xxx Not appropriate names in namelist PARAM_MKINIT_REAL_WRFARW. Check!'
       call prc_mpistop
    endif
    if( io_lnml ) write(io_fid_log,nml=param_mkinit_real_wrfarw)

    call externalfilegetshape( dims_wrf, timelen, mdlid, basename_org, myrank, single=.true. )
    dims(1:6) = dims_wrf(1:6)

    if ( wrf_file_type ) then
       wrfout = .true.
       if( io_l ) write(io_fid_log,*) '+++ WRF-ARW FILE-TYPE: WRF History Output'
    else
       wrfout = .false.
       if( io_l ) write(io_fid_log,*) '+++ WRF-ARW FILE-TYPE: WRF Restart'
    endif


    allocate( read_xy(        dims(2),dims(3),1) )
    allocate( read_uy(        dims(5),dims(3),1) )
    allocate( read_xv(        dims(2),dims(6),1) )
    allocate( read_zxy(dims(1),dims(2),dims(3),1) )
    allocate( read_wxy(dims(4),dims(2),dims(3),1) )
    allocate( read_zuy(dims(1),dims(5),dims(3),1) )
    allocate( read_zxv(dims(1),dims(2),dims(6),1) )

    allocate( p_org(dims(1),dims(2),dims(3)) )
    allocate( pb_org(dims(1),dims(2),dims(3)) )
    allocate( ph_org(dims(4),dims(2),dims(3)) )
    allocate( phb_org(dims(4),dims(2),dims(3)) )

    return

Here is the call graph for this function:

Here is the caller graph for this function:

parentatomopenwrfarw()

subroutine, public mod_realinput_wrfarw::parentatomopenwrfarw

(

)

Definition at line 151 of file mod_realinput_wrfarw.f90.

References scale_stdio::io_fid_log, and scale_stdio::io_l.

Referenced by mod_realinput::parentatomsetup().

    implicit none

    if( io_l ) write(io_fid_log,*) '+++ ScaleLib/IO[realinput]/Categ[AtomOpenWRFARW]'
    return

Here is the caller graph for this function:

parentatominputwrfarw()

subroutine, public mod_realinput_wrfarw::parentatominputwrfarw	(	real(rp), dimension(:,:,:), intent(out)	velz_org,
		real(rp), dimension(:,:,:), intent(out)	llvelx_org,
		real(rp), dimension(:,:,:), intent(out)	llvely_org,
		real(rp), dimension(:,:,:), intent(out)	pres_org,
		real(rp), dimension(:,:,:), intent(out)	temp_org,
		real(rp), dimension(:,:,:,:), intent(out)	qtrc_org,
		real(rp), dimension(:,:), intent(out)	lon_org,
		real(rp), dimension(:,:), intent(out)	lat_org,
		real(rp), dimension(:,:,:), intent(out)	cz_org,
		character(len=*), intent(in)	basename,
		integer, intent(in)	mptype_parent,
		integer, dimension(6), intent(in)	dims,
		integer, intent(in)	it
	)

Definition at line 172 of file mod_realinput_wrfarw.f90.

References scale_const::const_d2r, scale_const::const_grav, scale_const::const_laps, scale_tracer::i_nc, scale_tracer::i_ng, scale_tracer::i_ni, scale_tracer::i_nr, scale_tracer::i_ns, scale_tracer::i_qc, scale_tracer::i_qg, scale_tracer::i_qi, scale_tracer::i_qr, scale_tracer::i_qs, scale_tracer::i_qv, scale_stdio::io_fid_log, scale_stdio::io_l, scale_tracer::qa, and wrf_arwpost_calc_uvmet().

Referenced by mod_realinput::parentatomsetup().

    use scale_const, only: &
         d2r => const_d2r, &
         laps => const_laps, &
         grav => const_grav
    use scale_external_io, only: &
         externalfileread
    use scale_atmos_thermodyn, only: &
         thermodyn_pott => atmos_thermodyn_pott
    implicit none
    real(RP),         intent(out) :: velz_org(:,:,:)
    real(RP),         intent(out) :: llvelx_org(:,:,:)
    real(RP),         intent(out) :: llvely_org(:,:,:)
    real(RP),         intent(out) :: pres_org(:,:,:)
    real(RP),         intent(out) :: temp_org(:,:,:)
    real(RP),         intent(out) :: qtrc_org(:,:,:,:)
    real(RP),         intent(out) :: lon_org(:,:)
    real(RP),         intent(out) :: lat_org(:,:)
    real(RP),         intent(out) :: cz_org(:,:,:)
    character(len=*), intent(in)  :: basename
    integer,          intent(in)  :: mptype_parent
    integer,          intent(in)  :: dims(6)
    integer,          intent(in)  :: it

    ! full level
    real(RP) :: velx_org(dims(1)+2,dims(2),dims(3))
    real(RP) :: vely_org(dims(1)+2,dims(2),dims(3))
    real(RP) :: pott_org(dims(1)+2,dims(2),dims(3))
    real(RP) :: topo_org(          dims(2),dims(3))

    ! half level
    real(RP) :: velzs_org(dims(4),dims(2),dims(3))
    real(RP) :: velxs_org(dims(1),dims(5),dims(3))
    real(RP) :: velys_org(dims(1),dims(2),dims(6))
    real(RP) :: geof_org (dims(4),dims(2),dims(3))

    real(RP) :: qhyd

    integer :: k, i, j, iq

    character(len=H_MID) :: varname_t
    character(len=H_MID) :: varname_w
    character(len=H_MID) :: varname_u
    character(len=H_MID) :: varname_v

    logical :: lack_of_val

    integer :: ierr
    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*) '+++ ScaleLib/IO[realinput]/Categ[InputWRF]'

    if ( wrfout ) then
       varname_t = "T"
       varname_w = "W"
       varname_u = "U"
       varname_v = "V"
    else
       varname_t = "T_1"
       varname_w = "W_1"
       varname_u = "U_1"
       varname_v = "V_1"
    endif


    call externalfileread( read_xy(:,:,:),    basename, "XLAT",    it, it, myrank, mdlid, single=.true.               )
    lat_org(:,:) = real( read_xy(:,:,1), kind=RP ) * d2r

    call externalfileread( read_xy(:,:,:),    basename, "XLONG",   it, it, myrank, mdlid, single=.true.               )
    lon_org(:,:) = real( read_xy(:,:,1), kind=RP ) * d2r

    call externalfileread( read_xy(:,:,:),    basename, "HGT",     it, it, myrank, mdlid, single=.true.               )
    topo_org(:,:) = real( read_xy(:,:,1), kind=rp )

    call externalfileread( read_wxy(:,:,:,:), basename, "PH",      it, it, myrank, mdlid, single=.true., zstag=.true. )
    ph_org(:,:,:) = real( read_wxy(:,:,:,1), kind=rp )

    call externalfileread( read_wxy(:,:,:,:), basename, "PHB",     it, it, myrank, mdlid, single=.true., zstag=.true. )
    phb_org(:,:,:) = real( read_wxy(:,:,:,1), kind=rp )

    call externalfileread( read_zxy(:,:,:,:), basename, "P",       it, it, myrank, mdlid, single=.true.               )
    p_org(:,:,:) = real( read_zxy(:,:,:,1), kind=rp )

    call externalfileread( read_zxy(:,:,:,:), basename, "PB",      it, it, myrank, mdlid, single=.true.               )
    pb_org(:,:,:) = real( read_zxy(:,:,:,1), kind=rp )

    call externalfileread( read_wxy(:,:,:,:), basename, varname_w, it, it, myrank, mdlid, single=.true., zstag=.true. )
    velzs_org(:,:,:) = real( read_wxy(:,:,:,1), kind=rp )

    call externalfileread( read_zuy(:,:,:,:), basename, varname_u, it, it, myrank, mdlid, single=.true., xstag=.true. )

    velxs_org(:,:,:) = real( read_zuy(:,:,:,1), kind=rp )

    call externalfileread( read_zxv(:,:,:,:), basename, varname_v, it, it, myrank, mdlid, single=.true., ystag=.true. )
    velys_org(:,:,:) = real( read_zxv(:,:,:,1), kind=rp )

    ! from half level to full level
    do j = 1, dims(3)
    do i = 1, dims(2)
       do k = 1, dims(1)
          velz_org(k+2,i,j) = ( velzs_org(k,i,j) + velzs_org(k+1,i,j) ) * 0.5_rp
          velx_org(k+2,i,j) = ( velxs_org(k,i,j) + velxs_org(k,i+1,j) ) * 0.5_rp
          vely_org(k+2,i,j) = ( velys_org(k,i,j) + velys_org(k,i,j+1) ) * 0.5_rp
       end do
       velz_org(1:2,i,j) = 0.0_rp
       velx_org(1:2,i,j) = 0.0_rp
       vely_org(1:2,i,j) = 0.0_rp
    end do
    end do

    call wrf_arwpost_calc_uvmet( llvelx_org, llvely_org, & ! (out)
                                 velx_org, vely_org,     & ! (in)
                                 lon_org, lat_org,       & ! (in)
                                 basename,               & ! (in)
                                 dims(1)+2, dims(2), dims(3) ) ! (in)

    qtrc_org(:,:,:,:) = 0.0_rp
    call externalfileread( read_xy(:,:,:),    basename, "Q2",      it, it, myrank, mdlid, single=.true.               )
    qtrc_org(2,:,:,i_qv) = real(read_xy(:,:,1),kind=rp)
    qtrc_org(1,:,:,i_qv) = qtrc_org(2,:,:,i_qv)

    call externalfileread( read_zxy(:,:,:,:), basename, "QVAPOR",  it, it, myrank, mdlid, single=.true. )
    qtrc_org(3:,:,:,i_qv) = real(read_zxy(:,:,:,1),kind=rp)

#ifndef DRY
    if( mptype_parent > 0 ) then
       call externalfileread( read_zxy(:,:,:,:), basename, "QCLOUD", it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_qc) = real( read_zxy(:,:,:,1), kind=rp)

       call externalfileread( read_zxy(:,:,:,:), basename, "QRAIN",  it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_qr) = real( read_zxy(:,:,:,1), kind=rp)
    endif

    if( mptype_parent > 3 ) then
       call externalfileread( read_zxy(:,:,:,:), basename, "QICE",   it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_qi) = real( read_zxy(:,:,:,1), kind=rp)

       call externalfileread( read_zxy(:,:,:,:), basename, "QSNOW",  it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_qs) = real( read_zxy(:,:,:,1), kind=rp)
    endif

    if( mptype_parent > 5 ) then
       call externalfileread( read_zxy(:,:,:,:), basename, "QGRAUP", it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_qg) = real( read_zxy(:,:,:,1), kind=rp)
    endif

    ! convert mixing ratio to specific ratio
    do j = 1, dims(3)
    do i = 1, dims(2)
    do k = 1, dims(1)+2
       qhyd = 0.0_rp
       do iq = 1, min( mptype_parent, 6)
          qhyd = qhyd + qtrc_org(k,i,j,iq)
       end do
       do iq = 1, min( mptype_parent, 6)
          qtrc_org(k,i,j,iq) = qtrc_org(k,i,j,iq) / ( 1.0_rp + qhyd )
       end do
    end do
    end do
    end do

    if( mptype_parent > 6 ) then
       call externalfileread( read_zxy(:,:,:,:), basename, "NC",     it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_nc) = real( read_zxy(:,:,:,1), kind=rp )

       call externalfileread( read_zxy(:,:,:,:), basename, "NR",     it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_nr) = real( read_zxy(:,:,:,1), kind=rp )

       call externalfileread( read_zxy(:,:,:,:), basename, "NI",     it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_ni) = real( read_zxy(:,:,:,1), kind=rp )

       call externalfileread( read_zxy(:,:,:,:), basename, "NS",     it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_ns) = real( read_zxy(:,:,:,1), kind=rp )

       call externalfileread( read_zxy(:,:,:,:), basename, "NG",     it, it, myrank, mdlid, single=.true. )
       qtrc_org(3:,:,:,i_ng) = real( read_zxy(:,:,:,1), kind=rp )
    endif
#endif

    do iq = 1, qa
    do j = 1, dims(3)
    do i = 1, dims(2)
    do k = 1, dims(1)+2
       qtrc_org(k,i,j,iq) = max( qtrc_org(k,i,j,iq), 0.0_rp )
    end do
    end do
    end do
    end do


    call externalfileread( read_zxy(:,:,:,:), basename, varname_t, it, it, myrank, mdlid, single=.true.               )
    pott_org(3:,:,:) = real( read_zxy(:,:,:,1), kind=RP ) + t0
    call externalfileread( read_xy(:,:,:),    basename, "T2",      it, it, myrank, mdlid, single=.true.               )
    temp_org(2,:,:) = real( read_xy(:,:,1), kind=rp )

    call externalfileread( read_xy(:,:,:),    basename, "PSFC",    it, it, myrank, mdlid, single=.true.               )
    pres_org(2,:,:) = real( read_xy(:,:,1), kind=rp )

    do j = 1, dims(3)
    do i = 1, dims(2)
       do k = 3, dims(1)+2
          pres_org(k,i,j) = p_org(k-2,i,j) + pb_org(k-2,i,j)
          temp_org(k,i,j) = pott_org(k,i,j) * ( pres_org(k,i,j) / p0 )**rcp
       end do
       pott_org(2,i,j) = temp_org(2,i,j) * ( p0/pres_org(2,i,j) )**rcp
       temp_org(1,i,j) = temp_org(2,i,j) + laps * topo_org(i,j)
       pres_org(1,i,j) = p0 * ( temp_org(1,i,j) / pott_org(2,i,j) )**(1.0_rp/rcp) ! pott_org(1,i,j) == pott_org(2,i,j)
    end do
    end do

    do j = 1, dims(3)
    do i = 1, dims(2)
       ! convert to geopotential height to use as real height in WRF
       do k = 1, dims(4)
          geof_org(k,i,j) = ( ph_org(k,i,j) + phb_org(k,i,j) ) / grav
       end do
       ! make half level of geopotential height from face level
       do k = 1, dims(1)
          cz_org(k+2,i,j) = ( geof_org(k,i,j) + geof_org(k+1,i,j) ) * 0.5_rp
       end do
       cz_org(2,i,j) = topo_org(i,j)
       cz_org(1,i,j) = 0.0_rp
    end do
    end do


#ifdef DEBUG
     !k=1 ; i=int(dims(2)/2) ; j=int(dims(3)/2) ; iq = 1
     k=2 ; i=3 ; j=3 ; iq = 1
     write(*,*) "read 3D wrf data",i,j,k
     write(*,*) "lon_org    ",lon_org(i,j)/d2r
     write(*,*) "lat_org    ",lat_org(i,j)/d2r
     write(*,*) "cz_org     ",cz_org(k,i,j)
     write(*,*) "pres_org   ",pres_org(k,i,j)
     write(*,*) "velx_org   ",llvelx_org(k,i,j)
     write(*,*) "vely_org   ",llvely_org(k,i,j)
     write(*,*) "velz_org   ",velz_org(k,i,j)
     write(*,*) "temp_org   ",temp_org(k,i,j)
     write(*,*) "qtrc_org   ",qtrc_org(k,i,j,iq)
     k=3 ; i=3 ; j=3 ; iq = 1
     write(*,*) "read 3D wrf data",i,j,k
     write(*,*) "lon_org    ",lon_org(i,j)/d2r
     write(*,*) "lat_org    ",lat_org(i,j)/d2r
     write(*,*) "cz_org     ",cz_org(k,i,j)
     write(*,*) "pres_org   ",pres_org(k,i,j)
     write(*,*) "velx_org   ",llvelx_org(k,i,j)
     write(*,*) "vely_org   ",llvely_org(k,i,j)
     write(*,*) "velz_org   ",velz_org(k,i,j)
     write(*,*) "temp_org   ",temp_org(k,i,j)
     write(*,*) "qtrc_org   ",qtrc_org(k,i,j,iq)
#endif

    return

Here is the call graph for this function:

Here is the caller graph for this function:

parentlandsetupwrfarw()

subroutine, public mod_realinput_wrfarw::parentlandsetupwrfarw	(	integer, dimension(3), intent(out)	ldims,
		character(len=h_long), intent(in)	basename_land
	)

Land Setup.

Definition at line 431 of file mod_realinput_wrfarw.f90.

References scale_external_io::externalfilegetshape(), scale_stdio::io_fid_conf, scale_stdio::io_fid_log, scale_stdio::io_l, scale_stdio::io_lnml, scale_external_io::iwrfarw, and scale_process::prc_mpistop().

Referenced by mod_realinput::parentatomsetup().

    use scale_external_io, only: &
         iwrfarw, &
         externalfilegetshape
    implicit none

    integer,               intent(out) :: ldims(3)
    character(len=H_LONG), intent(in) :: basename_land

    logical :: wrf_file_type = .false.   ! wrf filetype: T=wrfout, F=wrfrst

    namelist / param_mkinit_real_wrfarw / &
         wrf_file_type

    integer :: dims_wrf(7)
    integer :: timelen
    integer :: ierr
    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*) '+++ Real Case/Atom Input File Type: WRF-ARW'

    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_mkinit_real_wrfarw,iostat=ierr)
    if( ierr > 0 ) then
       write(*,*) 'xxx Not appropriate names in namelist PARAM_MKINIT_REAL_WRFARW. Check!'
       call prc_mpistop
    endif
    if( io_lnml ) write(io_fid_log,nml=param_mkinit_real_wrfarw)


    call externalfilegetshape( dims_wrf, timelen, mdlid, basename_land, myrank, single=.true. )
    ldims(1) = dims_wrf(7)
    ldims(2) = dims_wrf(2)
    ldims(3) = dims_wrf(3)

    if ( wrf_file_type ) then
       wrfout = .true.
       if( io_l ) write(io_fid_log,*) '+++ WRF-ARW FILE-TYPE: WRF History Output'
    else
       wrfout = .false.
       if( io_l ) write(io_fid_log,*) '+++ WRF-ARW FILE-TYPE: WRF Restart'
    endif


    if ( .not. allocated(read_xy) ) then
       allocate( read_xy(        ldims(2),ldims(3),1) )
    end if

    allocate( read_lzxy(ldims(1),ldims(2),ldims(3),1) )
    allocate( read_lz(ldims(1),1) )

    return

Here is the call graph for this function:

Here is the caller graph for this function:

parentlandinputwrfarw()

subroutine, public mod_realinput_wrfarw::parentlandinputwrfarw	(	real(rp), dimension(:,:,:), intent(out)	tg_org,
		real(rp), dimension(:,:,:), intent(out)	sh2o_org,
		real(rp), dimension(:,:), intent(out)	lst_org,
		real(rp), dimension(:,:), intent(out)	ust_org,
		real(rp), dimension(:,:,:), intent(out)	albg_org,
		real(rp), dimension(:,:), intent(out)	topo_org,
		real(rp), dimension(:,:), intent(out)	lmask_org,
		real(rp), dimension(:,:), intent(out)	llon_org,
		real(rp), dimension(:,:), intent(out)	llat_org,
		real(rp), dimension(:), intent(out)	lz_org,
		character(len=*), intent(in)	basename,
		integer, dimension(3), intent(in)	ldims,
		logical, intent(in)	use_file_landwater,
		integer, intent(in)	it
	)

Definition at line 501 of file mod_realinput_wrfarw.f90.

References scale_const::const_d2r, scale_const::const_i_lw, scale_const::const_i_sw, scale_const::const_undef, scale_external_io::externalfilevarexistence(), scale_stdio::io_fid_log, and scale_stdio::io_l.

Referenced by mod_realinput::parentatomsetup().

    use scale_const, only: &
         d2r => const_d2r, &
         undef => const_undef, &
         i_lw => const_i_lw, &
         i_sw => const_i_sw
    use scale_external_io, only: &
         externalfileread, &
         externalfilevarexistence
    implicit none
    real(RP),         intent(out)  :: tg_org(:,:,:)
    real(RP),         intent(out)  :: sh2o_org(:,:,:)
    real(RP),         intent(out)  :: lst_org(:,:)
    real(RP),         intent(out)  :: ust_org(:,:)
    real(RP),         intent(out)  :: albg_org(:,:,:)
    real(RP),         intent(out)  :: topo_org(:,:)
    real(RP),         intent(out)  :: lmask_org(:,:)
    real(RP),         intent(out)  :: llon_org(:,:)
    real(RP),         intent(out)  :: llat_org(:,:)
    real(RP),         intent(out)  :: lz_org(:)
    character(len=*), intent( in)  :: basename
    integer,          intent( in)  :: ldims(3)
    logical,          intent( in)  :: use_file_landwater   ! use land water data from files
    integer,          intent( in)  :: it


    integer  :: k, i, j

    logical  :: existence

    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*) '+++ ScaleLib/IO[realinput]/Categ[LandInputWRF]'

    call externalfileread( read_xy(:,:,:),    basename, "XLAT",    it, it, myrank, mdlid, single=.true.               )
    llat_org(:,:) = read_xy(:,:,1) * d2r

    call externalfileread( read_xy(:,:,:),    basename, "XLONG",   it, it, myrank, mdlid, single=.true.               )
    llon_org(:,:) = read_xy(:,:,1) * d2r

    call externalfileread( read_xy(:,:,:),    basename, "HGT",     it, it, myrank, mdlid, single=.true.               )
    topo_org(:,:) = read_xy(:,:,1)

    ! depth
    call externalfileread( read_lz(:,:),                               &
                      basename, "ZS",      it, 1, myrank, mdlid, ldims(1), single=.true. )
    lz_org(:) = read_lz(:,1)

    ! land mask (1:land, 0:water)
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "LANDMASK",  it, 1, myrank, mdlid, single=.true. )
    lmask_org(:,:) = read_xy(:,:,1)

    ! soil temperature [K]
    call externalfileread( read_lzxy(:,:,:,:),                             &
                      basename, "TSLB",  it, 1, myrank, mdlid, single=.true., landgrid=.true. )
    tg_org(:,:,:) = read_lzxy(:,:,:,1)

    ! soil liquid water [m3 m-3] (no wrfout-default)
    if( use_file_landwater ) then
       call externalfilevarexistence( existence, basename, "SH2O", myrank, mdlid, single=.true. )
       if ( existence ) then
          call externalfileread( read_lzxy(:,:,:,:),                             &
                         basename, "SH2O", it, 1, myrank, mdlid, single=.true., landgrid=.true.  )
          sh2o_org(:,:,:) = read_lzxy(:,:,:,1)
       else
          sh2o_org(:,:,:) = undef
       endif
    endif

!    ! surface runoff [mm]
!    call ExternalFileRead( read_xy(:,:,:),                             &
!                      BASENAME, "SFROFF",  it, 1, myrank, mdlid, single=.true. )
!       do j = 1, dims(9)
!       do i = 1, dims(8)
!          org_3D(i,j) = read_xy(i,j,1) * 1000.0_DP * dwatr
!       enddo
!       enddo


    ! SURFACE SKIN TEMPERATURE [K]
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "TSK",  it, 1, myrank, mdlid, single=.true. )
    lst_org(:,:) = read_xy(:,:,1)

    ust_org(:,:) = lst_org(:,:)

    ! ALBEDO [-]
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "ALBEDO",  it, 1, myrank, mdlid, single=.true. )
    albg_org(:,:,i_sw) = read_xy(:,:,1)

    ! SURFACE EMISSIVITY [-]
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "EMISS",  it, 1, myrank, mdlid, single=.true. )
    do j = 1, ldims(3)
    do i = 1, ldims(2)
       albg_org(i,j,i_lw) = 1.0_dp - read_xy(i,j,1)
    enddo
    enddo


!    ! SNOW WATER EQUIVALENT [kg m-2] (no wrfout-default)
!    call ExternalFileVarExistence( existence, BASENAME, "SNOW", myrank, mdlid, single=.true. )
!    if ( existence ) then
!       call ExternalFileRead( read_xy(:,:,:),                             &
!                         BASENAME, "SNOW",  it, 1, myrank, mdlid, single=.true. )
!       swowq_org(:,:,:) = read_xy(:,:,1)
!    else
!       snowq_org(:,:) = UNDEF
!    endif

!    ! AVERAGE SNOW TEMPERATURE [C] (no wrfout-default)
!    call ExternalFileVarExistence( existence, BASENAME, "TSNAV", myrank, mdlid, single=.true. )
!    if ( existence ) then
!       call ExternalFileRead( read_xy(:,:,:),                             &
!                         BASENAME, "TSNAV",  it, 1, myrank, mdlid, single=.true. )
!       do j = 1, dims(9)
!       do i = 1, dims(8)
!          snowt_org(i,j,n) = read_xy(i,j,1) + TEM00
!       enddo
!       enddo
!    else
!       snowt_org(:,:) = UNDEFF
!    endif

    return

Here is the call graph for this function:

Here is the caller graph for this function:

parentoceansetupwrfarw()

subroutine, public mod_realinput_wrfarw::parentoceansetupwrfarw	(	integer, dimension(2), intent(out)	odims,
		integer, intent(out)	timelen,
		character(len=h_long), intent(in)	basename_org
	)

Ocean Setup.

Definition at line 635 of file mod_realinput_wrfarw.f90.

References scale_external_io::externalfilegetshape(), scale_stdio::io_fid_conf, scale_stdio::io_fid_log, scale_stdio::io_l, scale_stdio::io_lnml, scale_external_io::iwrfarw, and scale_process::prc_mpistop().

Referenced by mod_realinput::parentatomsetup().

    use scale_external_io, only: &
         iwrfarw, &
         externalfilegetshape
    implicit none

    integer,               intent(out) :: odims(2)
    integer,               intent(out) :: timelen
    character(len=H_LONG), intent(in) :: basename_org

    logical :: wrf_file_type = .false.   ! wrf filetype: T=wrfout, F=wrfrst

    namelist / param_mkinit_real_wrfarw / &
         wrf_file_type

    integer :: dims_wrf(7)
    integer :: ierr
    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*) '+++ Real Case/Ocean Input File Type: WRF-ARW'

    !--- read namelist
    rewind(io_fid_conf)
    read(io_fid_conf,nml=param_mkinit_real_wrfarw,iostat=ierr)
    if( ierr > 0 ) then
       write(*,*) 'xxx Not appropriate names in namelist PARAM_MKINIT_REAL_WRFARW. Check!'
       call prc_mpistop
    endif
    if( io_lnml ) write(io_fid_log,nml=param_mkinit_real_wrfarw)


    call externalfilegetshape( dims_wrf, timelen, mdlid, basename_org, myrank, single=.true. )
    odims(1) = dims_wrf(2)
    odims(2) = dims_wrf(3)

    if ( wrf_file_type ) then
       wrfout = .true.
       if( io_l ) write(io_fid_log,*) '+++ WRF-ARW FILE-TYPE: WRF History Output'
    else
       wrfout = .false.
       if( io_l ) write(io_fid_log,*) '+++ WRF-ARW FILE-TYPE: WRF Restart'
    endif


    if ( .not. allocated(read_xy) ) then
       allocate( read_xy(        odims(1),odims(2),1) )
    end if

    return

Here is the call graph for this function:

Here is the caller graph for this function:

parentoceanopenwrfarw()

subroutine, public mod_realinput_wrfarw::parentoceanopenwrfarw

(

)

Definition at line 687 of file mod_realinput_wrfarw.f90.

References scale_stdio::io_fid_log, and scale_stdio::io_l.

Referenced by mod_realinput::parentatomsetup().

    implicit none

    if( io_l ) write(io_fid_log,*) '+++ ScaleLib/IO[realinput]/Categ[OceanOpenWRFARW]'
    return

Here is the caller graph for this function:

parentoceaninputwrfarw()

subroutine, public mod_realinput_wrfarw::parentoceaninputwrfarw	(	real(rp), dimension(:,:), intent(out)	tw_org,
		real(rp), dimension(:,:), intent(out)	sst_org,
		real(rp), dimension(:,:,:), intent(out)	albw_org,
		real(rp), dimension(:,:), intent(out)	z0w_org,
		real(rp), dimension(:,:), intent(out)	omask_org,
		real(rp), dimension(:,:), intent(out)	olon_org,
		real(rp), dimension(:,:), intent(out)	olat_org,
		character(len=*), intent(in)	basename,
		integer, dimension(2), intent(in)	odims,
		integer, intent(in)	it
	)

Definition at line 705 of file mod_realinput_wrfarw.f90.

References scale_const::const_d2r, scale_const::const_i_lw, scale_const::const_i_sw, scale_const::const_undef, scale_external_io::externalfilevarexistence(), scale_stdio::io_fid_log, and scale_stdio::io_l.

Referenced by mod_realinput::parentatomsetup().

    use scale_const, only: &
         d2r => const_d2r, &
         undef => const_undef, &
         i_lw => const_i_lw, &
         i_sw => const_i_sw
    use scale_external_io, only: &
         externalfileread, &
         externalfilevarexistence
    implicit none
    real(RP),         intent(out)  :: tw_org(:,:)
    real(RP),         intent(out)  :: sst_org(:,:)
    real(RP),         intent(out)  :: albw_org(:,:,:)
    real(RP),         intent(out)  :: z0w_org(:,:)
    real(RP),         intent(out)  :: omask_org(:,:)
    real(RP),         intent(out)  :: olon_org(:,:)
    real(RP),         intent(out)  :: olat_org(:,:)
    character(len=*), intent( in)  :: basename
    integer,          intent( in)  :: odims(2)
    integer,          intent( in)  :: it


    integer  :: i, j

    logical  :: existence

    !---------------------------------------------------------------------------

    if( io_l ) write(io_fid_log,*) '+++ ScaleLib/IO[realinput]/Categ[OceanInputWRF]'

    call externalfileread( read_xy(:,:,:),    basename, "XLAT",    it, it, myrank, mdlid, single=.true.               )
    olat_org(:,:) = read_xy(:,:,1) * d2r

    call externalfileread( read_xy(:,:,:),    basename, "XLONG",   it, it, myrank, mdlid, single=.true.               )
    olon_org(:,:) = read_xy(:,:,1) * d2r

    ! land mask (1:land, 0:water)
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "LANDMASK",  it, 1, myrank, mdlid, single=.true. )
    omask_org(:,:) = read_xy(:,:,1)

    ! SEA SURFACE TEMPERATURE [K]
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "SST",  it, 1, myrank, mdlid, single=.true. )
    sst_org(:,:) = read_xy(:,:,1)

    tw_org(:,:) = sst_org(:,:)

    ! ALBEDO [-]
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "ALBEDO",  it, 1, myrank, mdlid, single=.true. )
    albw_org(:,:,i_sw) = read_xy(:,:,1)

    ! SURFACE EMISSIVITY [-]
    call externalfileread( read_xy(:,:,:),                             &
                      basename, "EMISS",  it, 1, myrank, mdlid, single=.true. )
    do j = 1, odims(2)
    do i = 1, odims(1)
       albw_org(i,j,i_lw) = 1.0_dp - read_xy(i,j,1)
    enddo
    enddo

    ! TIME-VARYING ROUGHNESS LENGTH [m] (no wrfout-default)
    call externalfilevarexistence( existence, basename, "ZNT", myrank, mdlid, single=.true. )
    if ( existence ) then
       call externalfileread( read_xy(:,:,:),                             &
                         basename, "ZNT",  it, 1, myrank, mdlid, single=.true. )
       z0w_org(:,:) = read_xy(:,:,1)
    else
       z0w_org(:,:) = undef
    endif

    return

Here is the call graph for this function:

Here is the caller graph for this function:

wrf_arwpost_calc_uvmet()

subroutine mod_realinput_wrfarw::wrf_arwpost_calc_uvmet	(	real(rp), dimension(:,:,:), intent(out)	u_latlon,
		real(rp), dimension(:,:,:), intent(out)	v_latlon,
		real(rp), dimension(:,:,:), intent(in)	u_on_map,
		real(rp), dimension(:,:,:), intent(in)	v_on_map,
		real(rp), dimension(:,:), intent(in)	xlon,
		real(rp), dimension(:,:), intent(in)	xlat,
		character(len=*), intent(in)	basename,
		integer, intent(in)	K1,
		integer, intent(in)	I1,
		integer, intent(in)	J1
	)

convert vector varibles from map-projected grid on wrf model to lat-lon grid

Definition at line 791 of file mod_realinput_wrfarw.f90.

References scale_const::const_d2r, scale_const::const_pi, and dc_log::log().

Referenced by parentatominputwrfarw().

    use scale_const, only: &
       d2r => const_d2r, &
       pi => const_pi
    use scale_external_io, only: &
         externalfilegetglobalattv
    implicit none
    real(RP), intent(out) :: u_latlon(:,:,:)
    real(RP), intent(out) :: v_latlon(:,:,:)
    real(RP), intent(in ) :: u_on_map(:,:,:)
    real(RP), intent(in ) :: v_on_map(:,:,:)
    real(RP), intent(in ) :: xlon(:,:)
    real(RP), intent(in ) :: xlat(:,:)
    integer , intent(in ) :: k1, i1, j1

    character(len=*), intent( in) :: basename

    real(RP) :: truelat1, truelat2
    real(RP) :: stand_lon
    real(RP) :: diff
    real(RP) :: alpha
    real(RP) :: sine(i1,j1)
    real(RP) :: cose(i1,j1)
    real(RP) :: cone
    integer  :: map_proj

    real(RP) :: dum_r(1)
    integer  :: dum_i(1)


    integer  :: k, i, j
    !---------------------------------------------------------------------------

    call externalfilegetglobalattv( dum_i, iwrfarw, basename, "MAP_PROJ",  myrank, single=.true. )
    map_proj = dum_i(1)
    call externalfilegetglobalattv( dum_r, iwrfarw, basename, "TRUELAT1",  myrank, single=.true. )
    truelat1 = dum_r(1) * d2r
    call externalfilegetglobalattv( dum_r, iwrfarw, basename, "TRUELAT2",  myrank, single=.true. )
    truelat2 = dum_r(1) * d2r
    call externalfilegetglobalattv( dum_r, iwrfarw, basename, "STAND_LON", myrank, single=.true. )
    stand_lon = dum_r(1) * d2r

    ! No need to rotate
    if ( map_proj .ge. 3 ) then
       u_latlon(:,:,:) = u_on_map(:,:,:)
       v_latlon(:,:,:) = v_on_map(:,:,:)

       return
    endif

    ! Lambert Conformal mapping
    cone = 1.0_rp         !  PS
    if ( map_proj .eq. 1 ) then
       if ( abs(truelat1-truelat2) .gt. 0.1_rp*d2r ) then
          cone = ( log(cos(truelat1)) -                 &
                   log(cos(truelat2)) )  /              &
                 ( log(tan((pi*0.5_rp-abs(truelat1))*0.5_rp )) - &
                   log(tan((pi*0.5_rp-abs(truelat2))*0.5_rp )) )
       else
          cone = sin( abs(truelat1) )
       endif
    endif

    do j = 1, j1
    do i = 1, i1
       diff = xlon(i,j) - stand_lon
       if ( diff .gt. pi ) then
          diff = diff - pi*2.0_rp
       endif
       if ( diff .lt. -pi ) then
          diff = diff + pi*2.0_rp
       endif
       alpha = diff * cone * sign(1.0_rp, xlat(i,j))
       sine(i,j) = sin( alpha )
       cose(i,j) = cos( alpha )
    enddo
    enddo

    do j = 1, j1
    do i = 1, i1
    do k = 1, k1
       u_latlon(k,i,j) = v_on_map(k,i,j)*sine(i,j) + u_on_map(k,i,j)*cose(i,j)
       v_latlon(k,i,j) = v_on_map(k,i,j)*cose(i,j) - u_on_map(k,i,j)*sine(i,j)
    enddo
    enddo
    enddo

    return

Here is the call graph for this function:

Here is the caller graph for this function: