SCALE-RM
Data Types | Functions/Subroutines | Variables
scale_mapprojection Module Reference

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), save, public mapprojection_mappinginfo
 
procedure(xy2lonlat_s), pointer xy2lonlat => NULL()
 

Detailed Description

module Map projection

Description
Map projection module
Author
Team SCALE
NAMELIST
  • PARAM_MAPPROJECTION
    nametypedefault valuecomment
    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) standard latitude1 for Mer. projection [deg]
    MAPPROJECTION_EC_LAT real(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_xcenter position of global domain [m]: x
[in]domain_center_ycenter position of global domain [m]: y

Definition at line 194 of file scale_mapprojection.F90.

194  use scale_prc, only: &
195  prc_abort
196  use scale_prc_cartesc, only: &
197  prc_twod
198  use scale_const, only: &
199  undef => const_undef, &
200  pi_rp => const_pi, &
201  d2r_rp => const_d2r, &
202  radius_rp => const_radius
203  implicit none
204 
205  real(RP), intent(in) :: DOMAIN_CENTER_X
206  real(RP), intent(in) :: DOMAIN_CENTER_Y
207 
208  namelist / param_mapprojection / &
209  mapprojection_basepoint_lon, &
210  mapprojection_basepoint_lat, &
211  mapprojection_basepoint_x, &
212  mapprojection_basepoint_y, &
213  mapprojection_type, &
214  mapprojection_rotation, &
215  mapprojection_lc_lat1, &
216  mapprojection_lc_lat2, &
217  mapprojection_ps_lat, &
218  mapprojection_m_lat, &
219  mapprojection_ec_lat
220 
221  integer :: ierr
222  !---------------------------------------------------------------------------
223 
224  log_newline
225  log_info("MAPPROJECTION_setup",*) 'Setup'
226 
227  pi = real(pi_rp, kind=dp)
228  d2r = real(d2r_rp, kind=dp)
229  radius = real(radius_rp, kind=dp)
230 
231  mapprojection_basepoint_x = domain_center_x
232  mapprojection_basepoint_y = domain_center_y
233  mapprojection_ps_lat = undef
234  mapprojection_m_lat = undef
235  mapprojection_ec_lat = undef
236 
237 
238  !--- read namelist
239  rewind(io_fid_conf)
240  read(io_fid_conf,nml=param_mapprojection,iostat=ierr)
241 
242  if( ierr < 0 ) then !--- missing
243  log_info("MAPPROJECTION_setup",*) 'Not found namelist. Default used.'
244  elseif( ierr > 0 ) then !--- fatal error
245  log_error("MAPPROJECTION_setup",*) 'Not appropriate names in namelist PARAM_MAPPROJECTION. Check!'
246  call prc_abort
247  endif
248  log_nml(param_mapprojection)
249 
250  if ( prc_twod .and. mapprojection_type .ne. 'NONE' ) then
251  log_error("MAPPROJECTION_setup",*) 'MAPPROJECTION_type must be "NONE" for 2D experiment'
252  call prc_abort
253  end if
254 
255  log_newline
256  log_info("MAPPROJECTION_setup",*) 'Map projection information'
257  log_info_cont('(1x,A,F15.3)') 'Basepoint(x) [m] : ', mapprojection_basepoint_x
258  log_info_cont('(1x,A,F15.3)') 'Basepoint(y) [m] : ', mapprojection_basepoint_y
259  log_info_cont(*) 'Map projection type : ', trim(mapprojection_type)
260 
261  mapprojection_mappinginfo%longitude_of_central_meridian = undef
262  mapprojection_mappinginfo%straight_vertical_longitude_from_pole = undef
263  mapprojection_mappinginfo%standard_parallel(:) = undef
264 
265  mapprojection_mappinginfo%longitude_of_projection_origin = mapprojection_basepoint_lon
266  mapprojection_mappinginfo%latitude_of_projection_origin = mapprojection_basepoint_lat
267  mapprojection_mappinginfo%false_easting = mapprojection_basepoint_x
268  mapprojection_mappinginfo%false_northing = mapprojection_basepoint_y
269  mapprojection_mappinginfo%rotation = mapprojection_rotation
270 
271 
272  select case(mapprojection_type)
273  case('NONE')
274  log_info_cont(*) '=> NO map projection'
275  mapprojection_mappinginfo%mapping_name = ""
276 
277  xy2lonlat => mapprojection_xy2lonlat_none
278  lonlat2xy => mapprojection_lonlat2xy_none
279  mapfactor => mapprojection_mapfactor_none
280  rotcoef => mapprojection_rotcoef_none
281  case('LC')
282  log_info_cont(*) '=> Lambert Conformal projection'
283  mapprojection_mappinginfo%mapping_name = "lambert_conformal_conic"
284  mapprojection_mappinginfo%standard_parallel(:) = (/ mapprojection_lc_lat1, mapprojection_lc_lat2 /)
285  mapprojection_mappinginfo%longitude_of_central_meridian = mapprojection_basepoint_lon
286 
287  xy2lonlat => mapprojection_xy2lonlat_lambertconformal
288  lonlat2xy => mapprojection_lonlat2xy_lambertconformal
289  mapfactor => mapprojection_mapfactor_lambertconformal
290  rotcoef => mapprojection_rotcoef_lambertconformal
291  case('PS')
292  log_info_cont(*) '=> Polar Stereographic projection'
293  if( mapprojection_ps_lat == undef ) mapprojection_ps_lat = mapprojection_basepoint_lat
294  mapprojection_mappinginfo%mapping_name = "polar_stereographic"
295  mapprojection_mappinginfo%straight_vertical_longitude_from_pole = mapprojection_basepoint_lon
296  mapprojection_mappinginfo%standard_parallel(1) = mapprojection_ps_lat
297 
298  xy2lonlat => mapprojection_xy2lonlat_polarstereographic
299  lonlat2xy => mapprojection_lonlat2xy_polarstereographic
300  mapfactor => mapprojection_mapfactor_polarstereographic
301  rotcoef => mapprojection_rotcoef_polarstereographic
302  case('MER')
303  log_info_cont(*) '=> Mercator projection'
304  if( mapprojection_m_lat == undef ) mapprojection_m_lat = mapprojection_basepoint_lat
305  mapprojection_mappinginfo%mapping_name = "mercator"
306  mapprojection_mappinginfo%standard_parallel(1) = mapprojection_m_lat
307 
308  xy2lonlat => mapprojection_xy2lonlat_mercator
309  lonlat2xy => mapprojection_lonlat2xy_mercator
310  mapfactor => mapprojection_mapfactor_mercator
311  rotcoef => mapprojection_rotcoef_mercator
312  case('EC')
313  log_info_cont(*) '=> Equidistant Cylindrical projection'
314  if( mapprojection_ec_lat == undef ) mapprojection_ec_lat = mapprojection_basepoint_lat
315  mapprojection_mappinginfo%mapping_name = "equirectangular"
316  mapprojection_mappinginfo%standard_parallel(1) = mapprojection_ec_lat
317  mapprojection_mappinginfo%longitude_of_central_meridian = mapprojection_basepoint_lon
318 
319  xy2lonlat => mapprojection_xy2lonlat_equidistantcylindrical
320  lonlat2xy => mapprojection_lonlat2xy_equidistantcylindrical
321  mapfactor => mapprojection_mapfactor_equidistantcylindrical
322  rotcoef => mapprojection_rotcoef_equidistantcylindrical
323  case default
324  log_error("MAPPROJECTION_setup",*) 'Unsupported MAPPROJECTION_type. STOP'
325  call prc_abort
326  endselect
327 
328  call mapprojection_get_param( mapprojection_mappinginfo, & ! (in)
329  mapprojection_mappingparam ) ! (out)
330 
331  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 337 of file scale_mapprojection.F90.

337  use scale_prc, only: &
338  prc_abort
339  implicit none
340  type(mappinginfo), intent(in) :: info
341  type(mappingparam), intent(out) :: param
342 
343  select case( info%mapping_name )
344  case( "" )
345  call mapprojection_get_param_none
346 
347  param%basepoint_lon = info%longitude_of_projection_origin * d2r
348  case( "lambert_conformal_conic" )
349  call mapprojection_get_param_lambertconformal( info, & ! (in)
350  param ) ! (out)
351  param%basepoint_lon = info%longitude_of_central_meridian * d2r
352  case( "polar_stereographic" )
353  call mapprojection_get_param_polarstereographic( info, & ! (in)
354  param ) ! (out)
355  param%basepoint_lon = info%straight_vertical_longitude_from_pole * d2r
356  case( "mercator" )
357  call mapprojection_get_param_mercator( info, & ! (in)
358  param ) ! (out)
359  param%basepoint_lon = info%longitude_of_projection_origin * d2r
360  case( "equirectangular" )
361  call mapprojection_get_param_equidistantcylindrical( info, & ! (in)
362  param ) ! (out)
363  param%basepoint_lon = info%longitude_of_central_meridian * d2r
364  case default
365  log_error("MAPPROJECTION_set_param",*) 'Unsupported mapping type. STOP'
366  call prc_abort
367  endselect
368 
369  param%basepoint_x = info%false_easting
370  param%basepoint_y = info%false_northing
371 
372  param%basepoint_lat = info%latitude_of_projection_origin * d2r
373 
374  param%rotation = info%rotation * d2r
375  param%rot_fact_sin = sin(param%rotation)
376  param%rot_fact_cos = cos(param%rotation)
377 
378  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::realinput_surface().

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 386 of file scale_mapprojection.F90.

386  implicit none
387  real(RP), intent(in) :: x, y
388  real(RP), intent(out) :: lon, lat ! [rad]
389  !---------------------------------------------------------------------------
390 
391  call xy2lonlat( x, y, & ! (in)
392  mapprojection_mappingparam, & ! (in)
393  lon, lat ) ! (out)
394 
395  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 474 of file scale_mapprojection.F90.

474  use scale_prc, only: &
475  prc_abort
476  implicit none
477  integer, intent(in) :: IA, IS, IE
478  integer, intent(in) :: JA, JS, JE
479 
480  real(RP), intent(in) :: x(IA,JA)
481  real(RP), intent(in) :: y(IA,JA)
482  character(len=*), intent(in) :: mapping_name
483  type(mappingparam), intent(in) :: mapping_param
484 
485  real(RP), intent(out) :: lon(IA,JA) ! [rad]
486  real(RP), intent(out) :: lat(IA,JA) ! [rad]
487 
488  integer :: i, j
489  !---------------------------------------------------------------------------
490 
491  select case( mapping_name )
492  case( "" )
493  !$omp parallel do
494  do j = js, je
495  do i = is, ie
496  call mapprojection_xy2lonlat_none( x(i,j), y(i,j), & ! (in)
497  mapping_param, & ! (in)
498  lon(i,j), lat(i,j) ) ! (out)
499  end do
500  end do
501  case( "lambert_conformal_conic" )
502  !$omp parallel do
503  do j = js, je
504  do i = is, ie
505  call mapprojection_xy2lonlat_lambertconformal( x(i,j), y(i,j), & ! (in)
506  mapping_param, & ! (in)
507  lon(i,j), lat(i,j) ) ! (out)
508  end do
509  end do
510  case( "polar_stereographic" )
511  !$omp parallel do
512  do j = js, je
513  do i = is, ie
514  call mapprojection_xy2lonlat_polarstereographic( x(i,j), y(i,j), & ! (in)
515  mapping_param, & ! (in)
516  lon(i,j), lat(i,j) ) ! (out)
517  end do
518  end do
519  case( "mercator" )
520  !$omp parallel do
521  do j = js, je
522  do i = is, ie
523  call mapprojection_xy2lonlat_mercator( x(i,j), y(i,j), & ! (in)
524  mapping_param, & ! (in)
525  lon(i,j), lat(i,j) ) ! (out)
526  end do
527  end do
528  case( "equirectangular" )
529  !$omp parallel do
530  do j = js, je
531  do i = is, ie
532  call mapprojection_xy2lonlat_equidistantcylindrical( x(i,j), y(i,j), & ! (in)
533  mapping_param, & ! (in)
534  lon(i,j), lat(i,j) ) ! (out)
535  end do
536  end do
537  case default
538  log_error("MAPPROJECTION_xy2lonlat_2D_param",*) 'Unsupported mapping type. STOP: ', trim(mapping_name)
539  call prc_abort
540  endselect
541 
542  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 550 of file scale_mapprojection.F90.

550  implicit none
551  real(RP), intent(in) :: lon, lat ! [rad]
552  real(RP), intent(out) :: x, y
553  !---------------------------------------------------------------------------
554 
555  call lonlat2xy( lon, lat, & ! (in)
556  mapprojection_mappingparam, & ! (in)
557  x, y ) ! (out)
558 
559  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 638 of file scale_mapprojection.F90.

638  use scale_prc, only: &
639  prc_abort
640  implicit none
641  integer, intent(in) :: IA, IS, IE
642  integer, intent(in) :: JA, JS, JE
643 
644  real(RP), intent(in) :: lon(IA,JA) ! [rad]
645  real(RP), intent(in) :: lat(IA,JA) ! [rad]
646  character(len=*), intent(in) :: mapping_name
647  type(mappingparam), intent(in) :: mapping_param
648 
649  real(RP), intent(out) :: x(IA,JA)
650  real(RP), intent(out) :: y(IA,JA)
651 
652  integer :: i, j
653  !---------------------------------------------------------------------------
654 
655  select case( mapping_name )
656  case( "" )
657  !$omp parallel do
658  do j = js, je
659  do i = is, ie
660  call mapprojection_lonlat2xy_none( lon(i,j), lat(i,j), & ! (in)
661  mapping_param, & ! (in)
662  x(i,j), y(i,j) ) ! (out)
663  end do
664  end do
665  case( "lambert_conformal_conic" )
666  !$omp parallel do
667  do j = js, je
668  do i = is, ie
669  call mapprojection_lonlat2xy_lambertconformal( lon(i,j), lat(i,j), & ! (in)
670  mapping_param, & ! (in)
671  x(i,j), y(i,j) ) ! (out)
672  end do
673  end do
674  case( "polar_stereographic" )
675  !$omp parallel do
676  do j = js, je
677  do i = is, ie
678  call mapprojection_lonlat2xy_polarstereographic( lon(i,j), lat(i,j), & ! (in)
679  mapping_param, & ! (in)
680  x(i,j), y(i,j) ) ! (out)
681  end do
682  end do
683  case( "mercator" )
684  !$omp parallel do
685  do j = js, je
686  do i = is, ie
687  call mapprojection_lonlat2xy_mercator( lon(i,j), lat(i,j), & ! (in)
688  mapping_param, & ! (in)
689  x(i,j), y(i,j) ) ! (out)
690  end do
691  end do
692  case( "equirectangular" )
693  !$omp parallel do
694  do j = js, je
695  do i = is, ie
696  call mapprojection_lonlat2xy_equidistantcylindrical( lon(i,j), lat(i,j), & ! (in)
697  mapping_param, & ! (in)
698  x(i,j), y(i,j) ) ! (out)
699  end do
700  end do
701  case default
702  log_error("MAPPROJECTION_lonlat2xy_2D_param",*) 'Unsupported mapping type. STOP: ', trim(mapping_name)
703  call prc_abort
704  endselect
705 
706  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 715 of file scale_mapprojection.F90.

715  implicit none
716  integer, intent(in) :: IA, IS, IE
717  integer, intent(in) :: JA, JS, JE
718 
719  real(RP), intent(in) :: lat(IA,JA) ! [rad]
720  real(RP), intent(out) :: m1 (IA,JA)
721  real(RP), intent(out) :: m2 (IA,JA)
722 
723  integer :: i, j
724  !---------------------------------------------------------------------------
725 
726  !$omp parallel do
727  do j = js, je
728  do i = is, ie
729  call mapfactor( lat(i,j), & ! (in)
730  mapprojection_mappingparam, & ! (in)
731  m1(i,j), m2(i,j) ) ! (out)
732  end do
733  end do
734 
735  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 821 of file scale_mapprojection.F90.

821  implicit none
822  integer, intent(in) :: IA, IS, IE
823  integer, intent(in) :: JA, JS, JE
824 
825  real(RP), intent(in) :: lon(IA,JA) ! [rad]
826  real(RP), intent(in) :: lat(IA,JA) ! [rad]
827  real(RP), intent(out) :: rotc_cos(IA,JA)
828  real(RP), intent(out) :: rotc_sin(IA,JA)
829 
830  integer :: i, j
831  !---------------------------------------------------------------------------
832 
833  !$omp parallel do
834  do j = js, je
835  do i = is, ie
836  call rotcoef( lon(i,j), lat(i,j), & ! (in)
837  mapprojection_mappingparam, & ! (in)
838  rotc_cos(i,j), rotc_sin(i,j) ) ! (out)
839  end do
840  end do
841 
842  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 925 of file scale_mapprojection.F90.

925  implicit none
926  !---------------------------------------------------------------------------
927 
928  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 937 of file scale_mapprojection.F90.

937  use scale_const, only: &
938  undef => const_undef
939  implicit none
940  real(RP), intent(in) :: x, y
941  type(mappingparam), intent(in) :: param
942  real(RP), intent(out) :: lon, lat ! [rad]
943 
944  real(DP) :: xx, yy
945  real(DP) :: gno1, gno2
946  real(DP) :: rho, gmm
947  real(DP) :: gmmc, gmms
948  real(DP) :: latc, lats
949  !---------------------------------------------------------------------------
950 
951  if ( x==undef .or. y==undef ) then
952  lon = undef
953  lat = undef
954 
955  return
956  end if
957 
958  call xy_rotate( x, y, & ! (in)
959  param, & ! (in)
960  xx, yy ) ! (out)
961 
962  gno1 = ( x - param%basepoint_x ) / radius
963  gno2 = ( y - param%basepoint_y ) / radius
964 
965  rho = sqrt( gno1 * gno1 + gno2 * gno2 )
966  gmm = atan( rho )
967 
968  if ( rho == 0.0_dp ) then
969  lon = param%basepoint_lon
970  lat = param%basepoint_lat
971  else
972  gmmc = cos(gmm)
973  gmms = sin(gmm)
974  latc = cos(param%basepoint_lat)
975  lats = sin(param%basepoint_lat)
976  lon = param%basepoint_lon &
977  + atan( gno1*gmms / ( rho * latc * gmmc &
978  - gno2 * lats * gmms ) )
979  lat = asin( lats * gmmc &
980  + gno2*latc * gmms / rho )
981  endif
982 
983  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 990 of file scale_mapprojection.F90.

990  use scale_const, only: &
991  undef => const_undef
992  implicit none
993  real(RP), intent(in) :: lon, lat ! [rad]
994  type(mappingparam), intent(in) :: param
995  real(RP), intent(out) :: x, y
996 
997  real(DP) :: xx, yy
998  real(DP) :: lat_d, lat0_d, dlon
999  real(DP) :: lat_d_c, lat_d_s, lat0_d_c, lat0_d_s, dlon_c, dlon_s
1000  real(DP) :: gno1, gno2
1001  real(DP) :: cos_gmm
1002  !---------------------------------------------------------------------------
1003  ! http://mathworld.wolfram.com/GnomonicProjection.html
1004 
1005  if ( lon==undef .or. lat==undef ) then
1006  x = undef
1007  y = undef
1008 
1009  return
1010  end if
1011 
1012  lat_d = real(lat,kind=dp)
1013  lat0_d = param%basepoint_lat
1014 
1015  dlon = lon - param%basepoint_lon
1016 
1017  lat_d_c = cos(lat_d)
1018  lat_d_s = sin(lat_d)
1019  lat0_d_c = cos(lat0_d)
1020  lat0_d_s = sin(lat0_d)
1021  dlon_c = cos(dlon)
1022  dlon_s = sin(dlon)
1023 
1024  cos_gmm = lat0_d_s * lat_d_s &
1025  + lat0_d_c * lat_d_c * dlon_c
1026 
1027  gno1 = ( lat_d_c * dlon_s ) / cos_gmm
1028  gno2 = ( lat0_d_c * lat_d_s &
1029  - lat0_d_s * lat_d_c * dlon_c ) / cos_gmm
1030 
1031  xx = gno1 * radius + param%basepoint_x
1032  yy = gno2 * radius + param%basepoint_y
1033 
1034  call xy_unrotate( xx, yy, & ! (in)
1035  param, & ! (in)
1036  x, y ) ! (out)
1037 
1038  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 1047 of file scale_mapprojection.F90.

1047  use scale_const, only: &
1048  undef => const_undef
1049  implicit none
1050  real(RP), intent(in) :: lat ! [rad]
1051  type(mappingparam), intent(in) :: param
1052  real(RP), intent(out) :: m1, m2
1053  !---------------------------------------------------------------------------
1054 
1055  m1 = 1.0_rp
1056  m2 = m1
1057 
1058  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 1067 of file scale_mapprojection.F90.

1067  implicit none
1068  real(RP), intent(in) :: lon, lat
1069  type(mappingparam), intent(in) :: param
1070  real(RP), intent(out) :: rotc_cos, rotc_sin
1071  !---------------------------------------------------------------------------
1072 
1073  rotc_cos = param%rot_fact_cos
1074  rotc_sin = param%rot_fact_sin
1075 
1076  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 1084 of file scale_mapprojection.F90.

1084  use scale_prc, only: &
1085  prc_abort
1086  implicit none
1087  type(mappinginfo), intent(in) :: info
1088  type(mappingparam), intent(out) :: param
1089 
1090  real(DP), parameter :: EPS = 1d-16
1091  real(DP) :: LC_lat1, LC_lat2
1092  real(DP) :: basepoint_lat
1093  real(DP) :: basepoint_x, basepoint_y
1094 
1095  real(DP) :: lat1rot, lat2rot
1096  real(DP) :: dlon, latrot, dist
1097  !---------------------------------------------------------------------------
1098 
1099  lc_lat1 = info%standard_parallel(1)
1100  lc_lat2 = info%standard_parallel(2)
1101 
1102  basepoint_lat = info%latitude_of_projection_origin
1103  basepoint_x = info%false_easting
1104  basepoint_y = info%false_northing
1105 
1106  if ( lc_lat1 > lc_lat2 ) then
1107  log_error("MAPPROJECTION_get_param_LambertConformal",*) 'Please set LC_lat1 <= LC_lat2 in degree. STOP'
1108  call prc_abort
1109  endif
1110 
1111  ! check hemisphere: 1=north, -1=south
1112  param%hemisphere = sign(1.0_dp,lc_lat1+lc_lat2)
1113 
1114  lat1rot = 0.5_dp*pi - param%hemisphere * lc_lat1 * d2r
1115  lat2rot = 0.5_dp*pi - param%hemisphere * lc_lat2 * d2r
1116  if ( lc_lat2 - lc_lat1 > eps ) then
1117  ! calc conformal factor c
1118  param%c = ( log( sin(lat1rot) ) - log( sin(lat2rot) ) ) &
1119  / ( log( tan(0.5_dp*lat1rot) ) - log( tan(0.5_dp*lat2rot) ) )
1120  else
1121  param%c = cos(lat1rot)
1122  end if
1123  ! pre-calc factor
1124  param%fact = sin(lat1rot) / param%c / tan(0.5_dp*lat1rot)**param%c
1125 
1126  ! calc (x,y) at pole point
1127  dlon = 0.0_dp
1128 
1129  latrot = 0.5_dp*pi - param%hemisphere * basepoint_lat * d2r
1130 
1131  dist = param%fact * radius * tan(0.5_dp*latrot)**param%c
1132 
1133  param%x = basepoint_x - dist * sin(param%c*dlon)
1134  param%y = basepoint_y + param%hemisphere * dist * cos(param%c*dlon)
1135 
1136  log_newline
1137  log_info("MAPPROJECTION_get_param_LambertConformal",*) 'Input parameters'
1138  log_info_cont(*) 'LC_lat1 = ', lc_lat1
1139  log_info_cont(*) 'LC_lat2 = ', lc_lat2
1140  log_info_cont(*) 'hemisphere = ', param%hemisphere
1141  log_info_cont(*) 'LC_c = ', param%c
1142  log_info_cont(*) 'LC_fact = ', param%fact
1143  log_info_cont(*) 'pole_x = ', param%x
1144  log_info_cont(*) 'pole_y = ', param%y
1145 
1146  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 1155 of file scale_mapprojection.F90.

1155  use scale_const, only: &
1156  undef => const_undef
1157  implicit none
1158  real(RP), intent(in) :: x, y
1159  type(mappingparam), intent(in) :: param
1160  real(RP), intent(out) :: lon, lat ! [rad]
1161 
1162  real(DP) :: xx, yy, dist
1163  !---------------------------------------------------------------------------
1164 
1165  if ( x==undef .or. y==undef ) then
1166  lon = undef
1167  lat = undef
1168 
1169  return
1170  end if
1171 
1172  call xy_rotate( x, y, & ! (in)
1173  param, & ! (in)
1174  xx, yy ) ! (out)
1175  xx = ( xx - param%x ) / radius / param%fact
1176  yy = - param%hemisphere * ( yy - param%y ) / radius / param%fact
1177 
1178  dist = sqrt( xx*xx + yy*yy )
1179 
1180  lon = param%basepoint_lon + atan2(xx,yy) / param%c
1181 
1182  ! check hemisphere: 1=north, -1=south
1183  lat = param%hemisphere * ( 0.5_dp*pi - 2.0_dp*atan( dist**(1.0_dp/param%c) ) )
1184 
1185  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 1194 of file scale_mapprojection.F90.

1194  use scale_const, only: &
1195  undef => const_undef
1196  implicit none
1197  real(RP), intent(in) :: lon, lat ! [rad]
1198  type(mappingparam), intent(in) :: param
1199  real(RP), intent(out) :: x, y
1200 
1201  real(DP) :: xx, yy
1202  real(DP) :: dlon, latrot, dist
1203  !---------------------------------------------------------------------------
1204 
1205  if ( lon==undef .or. lat==undef ) then
1206  x = undef
1207  y = undef
1208 
1209  return
1210  end if
1211 
1212  dlon = lon - param%basepoint_lon
1213  if ( dlon > pi ) dlon = dlon - pi*2.0_dp
1214  if ( dlon < -pi ) dlon = dlon + pi*2.0_dp
1215 
1216  latrot = 0.5_dp*pi - param%hemisphere * lat
1217 
1218  dist = param%fact * radius * tan(0.5_dp*latrot)**param%c
1219 
1220  xx = param%x + dist * sin(param%c*dlon)
1221  yy = param%y - param%hemisphere * dist * cos(param%c*dlon)
1222 
1223  call xy_unrotate( xx, yy, & ! (in)
1224  param, & ! (in)
1225  x, y ) ! (out)
1226 
1227  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 1236 of file scale_mapprojection.F90.

1236  implicit none
1237  real(RP), intent(in) :: lat ! [rad]
1238  type(mappingparam), intent(in) :: param
1239  real(RP), intent(out) :: m1, m2
1240 
1241  real(DP) :: latrot
1242  !---------------------------------------------------------------------------
1243 
1244  latrot = 0.5_dp*pi - param%hemisphere * lat
1245 
1246  m1 = param%fact / sin(latrot) * param%c * tan(0.5_dp*latrot)**param%c
1247  m2 = m1
1248 
1249  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 1257 of file scale_mapprojection.F90.

1257  implicit none
1258  real(RP), intent(in) :: lon, lat
1259  type(mappingparam), intent(in) :: param
1260  real(RP), intent(out) :: rotc_cos, rotc_sin
1261 
1262  real(DP) :: dlon
1263  real(DP) :: alpha
1264  !---------------------------------------------------------------------------
1265 
1266  dlon = lon - param%basepoint_lon
1267  if ( dlon > pi ) dlon = dlon - pi*2.0_dp
1268  if ( dlon < -pi ) dlon = dlon + pi*2.0_dp
1269 
1270  alpha = - param%c * dlon * param%hemisphere &
1271  + param%rotation
1272 
1273  rotc_cos = cos( alpha )
1274  rotc_sin = sin( alpha )
1275 
1276  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 1284 of file scale_mapprojection.F90.

1284  implicit none
1285  type(mappinginfo), intent(in) :: info
1286  type(mappingparam), intent(out) :: param
1287 
1288  real(DP) :: PS_lat
1289  real(DP) :: basepoint_lat
1290  real(DP) :: basepoint_x, basepoint_y
1291 
1292  real(DP) :: lat0
1293  real(DP) :: dlon, latrot, dist
1294  !---------------------------------------------------------------------------
1295 
1296  ps_lat = info%standard_parallel(1)
1297 
1298  basepoint_lat = info%latitude_of_projection_origin
1299  basepoint_x = info%false_easting
1300  basepoint_y = info%false_northing
1301 
1302  ! check hemisphere: 1=north, -1=south
1303  param%hemisphere = sign(1.0_dp,ps_lat)
1304 
1305  lat0 = param%hemisphere * ps_lat * d2r
1306 
1307  ! pre-calc factor
1308  param%fact = 1.0_dp + sin(lat0)
1309 
1310  ! calc (x,y) at pole point
1311  dlon = 0.0_dp
1312 
1313  latrot = 0.5_dp*pi - param%hemisphere * basepoint_lat * d2r
1314 
1315  dist = param%fact * radius * tan(0.5_dp*latrot)
1316 
1317  param%x = basepoint_x - dist * sin(dlon)
1318  param%y = basepoint_y + param%hemisphere * dist * cos(dlon)
1319 
1320  log_newline
1321  log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'PS_lat1 = ', ps_lat
1322  log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'hemisphere = ', param%hemisphere
1323  log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'PS_fact = ', param%fact
1324  log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'pole_x = ', param%x
1325  log_info("MAPPROJECTION_get_param_PolarStereographic",*) 'pole_y = ', param%y
1326 
1327  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 1336 of file scale_mapprojection.F90.

1336  use scale_const, only: &
1337  undef => const_undef
1338  implicit none
1339  real(RP), intent(in) :: x, y
1340  type(mappingparam), intent(in) :: param
1341  real(RP), intent(out) :: lon, lat ! [rad]
1342 
1343  real(DP) :: xx, yy, dist
1344  !---------------------------------------------------------------------------
1345 
1346  if ( x==undef .or. y==undef ) then
1347  lon = undef
1348  lat = undef
1349 
1350  return
1351  end if
1352 
1353  call xy_rotate( x, y, & ! (in)
1354  param, & ! (in)
1355  xx, yy ) ! (out)
1356 
1357  xx = ( xx - param%x ) / radius / param%fact
1358  yy = - param%hemisphere * ( yy - param%y ) / radius / param%fact
1359 
1360  dist = sqrt( xx*xx + yy*yy )
1361 
1362  lon = param%basepoint_lon + atan2(xx,yy)
1363  lat = param%hemisphere * ( 0.5_dp*pi - 2.0_dp*atan(dist) )
1364 
1365  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 1374 of file scale_mapprojection.F90.

1374  use scale_const, only: &
1375  undef => const_undef
1376  implicit none
1377  real(RP), intent(in) :: lon, lat ! [rad]
1378  type(mappingparam), intent(in) :: param
1379  real(RP), intent(out) :: x, y
1380 
1381  real(DP) :: dlon, latrot, dist
1382  real(DP) :: xx, yy
1383  !---------------------------------------------------------------------------
1384 
1385  if ( lon==undef .or. lat==undef ) then
1386  x = undef
1387  y = undef
1388 
1389  return
1390  end if
1391 
1392  dlon = lon - param%basepoint_lon
1393 
1394  latrot = 0.5_dp*pi - param%hemisphere * lat
1395 
1396  dist = param%fact * radius * tan(0.5_dp*latrot)
1397 
1398  xx = param%x + dist * sin(dlon)
1399  yy = param%y - param%hemisphere * dist * cos(dlon)
1400 
1401  call xy_unrotate( xx, yy, & ! (in)
1402  param, & ! (in)
1403  x, y ) ! (out)
1404 
1405  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 1414 of file scale_mapprojection.F90.

1414  implicit none
1415  real(RP), intent(in) :: lat ! [rad]
1416  type(mappingparam), intent(in) :: param
1417  real(RP), intent(out) :: m1, m2
1418  !---------------------------------------------------------------------------
1419 
1420  m1 = param%fact / ( 1.0_dp + sin(param%hemisphere*lat) )
1421  m2 = m1
1422 
1423  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 1431 of file scale_mapprojection.F90.

1431  implicit none
1432  real(RP), intent(in) :: lon, lat
1433  type(mappingparam), intent(in) :: param
1434  real(RP), intent(out) :: rotc_cos, rotc_sin
1435 
1436  real(DP) :: dlon
1437  real(DP) :: alpha
1438  !---------------------------------------------------------------------------
1439 
1440  dlon = lon - param%basepoint_lon
1441  if ( dlon > pi ) dlon = dlon - pi*2.0_dp
1442  if ( dlon < -pi ) dlon = dlon + pi*2.0_dp
1443 
1444  alpha = - dlon * param%hemisphere &
1445  + param%rotation
1446 
1447  rotc_cos = cos( alpha )
1448  rotc_sin = sin( alpha )
1449 
1450  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 1458 of file scale_mapprojection.F90.

1458  use scale_prc, only: &
1459  prc_abort
1460  implicit none
1461  type(mappinginfo), intent(in) :: info
1462  type(mappingparam), intent(out) :: param
1463 
1464  real(DP) :: M_lat
1465  real(DP) :: basepoint_lat
1466  real(DP) :: basepoint_x, basepoint_y
1467 
1468  real(DP) :: lat0
1469  real(DP) :: latrot, dist
1470  !---------------------------------------------------------------------------
1471 
1472  m_lat = info%standard_parallel(1)
1473 
1474  basepoint_lat = info%latitude_of_projection_origin
1475  basepoint_x = info%false_easting
1476  basepoint_y = info%false_northing
1477 
1478  lat0 = m_lat * d2r
1479 
1480  ! pre-calc factor
1481  param%fact = cos(lat0)
1482 
1483  if ( param%fact == 0.0_dp ) then
1484  log_error("MAPPROJECTION_get_param_Mercator",*) 'M_lat cannot be set to pole point! value=', m_lat
1485  call prc_abort
1486  endif
1487 
1488  ! calc (x,y) at (lon,lat) = (base,0)
1489  latrot = 0.5_dp*pi - basepoint_lat * d2r
1490 
1491  dist = 1.0_dp / tan(0.5_dp*latrot)
1492 
1493  param%x = basepoint_x
1494  param%y = basepoint_y - radius * param%fact * log(dist)
1495 
1496  log_newline
1497  log_info("MAPPROJECTION_get_param_Mercator",*) 'M_lat = ', m_lat
1498  log_info("MAPPROJECTION_get_param_Mercator",*) 'M_fact = ', param%fact
1499  log_info("MAPPROJECTION_get_param_Mercator",*) 'eq_x = ', param%x
1500  log_info("MAPPROJECTION_get_param_Mercator",*) 'eq_y = ', param%y
1501 
1502  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 1511 of file scale_mapprojection.F90.

1511  use scale_const, only: &
1512  undef => const_undef
1513  implicit none
1514  real(RP), intent(in) :: x, y
1515  type(mappingparam), intent(in) :: param
1516  real(RP), intent(out) :: lon, lat ! [rad]
1517 
1518  real(DP) :: xx, yy
1519  !---------------------------------------------------------------------------
1520 
1521  if ( x==undef .or. y==undef ) then
1522  lon = undef
1523  lat = undef
1524 
1525  return
1526  end if
1527 
1528  call xy_rotate( x, y, & ! (in)
1529  param, & ! (in)
1530  xx, yy ) ! (out)
1531 
1532  xx = ( xx - param%x ) / radius / param%fact
1533  yy = ( yy - param%y ) / radius / param%fact
1534 
1535  lon = xx + param%basepoint_lon
1536 
1537  lat = 0.5_dp*pi - 2.0_dp*atan( 1.0_dp/exp(yy) )
1538 
1539  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 1548 of file scale_mapprojection.F90.

1548  use scale_const, only: &
1549  undef => const_undef
1550  implicit none
1551  real(RP), intent(in) :: lon, lat ! [rad]
1552  type(mappingparam), intent(in) :: param
1553  real(RP), intent(out) :: x, y
1554 
1555  real(DP) :: dlon, latrot, dist
1556  !---------------------------------------------------------------------------
1557 
1558  if ( lon==undef .or. lat==undef ) then
1559  x = undef
1560  y = undef
1561 
1562  return
1563  end if
1564 
1565  dlon = lon - param%basepoint_lon
1566 
1567  latrot = 0.5_dp*pi - lat
1568 
1569  dist = 1.0_dp / tan(0.5_dp*latrot)
1570 
1571  x = param%x + radius * param%fact * dlon
1572  y = param%y + radius * param%fact * log(dist)
1573 
1574  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 1583 of file scale_mapprojection.F90.

1583  implicit none
1584  real(RP), intent(in) :: lat ! [rad]
1585  type(mappingparam), intent(in) :: param
1586  real(RP), intent(out) :: m1, m2
1587  !---------------------------------------------------------------------------
1588 
1589  m1 = param%fact / cos(real(lat,kind=dp))
1590  m2 = m1
1591 
1592  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 1600 of file scale_mapprojection.F90.

1600  implicit none
1601  real(RP), intent(in) :: lon, lat
1602  type(mappingparam), intent(in) :: param
1603  real(RP), intent(out) :: rotc_cos, rotc_sin
1604  !---------------------------------------------------------------------------
1605 
1606  rotc_cos = param%rot_fact_cos
1607  rotc_sin = param%rot_fact_sin
1608 
1609  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 1617 of file scale_mapprojection.F90.

1617  use scale_prc, only: &
1618  prc_abort
1619  implicit none
1620  type(mappinginfo), intent(in) :: info
1621  type(mappingparam), intent(out) :: param
1622 
1623  real(DP) :: EC_lat
1624  real(DP) :: basepoint_lat
1625  real(DP) :: basepoint_x, basepoint_y
1626 
1627  real(DP) :: lat0
1628  !---------------------------------------------------------------------------
1629 
1630  ec_lat = info%standard_parallel(1)
1631 
1632  basepoint_lat = info%latitude_of_projection_origin
1633  basepoint_x = info%false_easting
1634  basepoint_y = info%false_northing
1635 
1636  lat0 = ec_lat * d2r
1637 
1638  ! pre-calc factor
1639  param%fact = cos(lat0)
1640 
1641  if ( param%fact == 0.0_dp ) then
1642  log_error("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'EC_lat cannot be set to pole point! value=', ec_lat
1643  call prc_abort
1644  endif
1645 
1646  param%x = basepoint_x
1647  param%y = basepoint_y - radius * basepoint_lat * d2r
1648 
1649  log_newline
1650  log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'EC_lat = ', ec_lat
1651  log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'EC_fact = ', param%fact
1652  log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'eq_x = ', param%x
1653  log_info("MAPPROJECTION_get_param_EquidistantCylindrical",*) 'eq_y = ', param%y
1654 
1655  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 1664 of file scale_mapprojection.F90.

1664  use scale_prc, only: &
1665  prc_abort
1666  use scale_const, only: &
1667  undef => const_undef
1668  implicit none
1669  real(RP), intent(in) :: x, y
1670  type(mappingparam), intent(in) :: param
1671  real(RP), intent(out) :: lon, lat ! [rad]
1672 
1673  real(DP) :: xx, yy
1674  !---------------------------------------------------------------------------
1675 
1676  if ( x==undef .or. y==undef ) then
1677  lon = undef
1678  lat = undef
1679 
1680  return
1681  end if
1682 
1683  call xy_rotate( x, y, & ! (in)
1684  param, & ! (in)
1685  xx, yy ) ! (out)
1686 
1687  xx = ( xx - param%x ) / radius / param%fact
1688  yy = ( yy - param%y ) / radius
1689 
1690  lon = xx + param%basepoint_lon
1691  lat = yy
1692 
1693  if ( abs(lat) > 0.5_dp*pi ) then
1694  log_error("MAPPROJECTION_EquidistantCylindrical_xy2lonlat",*) 'Invalid latitude range! value=', lat
1695  call prc_abort
1696  endif
1697 
1698  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 1707 of file scale_mapprojection.F90.

1707  use scale_const, only: &
1708  undef => const_undef
1709  implicit none
1710  real(RP), intent(in) :: lon, lat ! [rad]
1711  type(mappingparam), intent(in) :: param
1712  real(RP), intent(out) :: x, y
1713 
1714  real(DP) :: dlon
1715  real(DP) :: xx, yy
1716  !---------------------------------------------------------------------------
1717 
1718  if ( lon==undef .or. lat==undef ) then
1719  x = undef
1720  y = undef
1721 
1722  return
1723  end if
1724 
1725  dlon = lon - param%basepoint_lon
1726 
1727  xx = param%x + radius * param%fact * dlon
1728  yy = param%y + radius * lat
1729 
1730  call xy_unrotate( xx, yy, & ! (in)
1731  param, & ! (in)
1732  x, y ) ! (out)
1733 
1734  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 1743 of file scale_mapprojection.F90.

1743  implicit none
1744  real(RP), intent(in) :: lat ! [rad]
1745  type(mappingparam), intent(in) :: param
1746  real(RP), intent(out) :: m1, m2
1747 
1748  real(DP) :: mm1, mm2
1749  !---------------------------------------------------------------------------
1750 
1751  mm1 = param%fact / cos(real(lat,kind=dp))
1752  mm2 = 1.0_dp
1753 
1754  m1 = sqrt( (param%rot_fact_cos * mm1)**2 + (param%rot_fact_sin * mm2)**2 )
1755  m2 = sqrt( (param%rot_fact_cos * mm2)**2 + (param%rot_fact_sin * mm1)**2 )
1756 
1757  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 1765 of file scale_mapprojection.F90.

1765  implicit none
1766  real(RP), intent(in) :: lon, lat
1767  type(mappingparam), intent(in) :: param
1768  real(RP), intent(out) :: rotc_cos, rotc_sin
1769  !---------------------------------------------------------------------------
1770 
1771  rotc_cos = param%rot_fact_cos
1772  rotc_sin = param%rot_fact_sin
1773 
1774  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(), and mapprojection_setup().

◆ 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(), and mapprojection_setup().

◆ mapprojection_mappinginfo

type(mappinginfo), save, public scale_mapprojection::mapprojection_mappinginfo

Definition at line 104 of file scale_mapprojection.F90.

104  type(mappinginfo), public, save :: 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().

scale_prc::prc_abort
subroutine, public prc_abort
Abort Process.
Definition: scale_prc.F90:350
scale_prc
module PROCESS
Definition: scale_prc.F90:11
scale_atmos_grid_cartesc_index::ie
integer, public ie
end point of inner domain: x, local
Definition: scale_atmos_grid_cartesC_index.F90:54
scale_const
module CONSTANT
Definition: scale_const.F90:11
scale_prc_cartesc
module process / cartesC
Definition: scale_prc_cartesC.F90:11
scale_atmos_grid_cartesc_index::is
integer, public is
start point of inner domain: x, local
Definition: scale_atmos_grid_cartesC_index.F90:53
scale_precision::dp
integer, parameter, public dp
Definition: scale_precision.F90:32
scale_const::const_pi
real(rp), parameter, public const_pi
pi
Definition: scale_const.F90:32
scale_mapprojection::mapprojection_mappinginfo
type(mappinginfo), save, public mapprojection_mappinginfo
Definition: scale_mapprojection.F90:104
scale_const::const_radius
real(rp), public const_radius
radius of the planet [m]
Definition: scale_const.F90:47
scale_atmos_grid_cartesc_index::js
integer, public js
start point of inner domain: y, local
Definition: scale_atmos_grid_cartesC_index.F90:55
scale_const::const_d2r
real(rp), public const_d2r
degree to radian
Definition: scale_const.F90:33
scale_const::const_undef
real(rp), public const_undef
Definition: scale_const.F90:43
scale_atmos_grid_cartesc_index::je
integer, public je
end point of inner domain: y, local
Definition: scale_atmos_grid_cartesC_index.F90:56
scale_prc_cartesc::prc_twod
logical, public prc_twod
2D experiment
Definition: scale_prc_cartesC.F90:56
Generated by   doxygen 1.8.17