module Map projection More...

Data Types
interface	lonlat2xy_s

interface	mapfactor_s

type	mappinginfo

type	mappingparam

interface	rotcoef_s

Functions/Subroutines
subroutine, public	mapprojection_setup (DOMAIN_CENTER_X, DOMAIN_CENTER_Y)
	Setup. More...

subroutine, public	mapprojection_get_param (info, param)

subroutine	mapprojection_xy2lonlat_0d_initialized (x, y, lon, lat)
	(x,y) -> (lon,lat) More...

subroutine	mapprojection_xy2lonlat_2d_param (IA, IS, IE, JA, JS, JE, x, y, mapping_name, mapping_param, lon, lat)

subroutine	mapprojection_lonlat2xy_0d_initialized (lon, lat, x, y)
	(lon,lat) -> (x,y) More...

subroutine	mapprojection_lonlat2xy_2d_param (IA, IS, IE, JA, JS, JE, lon, lat, mapping_name, mapping_param, x, y)

subroutine	mapprojection_mapfactor_initialized (IA, IS, IE, JA, JS, JE, lat, m1, m2)
	(x,y) -> (lon,lat) More...

subroutine	mapprojection_rotcoef_initialized (IA, IS, IE, JA, JS, JE, lon, lat, rotc_cos, rotc_sin)
	u(lat,lon) = cos u(x,y) - sin v(x,y) v(lat,lon) = sin u(x,y) + cos v(x,y) More...

subroutine, public	mapprojection_get_param_none
	No projection. More...

subroutine, public	mapprojection_xy2lonlat_none (x, y, param, lon, lat)
	No projection, lon,lat are determined by gnomonic projection: (x,y) -> (lon,lat) More...

subroutine, public	mapprojection_lonlat2xy_none (lon, lat, param, x, y)

subroutine, public	mapprojection_mapfactor_none (lat, param, m1, m2)
	No projection: m1=m2=1. More...

subroutine, public	mapprojection_rotcoef_none (lon, lat, param, rotc_cos, rotc_sin)
	No projection: More...

subroutine, public	mapprojection_get_param_lambertconformal (info, param)
	Lambert Conformal projection. More...

subroutine, public	mapprojection_xy2lonlat_lambertconformal (x, y, param, lon, lat)
	Lambert Conformal projection: (x,y) -> (lon,lat) More...

subroutine, public	mapprojection_lonlat2xy_lambertconformal (lon, lat, param, x, y)
	Lambert Conformal projection: (lon,lat) -> (x,y) More...

subroutine, public	mapprojection_mapfactor_lambertconformal (lat, param, m1, m2)
	Lambert Conformal projection: (lon,lat) -> (m1=m2) More...

subroutine, public	mapprojection_rotcoef_lambertconformal (lon, lat, param, rotc_cos, rotc_sin)

subroutine, public	mapprojection_get_param_polarstereographic (info, param)
	Polar Stereographic projection. More...

subroutine, public	mapprojection_xy2lonlat_polarstereographic (x, y, param, lon, lat)
	Polar Stereographic projection: (x,y) -> (lon,lat) More...

subroutine, public	mapprojection_lonlat2xy_polarstereographic (lon, lat, param, x, y)
	Polar Stereographic projection: (lon,lat) -> (x,y) More...

subroutine, public	mapprojection_mapfactor_polarstereographic (lat, param, m1, m2)
	Polar Stereographic projection: (lon,lat) -> (m1=m2) More...

subroutine, public	mapprojection_rotcoef_polarstereographic (lon, lat, param, rotc_cos, rotc_sin)

subroutine, public	mapprojection_get_param_mercator (info, param)
	Mercator projection. More...

subroutine, public	mapprojection_xy2lonlat_mercator (x, y, param, lon, lat)
	Mercator projection: (x,y) -> (lon,lat) More...

subroutine, public	mapprojection_lonlat2xy_mercator (lon, lat, param, x, y)
	Mercator projection: (lon,lat) -> (x,y) More...

subroutine, public	mapprojection_mapfactor_mercator (lat, param, m1, m2)
	Mercator projection: (lon,lat) -> (m1=m2) More...

subroutine, public	mapprojection_rotcoef_mercator (lon, lat, param, rotc_cos, rotc_sin)

subroutine, public	mapprojection_get_param_equidistantcylindrical (info, param)
	Equidistant Cylindrical projection. More...

subroutine, public	mapprojection_xy2lonlat_equidistantcylindrical (x, y, param, lon, lat)
	Equidistant Cylindrical projection: (x,y) -> (lon,lat) More...

subroutine, public	mapprojection_lonlat2xy_equidistantcylindrical (lon, lat, param, x, y)
	Equidistant Cylindrical projection: (lon,lat) -> (x,y) More...

subroutine, public	mapprojection_mapfactor_equidistantcylindrical (lat, param, m1, m2)
	Equidistant Cylindrical projection: (lon,lat) -> (m1,m2) More...

subroutine, public	mapprojection_rotcoef_equidistantcylindrical (lon, lat, param, rotc_cos, rotc_sin)

Variables
real(rp), public	mapprojection_basepoint_lon = 135.221_RP

real(rp), public	mapprojection_basepoint_lat = 34.653_RP

type(mappinginfo), public	mapprojection_mappinginfo

procedure(xy2lonlat_s), pointer	xy2lonlat => NULL()

Detailed Description

module Map projection

Description: Map projection module

Author: Team SCALE

NAMELIST

PARAM_MAPPROJECTION

name	type	default value	comment
MAPPROJECTION_BASEPOINT_LON	real(RP)	135.221_RP	position of base point in real world [deg]
MAPPROJECTION_BASEPOINT_LAT	real(RP)	34.653_RP	position of base point in real world [deg]
MAPPROJECTION_BASEPOINT_X	real(DP)		position of base point in the model [m]
MAPPROJECTION_BASEPOINT_Y	real(DP)		position of base point in the model [m]
MAPPROJECTION_TYPE	character(len=H_SHORT)	'NONE'	map projection type
MAPPROJECTION_ROTATION	real(DP)	0.0_DP	rotation factor
MAPPROJECTION_LC_LAT1	real(DP)	30.0_DP	standard latitude1 for L.C. projection [deg]
MAPPROJECTION_LC_LAT2	real(DP)	60.0_DP	standard latitude2 for L.C. projection [deg]
MAPPROJECTION_PS_LAT	real(DP)		standard latitude1 for P.S. projection [deg]
MAPPROJECTION_M_LAT	real(DP)	0.0_DP	standard latitude1 for Mer. projection [deg]
MAPPROJECTION_EC_LAT	real(DP)	0.0_DP	standard latitude1 for E.C. projection [deg]

History Output: No history output

Function/Subroutine Documentation

◆ mapprojection_setup()

subroutine, public scale_mapprojection::mapprojection_setup	(	real(rp), intent(in)	DOMAIN_CENTER_X,
		real(rp), intent(in)	DOMAIN_CENTER_Y
	)

Setup.

Parameters

[in]	domain_center_x	center position of global domain [m]: x
[in]	domain_center_y	center position of global domain [m]: y

Definition at line 194 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_twod
     use scale_const, only: &
        undef     => const_undef,  &
        pi_rp     => const_pi,     &
        d2r_rp    => const_d2r,    &
        radius_rp => const_radius
     implicit none
  
     real(RP), intent(in) :: DOMAIN_CENTER_X
     real(RP), intent(in) :: DOMAIN_CENTER_Y
  
     namelist / param_mapprojection / &
        mapprojection_basepoint_lon, &
        mapprojection_basepoint_lat, &
        mapprojection_basepoint_x,   &
        mapprojection_basepoint_y,   &
        mapprojection_type,          &
        mapprojection_rotation,      &
        mapprojection_lc_lat1,       &
        mapprojection_lc_lat2,       &
        mapprojection_ps_lat,        &
        mapprojection_m_lat,         &
        mapprojection_ec_lat
  
     integer :: ierr
     !---------------------------------------------------------------------------
  
     log_newline
     log_info("MAPPROJECTION_setup",*) 'Setup'
  
     pi     = real(pi_rp,     kind=dp)
     d2r    = real(d2r_rp,    kind=dp)
     radius = real(radius_rp, kind=dp)
  
     mapprojection_basepoint_x = domain_center_x
     mapprojection_basepoint_y = domain_center_y
     mapprojection_ps_lat      = undef
  
  
     !--- read namelist
     rewind(io_fid_conf)
     read(io_fid_conf,nml=param_mapprojection,iostat=ierr)
  
     if( ierr < 0 ) then !--- missing
        log_info("MAPPROJECTION_setup",*) 'Not found namelist. Default used.'
     elseif( ierr > 0 ) then !--- fatal error
        log_error("MAPPROJECTION_setup",*) 'Not appropriate names in namelist PARAM_MAPPROJECTION. Check!'
        call prc_abort
     endif
     log_nml(param_mapprojection)
  
     if ( prc_twod .and. mapprojection_type .ne. 'NONE' ) then
        log_error("MAPPROJECTION_setup",*) 'MAPPROJECTION_type must be "NONE" for 2D experiment'
        call prc_abort
     end if
  
     log_newline
     log_info("MAPPROJECTION_setup",*) 'Map projection information'
     log_info_cont('(1x,A,F15.3)') 'Basepoint(x)    [m] : ', mapprojection_basepoint_x
     log_info_cont('(1x,A,F15.3)') 'Basepoint(y)    [m] : ', mapprojection_basepoint_y
     log_info_cont(*)              'Map projection type : ', trim(mapprojection_type)
  
     mapprojection_mappinginfo%longitude_of_central_meridian         = undef
     mapprojection_mappinginfo%straight_vertical_longitude_from_pole = undef
     mapprojection_mappinginfo%standard_parallel(:)                  = undef
  
     mapprojection_mappinginfo%longitude_of_projection_origin = mapprojection_basepoint_lon
     mapprojection_mappinginfo%latitude_of_projection_origin  = mapprojection_basepoint_lat
     mapprojection_mappinginfo%false_easting                  = mapprojection_basepoint_x
     mapprojection_mappinginfo%false_northing                 = mapprojection_basepoint_y
     mapprojection_mappinginfo%rotation                       = mapprojection_rotation
  
  
     select case(mapprojection_type)
     case('NONE')
        log_info_cont(*) '=> NO map projection'
        mapprojection_mappinginfo%mapping_name = ""
  
        xy2lonlat => mapprojection_xy2lonlat_none
        lonlat2xy => mapprojection_lonlat2xy_none
        mapfactor => mapprojection_mapfactor_none
        rotcoef   => mapprojection_rotcoef_none
     case('LC')
        log_info_cont(*) '=> Lambert Conformal projection'
        mapprojection_mappinginfo%mapping_name = "lambert_conformal_conic"
        mapprojection_mappinginfo%standard_parallel(:) = (/ mapprojection_lc_lat1, mapprojection_lc_lat2 /)
        mapprojection_mappinginfo%longitude_of_central_meridian = mapprojection_basepoint_lon
  
        xy2lonlat => mapprojection_xy2lonlat_lambertconformal
        lonlat2xy => mapprojection_lonlat2xy_lambertconformal
        mapfactor => mapprojection_mapfactor_lambertconformal
        rotcoef   => mapprojection_rotcoef_lambertconformal
     case('PS')
        log_info_cont(*) '=> Polar Stereographic projection'
        if( mapprojection_ps_lat == undef ) mapprojection_ps_lat = mapprojection_basepoint_lat
        mapprojection_mappinginfo%mapping_name = "polar_stereographic"
        mapprojection_mappinginfo%straight_vertical_longitude_from_pole = mapprojection_basepoint_lon
        mapprojection_mappinginfo%standard_parallel(1) = mapprojection_ps_lat
  
        xy2lonlat => mapprojection_xy2lonlat_polarstereographic
        lonlat2xy => mapprojection_lonlat2xy_polarstereographic
        mapfactor => mapprojection_mapfactor_polarstereographic
        rotcoef   => mapprojection_rotcoef_polarstereographic
     case('MER')
        log_info_cont(*) '=> Mercator projection'
        mapprojection_mappinginfo%mapping_name = "mercator"
        mapprojection_mappinginfo%standard_parallel(1) = mapprojection_m_lat
  
        xy2lonlat => mapprojection_xy2lonlat_mercator
        lonlat2xy => mapprojection_lonlat2xy_mercator
        mapfactor => mapprojection_mapfactor_mercator
        rotcoef   => mapprojection_rotcoef_mercator
     case('EC')
        log_info_cont(*) '=> Equidistant Cylindrical projection'
        mapprojection_mappinginfo%mapping_name = "equirectangular"
        mapprojection_mappinginfo%standard_parallel(1) = mapprojection_ec_lat
        mapprojection_mappinginfo%longitude_of_central_meridian = mapprojection_basepoint_lon
  
        xy2lonlat => mapprojection_xy2lonlat_equidistantcylindrical
        lonlat2xy => mapprojection_lonlat2xy_equidistantcylindrical
        mapfactor => mapprojection_mapfactor_equidistantcylindrical
        rotcoef   => mapprojection_rotcoef_equidistantcylindrical
     case default
        log_error("MAPPROJECTION_setup",*) 'Unsupported MAPPROJECTION_type. STOP'
        call prc_abort
     endselect
  
     call mapprojection_get_param( mapprojection_mappinginfo, & ! (in)
                                   mapprojection_mappingparam ) ! (out)
  
     return

References scale_const::const_d2r, scale_const::const_pi, scale_const::const_radius, scale_const::const_undef, scale_precision::dp, scale_io::io_fid_conf, mapprojection_basepoint_lat, mapprojection_basepoint_lon, mapprojection_get_param(), mapprojection_lonlat2xy_equidistantcylindrical(), mapprojection_lonlat2xy_lambertconformal(), mapprojection_lonlat2xy_mercator(), mapprojection_lonlat2xy_none(), mapprojection_lonlat2xy_polarstereographic(), mapprojection_mapfactor_equidistantcylindrical(), mapprojection_mapfactor_lambertconformal(), mapprojection_mapfactor_mercator(), mapprojection_mapfactor_none(), mapprojection_mapfactor_polarstereographic(), mapprojection_mappinginfo, mapprojection_rotcoef_equidistantcylindrical(), mapprojection_rotcoef_lambertconformal(), mapprojection_rotcoef_mercator(), mapprojection_rotcoef_none(), mapprojection_rotcoef_polarstereographic(), mapprojection_xy2lonlat_equidistantcylindrical(), mapprojection_xy2lonlat_lambertconformal(), mapprojection_xy2lonlat_mercator(), mapprojection_xy2lonlat_none(), mapprojection_xy2lonlat_polarstereographic(), scale_prc::prc_abort(), scale_prc_cartesc::prc_twod, and xy2lonlat.

Referenced by scale_atmos_grid_cartesc_real::atmos_grid_cartesc_real_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mapprojection_get_param()

subroutine, public scale_mapprojection::mapprojection_get_param	(	type(mappinginfo), intent(in)	info,
		type(mappingparam), intent(out)	param
	)

Definition at line 333 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     implicit none
     type(mappinginfo),  intent(in)  :: info
     type(mappingparam), intent(out) :: param
  
     select case( info%mapping_name )
     case( "" )
        call mapprojection_get_param_none
  
        param%basepoint_lon = info%longitude_of_projection_origin * d2r
     case( "lambert_conformal_conic" )
        call mapprojection_get_param_lambertconformal( info, & ! (in)
                                                       param ) ! (out)
        param%basepoint_lon = info%longitude_of_central_meridian * d2r
     case( "polar_stereographic" )
        call mapprojection_get_param_polarstereographic( info, & ! (in)
                                                         param ) ! (out)
        param%basepoint_lon = info%straight_vertical_longitude_from_pole * d2r
     case( "mercator" )
        call mapprojection_get_param_mercator( info, & ! (in)
                                               param ) ! (out)
        param%basepoint_lon = info%longitude_of_projection_origin * d2r
     case( "equirectangular" )
        call mapprojection_get_param_equidistantcylindrical( info, & ! (in)
                                                             param ) ! (out)
        param%basepoint_lon = info%longitude_of_central_meridian * d2r
     case default
        log_error("MAPPROJECTION_set_param",*) 'Unsupported mapping type. STOP'
        call prc_abort
     endselect
  
     param%basepoint_x = info%false_easting
     param%basepoint_y = info%false_northing
  
     param%basepoint_lat = info%latitude_of_projection_origin * d2r
  
     param%rotation     = info%rotation * d2r
     param%rot_fact_sin = sin(param%rotation)
     param%rot_fact_cos = cos(param%rotation)
  
     return

References mapprojection_get_param_equidistantcylindrical(), mapprojection_get_param_lambertconformal(), mapprojection_get_param_mercator(), mapprojection_get_param_none(), mapprojection_get_param_polarstereographic(), and scale_prc::prc_abort().

Referenced by mapprojection_setup(), and mod_realinput_scale::parentatmosopenscale().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mapprojection_xy2lonlat_0d_initialized()

subroutine scale_mapprojection::mapprojection_xy2lonlat_0d_initialized	(	real(rp), intent(in)	x,
		real(rp), intent(in)	y,
		real(rp), intent(out)	lon,
		real(rp), intent(out)	lat
	)

(x,y) -> (lon,lat)

Definition at line 382 of file scale_mapprojection.F90.

     implicit none
     real(RP), intent(in)  :: x, y
     real(RP), intent(out) :: lon, lat ! [rad]
     !---------------------------------------------------------------------------
  
     call xy2lonlat( x, y,                       & ! (in)
                     mapprojection_mappingparam, & ! (in)
                     lon, lat                    ) ! (out)
  
     return

References mapprojection_xy2lonlat_equidistantcylindrical(), mapprojection_xy2lonlat_lambertconformal(), mapprojection_xy2lonlat_mercator(), mapprojection_xy2lonlat_none(), mapprojection_xy2lonlat_polarstereographic(), scale_prc::prc_abort(), and xy2lonlat.

Here is the call graph for this function:

◆ mapprojection_xy2lonlat_2d_param()

subroutine scale_mapprojection::mapprojection_xy2lonlat_2d_param	(	integer, intent(in)	IA,
		integer, intent(in)	IS,
		integer, intent(in)	IE,
		integer, intent(in)	JA,
		integer, intent(in)	JS,
		integer, intent(in)	JE,
		real(rp), dimension(ia,ja), intent(in)	x,
		real(rp), dimension(ia,ja), intent(in)	y,
		character(len=*), intent(in)	mapping_name,
		type(mappingparam), intent(in)	mapping_param,
		real(rp), dimension(ia,ja), intent(out)	lon,
		real(rp), dimension(ia,ja), intent(out)	lat
	)

Definition at line 470 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     implicit none
     integer, intent(in) :: IA, IS, IE
     integer, intent(in) :: JA, JS, JE
  
     real(RP),           intent(in)  :: x(IA,JA)
     real(RP),           intent(in)  :: y(IA,JA)
     character(len=*),   intent(in) :: mapping_name
     type(mappingparam), intent(in) :: mapping_param
  
     real(RP), intent(out) :: lon(IA,JA) ! [rad]
     real(RP), intent(out) :: lat(IA,JA) ! [rad]
  
     integer :: i, j
     !---------------------------------------------------------------------------
  
     select case( mapping_name )
     case( "" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_xy2lonlat_none( x(i,j), y(i,j),    & ! (in)
                                              mapping_param,     & ! (in)
                                              lon(i,j), lat(i,j) ) ! (out)
        end do
        end do
     case( "lambert_conformal_conic" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_xy2lonlat_lambertconformal( x(i,j), y(i,j),    & ! (in)
                                                          mapping_param,     & ! (in)
                                                          lon(i,j), lat(i,j) ) ! (out)
        end do
        end do
     case( "polar_stereographic" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_xy2lonlat_polarstereographic( x(i,j), y(i,j),    & ! (in)
                                                            mapping_param,     & ! (in)
                                                            lon(i,j), lat(i,j) ) ! (out)
        end do
        end do
     case( "mercator" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_xy2lonlat_mercator( x(i,j), y(i,j),    & ! (in)
                                                  mapping_param,     & ! (in)
                                                  lon(i,j), lat(i,j) ) ! (out)
        end do
        end do
     case( "equirectangular" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_xy2lonlat_equidistantcylindrical( x(i,j), y(i,j),    & ! (in)
                                                                mapping_param,     & ! (in)
                                                                lon(i,j), lat(i,j) ) ! (out)
        end do
        end do
     case default
        log_error("MAPPROJECTION_xy2lonlat_2D_param",*) 'Unsupported mapping type. STOP: ', trim(mapping_name)
        call prc_abort
     endselect
  
     return

References mapprojection_xy2lonlat_equidistantcylindrical(), mapprojection_xy2lonlat_lambertconformal(), mapprojection_xy2lonlat_mercator(), mapprojection_xy2lonlat_none(), mapprojection_xy2lonlat_polarstereographic(), and scale_prc::prc_abort().

Here is the call graph for this function:

◆ mapprojection_lonlat2xy_0d_initialized()

subroutine scale_mapprojection::mapprojection_lonlat2xy_0d_initialized	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		real(rp), intent(out)	x,
		real(rp), intent(out)	y
	)

(lon,lat) -> (x,y)

Definition at line 546 of file scale_mapprojection.F90.

     implicit none
     real(RP), intent(in)  :: lon, lat ! [rad]
     real(RP), intent(out) :: x, y
     !---------------------------------------------------------------------------
  
     call lonlat2xy( lon, lat,                   & ! (in)
                     mapprojection_mappingparam, & ! (in)
                     x, y                       ) ! (out)
  
     return

References mapprojection_lonlat2xy_equidistantcylindrical(), mapprojection_lonlat2xy_lambertconformal(), mapprojection_lonlat2xy_mercator(), mapprojection_lonlat2xy_none(), mapprojection_lonlat2xy_polarstereographic(), and scale_prc::prc_abort().

Here is the call graph for this function:

◆ mapprojection_lonlat2xy_2d_param()

subroutine scale_mapprojection::mapprojection_lonlat2xy_2d_param	(	integer, intent(in)	IA,
		integer, intent(in)	IS,
		integer, intent(in)	IE,
		integer, intent(in)	JA,
		integer, intent(in)	JS,
		integer, intent(in)	JE,
		real(rp), dimension(ia,ja), intent(in)	lon,
		real(rp), dimension(ia,ja), intent(in)	lat,
		character(len=*), intent(in)	mapping_name,
		type(mappingparam), intent(in)	mapping_param,
		real(rp), dimension(ia,ja), intent(out)	x,
		real(rp), dimension(ia,ja), intent(out)	y
	)

Definition at line 634 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     implicit none
     integer, intent(in) :: IA, IS, IE
     integer, intent(in) :: JA, JS, JE
  
     real(RP),           intent(in)  :: lon(IA,JA) ! [rad]
     real(RP),           intent(in)  :: lat(IA,JA) ! [rad]
     character(len=*),   intent(in) :: mapping_name
     type(mappingparam), intent(in) :: mapping_param
  
     real(RP), intent(out) :: x(IA,JA)
     real(RP), intent(out) :: y(IA,JA)
  
     integer :: i, j
     !---------------------------------------------------------------------------
  
     select case( mapping_name )
     case( "" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_lonlat2xy_none( lon(i,j), lat(i,j), & ! (in)
                                              mapping_param,      & ! (in)
                                              x(i,j), y(i,j)      ) ! (out)
        end do
        end do
     case( "lambert_conformal_conic" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_lonlat2xy_lambertconformal( lon(i,j), lat(i,j), & ! (in)
                                                          mapping_param,      & ! (in)
                                                          x(i,j), y(i,j)      ) ! (out)
        end do
        end do
     case( "polar_stereographic" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_lonlat2xy_polarstereographic( lon(i,j), lat(i,j), & ! (in)
                                                            mapping_param,      & ! (in)
                                                            x(i,j), y(i,j)      ) ! (out)
        end do
        end do
     case( "mercator" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_lonlat2xy_mercator( lon(i,j), lat(i,j), & ! (in)
                                                   mapping_param,      & ! (in)
                                                   x(i,j), y(i,j)      ) ! (out)
        end do
        end do
     case( "equirectangular" )
        !$omp parallel do
        do j = js, je
        do i = is, ie
           call mapprojection_lonlat2xy_equidistantcylindrical( lon(i,j), lat(i,j), & ! (in)
                                                                mapping_param,      & ! (in)
                                                                x(i,j), y(i,j)      ) ! (out)
        end do
        end do
     case default
        log_error("MAPPROJECTION_lonlat2xy_2D_param",*) 'Unsupported mapping type. STOP: ', trim(mapping_name)
        call prc_abort
     endselect
  
     return

References mapprojection_lonlat2xy_equidistantcylindrical(), mapprojection_lonlat2xy_lambertconformal(), mapprojection_lonlat2xy_mercator(), mapprojection_lonlat2xy_none(), mapprojection_lonlat2xy_polarstereographic(), and scale_prc::prc_abort().

Here is the call graph for this function:

◆ mapprojection_mapfactor_initialized()

subroutine scale_mapprojection::mapprojection_mapfactor_initialized	(	integer, intent(in)	IA,
		integer, intent(in)	IS,
		integer, intent(in)	IE,
		integer, intent(in)	JA,
		integer, intent(in)	JS,
		integer, intent(in)	JE,
		real(rp), dimension(ia,ja), intent(in)	lat,
		real(rp), dimension (ia,ja), intent(out)	m1,
		real(rp), dimension (ia,ja), intent(out)	m2
	)

(x,y) -> (lon,lat)

Definition at line 711 of file scale_mapprojection.F90.

     implicit none
     integer, intent(in) :: IA, IS, IE
     integer, intent(in) :: JA, JS, JE
  
     real(RP), intent(in)  :: lat(IA,JA) ! [rad]
     real(RP), intent(out) :: m1 (IA,JA)
     real(RP), intent(out) :: m2 (IA,JA)
  
     integer :: i, j
     !---------------------------------------------------------------------------
  
     !$omp parallel do
     do j = js, je
     do i = is, ie
        call mapfactor( lat(i,j),                   & ! (in)
                        mapprojection_mappingparam, & ! (in)
                        m1(i,j), m2(i,j)            ) ! (out)
     end do
     end do
  
     return

References mapprojection_mapfactor_equidistantcylindrical(), mapprojection_mapfactor_lambertconformal(), mapprojection_mapfactor_mercator(), mapprojection_mapfactor_none(), mapprojection_mapfactor_polarstereographic(), and scale_prc::prc_abort().

Here is the call graph for this function:

◆ mapprojection_rotcoef_initialized()

subroutine scale_mapprojection::mapprojection_rotcoef_initialized	(	integer, intent(in)	IA,
		integer, intent(in)	IS,
		integer, intent(in)	IE,
		integer, intent(in)	JA,
		integer, intent(in)	JS,
		integer, intent(in)	JE,
		real(rp), dimension(ia,ja), intent(in)	lon,
		real(rp), dimension(ia,ja), intent(in)	lat,
		real(rp), dimension(ia,ja), intent(out)	rotc_cos,
		real(rp), dimension(ia,ja), intent(out)	rotc_sin
	)

u(lat,lon) = cos u(x,y) - sin v(x,y) v(lat,lon) = sin u(x,y) + cos v(x,y)

Definition at line 817 of file scale_mapprojection.F90.

     implicit none
     integer, intent(in) :: IA, IS, IE
     integer, intent(in) :: JA, JS, JE
  
     real(RP), intent(in)  :: lon(IA,JA)    ! [rad]
     real(RP), intent(in)  :: lat(IA,JA)    ! [rad]
     real(RP), intent(out) :: rotc_cos(IA,JA)
     real(RP), intent(out) :: rotc_sin(IA,JA)
  
     integer :: i, j
     !---------------------------------------------------------------------------
  
     !$omp parallel do
     do j = js, je
     do i = is, ie
        call rotcoef( lon(i,j), lat(i,j),          & ! (in)
                      mapprojection_mappingparam,  & ! (in)
                      rotc_cos(i,j), rotc_sin(i,j) ) ! (out)
     end do
     end do
  
     return

References mapprojection_rotcoef_equidistantcylindrical(), mapprojection_rotcoef_lambertconformal(), mapprojection_rotcoef_mercator(), mapprojection_rotcoef_none(), mapprojection_rotcoef_polarstereographic(), and scale_prc::prc_abort().

Here is the call graph for this function:

◆ mapprojection_get_param_none()

subroutine, public scale_mapprojection::mapprojection_get_param_none

No projection.

Definition at line 921 of file scale_mapprojection.F90.

     implicit none
     !---------------------------------------------------------------------------
  
     return

Referenced by mapprojection_get_param().

Here is the caller graph for this function:

◆ mapprojection_xy2lonlat_none()

subroutine, public scale_mapprojection::mapprojection_xy2lonlat_none	(	real(rp), intent(in)	x,
		real(rp), intent(in)	y,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	lon,
		real(rp), intent(out)	lat
	)

No projection, lon,lat are determined by gnomonic projection: (x,y) -> (lon,lat)

Definition at line 933 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: x, y
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: lon, lat ! [rad]
  
     real(DP) :: xx, yy
     real(DP) :: gno1, gno2
     real(DP) :: rho, gmm
     real(DP) :: gmmc, gmms
     real(DP) :: latc, lats
     !---------------------------------------------------------------------------
  
     if ( x==undef .or. y==undef ) then
        lon = undef
        lat = undef
  
        return
     end if
  
     call xy_rotate( x, y,  & ! (in)
                     param, & ! (in)
                     xx, yy ) ! (out)
  
     gno1 = ( x - param%basepoint_x ) / radius
     gno2 = ( y - param%basepoint_y ) / radius
  
     rho = sqrt( gno1 * gno1 + gno2 * gno2 )
     gmm = atan( rho )
  
     if ( rho == 0.0_dp ) then
        lon = param%basepoint_lon
        lat = param%basepoint_lat
     else
        gmmc = cos(gmm)
        gmms = sin(gmm)
        latc = cos(param%basepoint_lat)
        lats = sin(param%basepoint_lat)
        lon = param%basepoint_lon &
            + atan( gno1*gmms / ( rho * latc * gmmc &
                               - gno2 * lats * gmms ) )
        lat = asin(      lats * gmmc       &
                  + gno2*latc * gmms / rho )
     endif
  
     return

References scale_const::const_undef.

Referenced by mapprojection_setup(), mapprojection_xy2lonlat_0d_initialized(), and mapprojection_xy2lonlat_2d_param().

Here is the caller graph for this function:

◆ mapprojection_lonlat2xy_none()

subroutine, public scale_mapprojection::mapprojection_lonlat2xy_none	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	x,
		real(rp), intent(out)	y
	)

Definition at line 986 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: lon, lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: x, y
  
     real(DP) :: xx, yy
     real(DP) :: lat_d, lat0_d, dlon
     real(DP) :: lat_d_c, lat_d_s, lat0_d_c, lat0_d_s, dlon_c, dlon_s
     real(DP) :: gno1, gno2
     real(DP) :: cos_gmm
     !---------------------------------------------------------------------------
     ! http://mathworld.wolfram.com/GnomonicProjection.html
  
     if ( lon==undef .or. lat==undef ) then
        x = undef
        y = undef
  
        return
     end if
  
     lat_d  = real(lat,kind=dp)
     lat0_d = param%basepoint_lat
  
     dlon = lon - param%basepoint_lon
  
     lat_d_c = cos(lat_d)
     lat_d_s = sin(lat_d)
     lat0_d_c = cos(lat0_d)
     lat0_d_s = sin(lat0_d)
     dlon_c = cos(dlon)
     dlon_s = sin(dlon)
  
     cos_gmm = lat0_d_s * lat_d_s &
             + lat0_d_c * lat_d_c * dlon_c
  
     gno1 = ( lat_d_c  * dlon_s  ) / cos_gmm
     gno2 = ( lat0_d_c * lat_d_s &
            - lat0_d_s * lat_d_c * dlon_c ) / cos_gmm
  
     xx = gno1 * radius + param%basepoint_x
     yy = gno2 * radius + param%basepoint_y
  
     call xy_unrotate( xx, yy, & ! (in)
                       param,  & ! (in)
                       x, y    ) ! (out)
  
     return

References scale_const::const_undef, and scale_precision::dp.

Referenced by mapprojection_lonlat2xy_0d_initialized(), mapprojection_lonlat2xy_2d_param(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_mapfactor_none()

subroutine, public scale_mapprojection::mapprojection_mapfactor_none	(	real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	m1,
		real(rp), intent(out)	m2
	)

No projection: m1=m2=1.

Definition at line 1043 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: m1, m2
     !---------------------------------------------------------------------------
  
     m1 = 1.0_rp
     m2 = m1
  
     return

References scale_const::const_undef.

Referenced by mapprojection_mapfactor_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_rotcoef_none()

subroutine, public scale_mapprojection::mapprojection_rotcoef_none	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	rotc_cos,
		real(rp), intent(out)	rotc_sin
	)

No projection:

Definition at line 1063 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lon, lat
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: rotc_cos, rotc_sin
     !---------------------------------------------------------------------------
  
     rotc_cos = param%rot_fact_cos
     rotc_sin = param%rot_fact_sin
  
     return

Referenced by mapprojection_rotcoef_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_get_param_lambertconformal()

subroutine, public scale_mapprojection::mapprojection_get_param_lambertconformal	(	type(mappinginfo), intent(in)	info,
		type(mappingparam), intent(out)	param
	)

Lambert Conformal projection.

Definition at line 1080 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     implicit none
     type(mappinginfo),  intent(in)  :: info
     type(mappingparam), intent(out) :: param
  
     real(DP) :: LC_lat1, LC_lat2
     real(DP) :: basepoint_lat
     real(DP) :: basepoint_x, basepoint_y
  
     real(DP) :: lat1rot, lat2rot
     real(DP) :: dlon, latrot, dist
     !---------------------------------------------------------------------------
  
     lc_lat1 = info%standard_parallel(1)
     lc_lat2 = info%standard_parallel(2)
  
     basepoint_lat = info%latitude_of_projection_origin
     basepoint_x   = info%false_easting
     basepoint_y   = info%false_northing
  
     if ( lc_lat1 >= lc_lat2 ) then
        log_error("MAPPROJECTION_get_param_LambertConformal",*) 'Please set LC_lat1 < LC_lat2 in degree. STOP'
        call prc_abort
     endif
  
     ! check hemisphere: 1=north, -1=south
     param%hemisphere = sign(1.0_dp,lc_lat1+lc_lat2)
  
     lat1rot = 0.5_dp*pi - param%hemisphere * lc_lat1 * d2r
     lat2rot = 0.5_dp*pi - param%hemisphere * lc_lat2 * d2r
  
     ! calc conformal factor c
     param%c = ( log( sin(lat1rot)        ) - log( sin(lat2rot)        ) ) &
             / ( log( tan(0.5_dp*lat1rot) ) - log( tan(0.5_dp*lat2rot) ) )
  
     ! pre-calc factor
     param%fact = sin(lat1rot) / param%c / tan(0.5_dp*lat1rot)**param%c
  
     ! calc (x,y) at pole point
     dlon = 0.0_dp
  
     latrot = 0.5_dp*pi - param%hemisphere * basepoint_lat * d2r
  
     dist = param%fact * radius * tan(0.5_dp*latrot)**param%c
  
     param%x = basepoint_x -                    dist * sin(param%c*dlon)
     param%y = basepoint_y + param%hemisphere * dist * cos(param%c*dlon)
  
     log_newline
     log_info("MAPPROJECTION_get_param_LambertConformal",*) 'Input parameters'
     log_info_cont(*) 'LC_lat1    = ', lc_lat1
     log_info_cont(*) 'LC_lat2    = ', lc_lat2
     log_info_cont(*) 'hemisphere = ', param%hemisphere
     log_info_cont(*) 'LC_c       = ', param%c
     log_info_cont(*) 'LC_fact    = ', param%fact
     log_info_cont(*) 'pole_x     = ', param%x
     log_info_cont(*) 'pole_y     = ', param%y
  
     return

References scale_prc::prc_abort().

Referenced by mapprojection_get_param().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mapprojection_xy2lonlat_lambertconformal()

subroutine, public scale_mapprojection::mapprojection_xy2lonlat_lambertconformal	(	real(rp), intent(in)	x,
		real(rp), intent(in)	y,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	lon,
		real(rp), intent(out)	lat
	)

Lambert Conformal projection: (x,y) -> (lon,lat)

Definition at line 1148 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: x, y
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: lon, lat ! [rad]
  
     real(DP) :: xx, yy, dist
     !---------------------------------------------------------------------------
  
     if ( x==undef .or. y==undef ) then
        lon = undef
        lat = undef
  
        return
     end if
  
     call xy_rotate( x, y,  & ! (in)
                     param, & ! (in)
                     xx, yy ) ! (out)
     xx =                      ( xx - param%x ) / radius / param%fact
     yy = - param%hemisphere * ( yy - param%y ) / radius / param%fact
  
     dist = sqrt( xx*xx + yy*yy )
  
     lon = param%basepoint_lon + atan2(xx,yy) / param%c
  
     ! check hemisphere: 1=north, -1=south
     lat = param%hemisphere * ( 0.5_dp*pi - 2.0_dp*atan( dist**(1.0_dp/param%c) ) )
  
     return

References scale_const::const_undef.

Referenced by mapprojection_setup(), mapprojection_xy2lonlat_0d_initialized(), and mapprojection_xy2lonlat_2d_param().

Here is the caller graph for this function:

◆ mapprojection_lonlat2xy_lambertconformal()

subroutine, public scale_mapprojection::mapprojection_lonlat2xy_lambertconformal	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	x,
		real(rp), intent(out)	y
	)

Lambert Conformal projection: (lon,lat) -> (x,y)

Definition at line 1187 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: lon, lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: x, y
  
     real(DP) :: xx, yy
     real(DP) :: dlon, latrot, dist
     !---------------------------------------------------------------------------
  
     if ( lon==undef .or. lat==undef ) then
        x = undef
        y = undef
  
        return
     end if
  
     dlon = lon - param%basepoint_lon
     if ( dlon >  pi ) dlon = dlon - pi*2.0_dp
     if ( dlon < -pi ) dlon = dlon + pi*2.0_dp
  
     latrot = 0.5_dp*pi - param%hemisphere * lat
  
     dist = param%fact * radius * tan(0.5_dp*latrot)**param%c
  
     xx = param%x +                    dist * sin(param%c*dlon)
     yy = param%y - param%hemisphere * dist * cos(param%c*dlon)
  
     call xy_unrotate( xx, yy, & ! (in)
                       param,  & ! (in)
                       x, y    ) ! (out)
  
     return

References scale_const::const_undef.

Referenced by mapprojection_lonlat2xy_0d_initialized(), mapprojection_lonlat2xy_2d_param(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_mapfactor_lambertconformal()

subroutine, public scale_mapprojection::mapprojection_mapfactor_lambertconformal	(	real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	m1,
		real(rp), intent(out)	m2
	)

Lambert Conformal projection: (lon,lat) -> (m1=m2)

Definition at line 1229 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: m1, m2
  
     real(DP) :: latrot
     !---------------------------------------------------------------------------
  
     latrot = 0.5_dp*pi - param%hemisphere * lat
  
     m1 = param%fact / sin(latrot) * param%c * tan(0.5_dp*latrot)**param%c
     m2 = m1
  
     return

Referenced by mapprojection_mapfactor_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_rotcoef_lambertconformal()

subroutine, public scale_mapprojection::mapprojection_rotcoef_lambertconformal	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	rotc_cos,
		real(rp), intent(out)	rotc_sin
	)

Definition at line 1250 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lon, lat
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: rotc_cos, rotc_sin
  
     real(DP) :: dlon
     real(DP) :: alpha
     !---------------------------------------------------------------------------
  
     dlon = lon - param%basepoint_lon
     if ( dlon >  pi ) dlon = dlon - pi*2.0_dp
     if ( dlon < -pi ) dlon = dlon + pi*2.0_dp
  
     alpha = - param%c * dlon * param%hemisphere &
             + param%rotation
  
     rotc_cos = cos( alpha )
     rotc_sin = sin( alpha )
  
     return

Referenced by mapprojection_rotcoef_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_get_param_polarstereographic()

subroutine, public scale_mapprojection::mapprojection_get_param_polarstereographic	(	type(mappinginfo), intent(in)	info,
		type(mappingparam), intent(out)	param
	)

Polar Stereographic projection.

Definition at line 1277 of file scale_mapprojection.F90.

     implicit none
     type(mappinginfo),  intent(in)  :: info
     type(mappingparam), intent(out) :: param
  
     real(DP) :: PS_lat
     real(DP) :: basepoint_lat
     real(DP) :: basepoint_x, basepoint_y
  
     real(DP) :: lat0
     real(DP) :: dlon, latrot, dist
     !---------------------------------------------------------------------------
  
     ps_lat = info%standard_parallel(1)
  
     basepoint_lat = info%latitude_of_projection_origin
     basepoint_x   = info%false_easting
     basepoint_y   = info%false_northing
  
     ! check hemisphere: 1=north, -1=south
     param%hemisphere = sign(1.0_dp,ps_lat)
  
     lat0 = param%hemisphere * ps_lat * d2r
  
     ! pre-calc factor
     param%fact = 1.0_dp + sin(lat0)
  
     ! calc (x,y) at pole point
     dlon = 0.0_dp
  
     latrot = 0.5_dp*pi - param%hemisphere * basepoint_lat * d2r
  
     dist = param%fact * radius * tan(0.5_dp*latrot)
  
     param%x = basepoint_x -                    dist * sin(dlon)
     param%y = basepoint_y + param%hemisphere * dist * cos(dlon)
  
     log_newline
     log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'PS_lat1    = ', ps_lat
     log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'hemisphere = ', param%hemisphere
     log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'PS_fact    = ', param%fact
     log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'pole_x     = ', param%x
     log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'pole_y     = ', param%y
  
     return

Referenced by mapprojection_get_param().

Here is the caller graph for this function:

◆ mapprojection_xy2lonlat_polarstereographic()

subroutine, public scale_mapprojection::mapprojection_xy2lonlat_polarstereographic	(	real(rp), intent(in)	x,
		real(rp), intent(in)	y,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	lon,
		real(rp), intent(out)	lat
	)

Polar Stereographic projection: (x,y) -> (lon,lat)

Definition at line 1329 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: x, y
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: lon, lat ! [rad]
  
     real(DP) :: xx, yy, dist
     !---------------------------------------------------------------------------
  
     if ( x==undef .or. y==undef ) then
        lon = undef
        lat = undef
  
        return
     end if
  
     call xy_rotate( x, y,  & ! (in)
                     param, & ! (in)
                     xx, yy ) ! (out)
  
     xx =                      ( xx - param%x ) / radius / param%fact
     yy = - param%hemisphere * ( yy - param%y ) / radius / param%fact
  
     dist = sqrt( xx*xx + yy*yy )
  
     lon = param%basepoint_lon + atan2(xx,yy)
     lat = param%hemisphere * ( 0.5_dp*pi - 2.0_dp*atan(dist) )
  
     return

References scale_const::const_undef.

Referenced by mapprojection_setup(), mapprojection_xy2lonlat_0d_initialized(), and mapprojection_xy2lonlat_2d_param().

Here is the caller graph for this function:

◆ mapprojection_lonlat2xy_polarstereographic()

subroutine, public scale_mapprojection::mapprojection_lonlat2xy_polarstereographic	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	x,
		real(rp), intent(out)	y
	)

Polar Stereographic projection: (lon,lat) -> (x,y)

Definition at line 1367 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: lon, lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: x, y
  
     real(DP) :: dlon, latrot, dist
     real(DP) :: xx, yy
     !---------------------------------------------------------------------------
  
     if ( lon==undef .or. lat==undef ) then
        x = undef
        y = undef
  
        return
     end if
  
     dlon = lon - param%basepoint_lon
  
     latrot = 0.5_dp*pi - param%hemisphere * lat
  
     dist = param%fact * radius * tan(0.5_dp*latrot)
  
     xx = param%x +                    dist * sin(dlon)
     yy = param%y - param%hemisphere * dist * cos(dlon)
  
     call xy_unrotate( xx, yy, & ! (in)
                       param,  & ! (in)
                       x, y    ) ! (out)
  
     return

References scale_const::const_undef.

Referenced by mapprojection_lonlat2xy_0d_initialized(), mapprojection_lonlat2xy_2d_param(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_mapfactor_polarstereographic()

subroutine, public scale_mapprojection::mapprojection_mapfactor_polarstereographic	(	real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	m1,
		real(rp), intent(out)	m2
	)

Polar Stereographic projection: (lon,lat) -> (m1=m2)

Definition at line 1407 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: m1, m2
     !---------------------------------------------------------------------------
  
     m1 = param%fact / ( 1.0_dp + sin(param%hemisphere*lat) )
     m2 = m1
  
     return

Referenced by mapprojection_mapfactor_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_rotcoef_polarstereographic()

subroutine, public scale_mapprojection::mapprojection_rotcoef_polarstereographic	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	rotc_cos,
		real(rp), intent(out)	rotc_sin
	)

Definition at line 1424 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lon, lat
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: rotc_cos, rotc_sin
  
     real(DP) :: dlon
     real(DP) :: alpha
     !---------------------------------------------------------------------------
  
     dlon = lon - param%basepoint_lon
     if ( dlon >  pi ) dlon = dlon - pi*2.0_dp
     if ( dlon < -pi ) dlon = dlon + pi*2.0_dp
  
     alpha = - dlon * param%hemisphere &
             + param%rotation
  
     rotc_cos = cos( alpha )
     rotc_sin = sin( alpha )
  
     return

Referenced by mapprojection_rotcoef_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_get_param_mercator()

subroutine, public scale_mapprojection::mapprojection_get_param_mercator	(	type(mappinginfo), intent(in)	info,
		type(mappingparam), intent(out)	param
	)

Mercator projection.

Definition at line 1451 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     implicit none
     type(mappinginfo),  intent(in)  :: info
     type(mappingparam), intent(out) :: param
  
     real(DP) :: M_lat
     real(DP) :: basepoint_lat
     real(DP) :: basepoint_x, basepoint_y
  
     real(DP) :: lat0
     real(DP) :: latrot, dist
     !---------------------------------------------------------------------------
  
     m_lat = info%standard_parallel(1)
  
     basepoint_lat = info%latitude_of_projection_origin
     basepoint_x   = info%false_easting
     basepoint_y   = info%false_northing
  
     lat0 = m_lat * d2r
  
     ! pre-calc factor
     param%fact = cos(lat0)
  
     if ( param%fact == 0.0_dp ) then
        log_error("MAPPROJECTION_get_param_Mercator",*) 'M_lat cannot be set to pole point! value=', m_lat
        call prc_abort
     endif
  
     ! calc (x,y) at (lon,lat) = (base,0)
     latrot = 0.5_dp*pi - basepoint_lat * d2r
  
     dist = 1.0_dp / tan(0.5_dp*latrot)
  
     param%x = basepoint_x
     param%y = basepoint_y - radius * param%fact * log(dist)
  
     log_newline
     log_info("MAPPROJECTION_get_param_Mercator",*) 'M_lat  = ', m_lat
     log_info("MAPPROJECTION_get_param_Mercator",*) 'M_fact = ', param%fact
     log_info("MAPPROJECTION_get_param_Mercator",*) 'eq_x   = ', param%x
     log_info("MAPPROJECTION_get_param_Mercator",*) 'eq_y   = ', param%y
  
     return

References scale_prc::prc_abort().

Referenced by mapprojection_get_param().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mapprojection_xy2lonlat_mercator()

subroutine, public scale_mapprojection::mapprojection_xy2lonlat_mercator	(	real(rp), intent(in)	x,
		real(rp), intent(in)	y,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	lon,
		real(rp), intent(out)	lat
	)

Mercator projection: (x,y) -> (lon,lat)

Definition at line 1504 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: x, y
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: lon, lat ! [rad]
  
     real(DP) :: xx, yy
     !---------------------------------------------------------------------------
  
     if ( x==undef .or. y==undef ) then
        lon = undef
        lat = undef
  
        return
     end if
  
     call xy_rotate( x, y,  & ! (in)
                     param, & ! (in)
                     xx, yy ) ! (out)
  
     xx = ( xx - param%x ) / radius / param%fact
     yy = ( yy - param%y ) / radius / param%fact
  
     lon = xx + param%basepoint_lon
  
     lat = 0.5_dp*pi - 2.0_dp*atan( 1.0_dp/exp(yy) )
  
     return

References scale_const::const_undef.

Referenced by mapprojection_setup(), mapprojection_xy2lonlat_0d_initialized(), and mapprojection_xy2lonlat_2d_param().

Here is the caller graph for this function:

◆ mapprojection_lonlat2xy_mercator()

subroutine, public scale_mapprojection::mapprojection_lonlat2xy_mercator	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	x,
		real(rp), intent(out)	y
	)

Mercator projection: (lon,lat) -> (x,y)

Definition at line 1541 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: lon, lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: x, y
  
     real(DP) :: dlon, latrot, dist
     !---------------------------------------------------------------------------
  
     if ( lon==undef .or. lat==undef ) then
        x = undef
        y = undef
  
        return
     end if
  
     dlon = lon - param%basepoint_lon
  
     latrot = 0.5_dp*pi - lat
  
     dist = 1.0_dp / tan(0.5_dp*latrot)
  
     x = param%x + radius * param%fact * dlon
     y = param%y + radius * param%fact * log(dist)
  
     return

References scale_const::const_undef.

Referenced by mapprojection_lonlat2xy_0d_initialized(), mapprojection_lonlat2xy_2d_param(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_mapfactor_mercator()

subroutine, public scale_mapprojection::mapprojection_mapfactor_mercator	(	real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	m1,
		real(rp), intent(out)	m2
	)

Mercator projection: (lon,lat) -> (m1=m2)

Definition at line 1576 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: m1, m2
     !---------------------------------------------------------------------------
  
     m1 = param%fact / cos(real(lat,kind=dp))
     m2 = m1
  
     return

References scale_precision::dp.

Referenced by mapprojection_mapfactor_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_rotcoef_mercator()

subroutine, public scale_mapprojection::mapprojection_rotcoef_mercator	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	rotc_cos,
		real(rp), intent(out)	rotc_sin
	)

Definition at line 1593 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lon, lat
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: rotc_cos, rotc_sin
     !---------------------------------------------------------------------------
  
     rotc_cos = param%rot_fact_cos
     rotc_sin = param%rot_fact_sin
  
     return

Referenced by mapprojection_rotcoef_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_get_param_equidistantcylindrical()

subroutine, public scale_mapprojection::mapprojection_get_param_equidistantcylindrical	(	type(mappinginfo), intent(in)	info,
		type(mappingparam), intent(out)	param
	)

Equidistant Cylindrical projection.

Definition at line 1610 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     implicit none
     type(mappinginfo),  intent(in)  :: info
     type(mappingparam), intent(out) :: param
  
     real(DP) :: EC_lat
     real(DP) :: basepoint_lat
     real(DP) :: basepoint_x, basepoint_y
  
     real(DP) :: lat0
     !---------------------------------------------------------------------------
  
     ec_lat = info%standard_parallel(1)
  
     basepoint_lat = info%latitude_of_projection_origin
     basepoint_x   = info%false_easting
     basepoint_y   = info%false_northing
  
     lat0 = ec_lat * d2r
  
     ! pre-calc factor
     param%fact = cos(lat0)
  
     if ( param%fact == 0.0_dp ) then
        log_error("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'EC_lat cannot be set to pole point! value=', ec_lat
        call prc_abort
     endif
  
     param%x = basepoint_x
     param%y = basepoint_y - radius * basepoint_lat * d2r
  
     log_newline
     log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'EC_lat  = ', ec_lat
     log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'EC_fact = ', param%fact
     log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'eq_x    = ', param%x
     log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'eq_y    = ', param%y
  
     return

References scale_prc::prc_abort().

Referenced by mapprojection_get_param().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mapprojection_xy2lonlat_equidistantcylindrical()

subroutine, public scale_mapprojection::mapprojection_xy2lonlat_equidistantcylindrical	(	real(rp), intent(in)	x,
		real(rp), intent(in)	y,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	lon,
		real(rp), intent(out)	lat
	)

Equidistant Cylindrical projection: (x,y) -> (lon,lat)

Definition at line 1657 of file scale_mapprojection.F90.

     use scale_prc, only: &
        prc_abort
     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: x, y
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: lon, lat ! [rad]
  
     real(DP) :: xx, yy
     !---------------------------------------------------------------------------
  
     if ( x==undef .or. y==undef ) then
        lon = undef
        lat = undef
  
        return
     end if
  
     call xy_rotate( x, y,  & ! (in)
                     param, & ! (in)
                     xx, yy ) ! (out)
  
     xx = ( xx - param%x ) / radius / param%fact
     yy = ( yy - param%y ) / radius
  
     lon = xx + param%basepoint_lon
     lat = yy
  
     if ( abs(lat) >  0.5_dp*pi ) then
        log_error("MAPPROJECTION_EquidistantCylindrical_xy2lonlat",*) 'Invalid latitude range! value=', lat
        call prc_abort
     endif
  
     return

References scale_const::const_undef, and scale_prc::prc_abort().

Referenced by mapprojection_setup(), mapprojection_xy2lonlat_0d_initialized(), and mapprojection_xy2lonlat_2d_param().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mapprojection_lonlat2xy_equidistantcylindrical()

subroutine, public scale_mapprojection::mapprojection_lonlat2xy_equidistantcylindrical	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	x,
		real(rp), intent(out)	y
	)

Equidistant Cylindrical projection: (lon,lat) -> (x,y)

Definition at line 1700 of file scale_mapprojection.F90.

     use scale_const, only: &
        undef => const_undef
     implicit none
     real(RP),           intent(in)  :: lon, lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: x, y
  
     real(DP) :: dlon
     real(DP) :: xx, yy
     !---------------------------------------------------------------------------
  
     if ( lon==undef .or. lat==undef ) then
        x = undef
        y = undef
  
        return
     end if
  
     dlon = lon - param%basepoint_lon
  
     xx = param%x + radius * param%fact * dlon
     yy = param%y + radius * lat
  
     call xy_unrotate( xx, yy, & ! (in)
                       param,  & ! (in)
                       x, y    ) ! (out)
  
     return

References scale_const::const_undef.

Referenced by mapprojection_lonlat2xy_0d_initialized(), mapprojection_lonlat2xy_2d_param(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_mapfactor_equidistantcylindrical()

subroutine, public scale_mapprojection::mapprojection_mapfactor_equidistantcylindrical	(	real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	m1,
		real(rp), intent(out)	m2
	)

Equidistant Cylindrical projection: (lon,lat) -> (m1,m2)

Definition at line 1736 of file scale_mapprojection.F90.

     implicit none
     real(RP), intent(in)  :: lat ! [rad]
     type(mappingparam), intent(in)  :: param
     real(RP), intent(out) :: m1, m2
  
     real(DP) :: mm1, mm2
     !---------------------------------------------------------------------------
  
     mm1 = param%fact / cos(real(lat,kind=dp))
     mm2 = 1.0_dp
  
     m1 = sqrt( (param%rot_fact_cos * mm1)**2 + (param%rot_fact_sin * mm2)**2 )
     m2 = sqrt( (param%rot_fact_cos * mm2)**2 + (param%rot_fact_sin * mm1)**2 )
  
     return

References scale_precision::dp.

Referenced by mapprojection_mapfactor_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

◆ mapprojection_rotcoef_equidistantcylindrical()

subroutine, public scale_mapprojection::mapprojection_rotcoef_equidistantcylindrical	(	real(rp), intent(in)	lon,
		real(rp), intent(in)	lat,
		type(mappingparam), intent(in)	param,
		real(rp), intent(out)	rotc_cos,
		real(rp), intent(out)	rotc_sin
	)

Definition at line 1758 of file scale_mapprojection.F90.

     implicit none
     real(RP),           intent(in)  :: lon, lat
     type(mappingparam), intent(in)  :: param
     real(RP),           intent(out) :: rotc_cos, rotc_sin
     !---------------------------------------------------------------------------
  
     rotc_cos = param%rot_fact_cos
     rotc_sin = param%rot_fact_sin
  
     return

Referenced by mapprojection_rotcoef_initialized(), and mapprojection_setup().

Here is the caller graph for this function:

Variable Documentation

◆ mapprojection_basepoint_lon

real(rp), public scale_mapprojection::mapprojection_basepoint_lon = 135.221_RP

Definition at line 90 of file scale_mapprojection.F90.

90 real(RP), public :: MAPPROJECTION_basepoint_lon = 135.221_rp ! position of base point in real world [deg]

Referenced by scale_atmos_grid_cartesc_real::atmos_grid_cartesc_real_setup(), mapprojection_setup(), and mod_urban_driver::urban_driver_calc_tendency().

◆ mapprojection_basepoint_lat

real(rp), public scale_mapprojection::mapprojection_basepoint_lat = 34.653_RP

Definition at line 91 of file scale_mapprojection.F90.

91 real(RP), public :: MAPPROJECTION_basepoint_lat = 34.653_rp ! position of base point in real world [deg]

Referenced by scale_atmos_grid_cartesc_real::atmos_grid_cartesc_real_setup(), mapprojection_setup(), and mod_urban_driver::urban_driver_calc_tendency().

◆ mapprojection_mappinginfo

type(mappinginfo), public scale_mapprojection::mapprojection_mappinginfo

Definition at line 104 of file scale_mapprojection.F90.

104 type(mappinginfo), public :: MAPPROJECTION_mappinginfo

Referenced by scale_file_cartesc::file_cartesc_def_axes(), scale_file_cartesc::file_cartesc_def_var(), scale_file_history_cartesc::file_history_cartesc_set_pres(), scale_file_history_cartesc::file_history_cartesc_truncate_3d(), and mapprojection_setup().

◆ xy2lonlat

procedure(xy2lonlat_s), pointer scale_mapprojection::xy2lonlat => NULL()

Definition at line 184 of file scale_mapprojection.F90.

184 procedure(xy2lonlat_s), pointer :: xy2lonlat => null()

Referenced by mapprojection_setup(), and mapprojection_xy2lonlat_0d_initialized().

Data Types

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ mapprojection_setup()

◆ mapprojection_get_param()

◆ mapprojection_xy2lonlat_0d_initialized()

◆ mapprojection_xy2lonlat_2d_param()

◆ mapprojection_lonlat2xy_0d_initialized()

◆ mapprojection_lonlat2xy_2d_param()

◆ mapprojection_mapfactor_initialized()

◆ mapprojection_rotcoef_initialized()

◆ mapprojection_get_param_none()

◆ mapprojection_xy2lonlat_none()

◆ mapprojection_lonlat2xy_none()

◆ mapprojection_mapfactor_none()

◆ mapprojection_rotcoef_none()

◆ mapprojection_get_param_lambertconformal()

◆ mapprojection_xy2lonlat_lambertconformal()

◆ mapprojection_lonlat2xy_lambertconformal()

◆ mapprojection_mapfactor_lambertconformal()

◆ mapprojection_rotcoef_lambertconformal()

◆ mapprojection_get_param_polarstereographic()

◆ mapprojection_xy2lonlat_polarstereographic()

◆ mapprojection_lonlat2xy_polarstereographic()

◆ mapprojection_mapfactor_polarstereographic()

◆ mapprojection_rotcoef_polarstereographic()

◆ mapprojection_get_param_mercator()

◆ mapprojection_xy2lonlat_mercator()

◆ mapprojection_lonlat2xy_mercator()

◆ mapprojection_mapfactor_mercator()

◆ mapprojection_rotcoef_mercator()

◆ mapprojection_get_param_equidistantcylindrical()

◆ mapprojection_xy2lonlat_equidistantcylindrical()

◆ mapprojection_lonlat2xy_equidistantcylindrical()

◆ mapprojection_mapfactor_equidistantcylindrical()

◆ mapprojection_rotcoef_equidistantcylindrical()

Variable Documentation

◆ mapprojection_basepoint_lon

◆ mapprojection_basepoint_lat

◆ mapprojection_mappinginfo

◆ xy2lonlat