module file / cartesianC More...

Data Types
type	axisattinfo

Functions/Subroutines
subroutine, public	file_cartesc_setup
	Setup. More...

subroutine, public	file_cartesc_finalize
	deallocate buffers More...

subroutine	file_cartesc_get_size_id (fid, KMAX, OKMAX, LKMAX, UKMAX, IMAXG, JMAXG, KHALO, IHALO, JHALO)

subroutine, public	file_cartesc_set_coordinates_atmos (CZ, FZ, LON, LONUY, LONXV, LONUV, LAT, LATUY, LATXV, LATUV, TOPO, LSMASK)
	set latlon and z for atmosphere More...

subroutine, public	file_cartesc_set_areavol_atmos (AREA, AREAZUY_X, AREAZXV_Y, AREAWUY_X, AREAWXV_Y, AREAUY, AREAZXY_X, AREAZUV_Y, AREAXV, AREAZUV_X, AREAZXY_Y, VOL, VOLWXY, VOLZUY, VOLZXV)
	set area and volume More...

subroutine, public	file_cartesc_set_coordinates_ocean (VOL)
	set volume for ocean More...

subroutine, public	file_cartesc_set_coordinates_land (VOL)
	set volume for land More...

subroutine, public	file_cartesc_set_coordinates_urban (VOL)
	set volume for urban More...

subroutine, public	file_cartesc_open (basename, fid, single, aggregate)
	open a netCDF file for read More...

subroutine, public	file_cartesc_create (basename, title, datatype, fid, date, subsec, haszcoord, append, aggregate, single)
	Create/open a netCDF file. More...

subroutine, public	file_cartesc_enddef (fid)
	Exit netCDF file define mode. More...

subroutine, public	file_cartesc_flush (fid)
	Flush all pending requests to a netCDF file (PnetCDF only) More...

subroutine, public	file_cartesc_close (fid)
	Close a netCDF file. More...

subroutine	file_cartesc_read_1d (basename, varname, dim_type, var, step, aggregate, allow_missing)
	interface FILE_CARTESC_read Read data from file This routine is a wrapper of the lower primitive routines More...

subroutine	file_cartesc_read_var_2d (fid, varname, dim_type, var, step, allow_missing)
	Read 2D data from file. More...

subroutine	file_cartesc_read_var_3d (fid, varname, dim_type, var, step, allow_missing)
	Read 3D data from file. More...

subroutine	file_cartesc_read_var_4d (fid, varname, dim_type, step, var, allow_missing)
	Read 4D data from file. More...

subroutine	file_cartesc_read_auto_2d (fid, varname, var, step, existed)
	Read 2D data from file. More...

subroutine	file_cartesc_read_auto_3d (fid, varname, var, step, existed)
	Read 3D data from file. More...

subroutine	file_cartesc_write_1d (var, basename, title, varname, desc, unit, dim_type, datatype, date, subsec, append, aggregate, standard_name, cell_measures)
	interface FILE_CARTESC_write Write data to file This routine is a wrapper of the lowere primitive routines More...

subroutine, public	file_cartesc_put_globalattributes (fid, prc_rank_x, prc_rank_y, prc_num_x, prc_num_y, prc_periodic_x, prc_periodic_y, kmax, okmax, lkmax, ukmax, imaxg, jmaxg, khalo, ihalo, jhalo, time, tunits, calendar)
	put global attributes More...

subroutine	file_cartesc_def_axes (fid, dtype, hasZ)
	define axis variables in the file More...

subroutine	file_cartesc_write_axes (fid, haszcoord, start)
	write axis to the file More...

subroutine, public	file_cartesc_def_var (fid, varname, desc, unit, dim_type, datatype, vid, standard_name, timeintv, nsteps, cell_measures)
	Define a variable to file. More...

subroutine	file_cartesc_write_var_1d (fid, vid, var, varname, dim_type)
	Write 1D data to file. More...

subroutine	file_cartesc_write_var_2d (fid, vid, var, varname, dim_type, fill_halo)
	Write 2D data to file. More...

subroutine	file_cartesc_write_var_3d (fid, vid, var, varname, dim_type, fill_halo)
	Write 3D data to file. More...

subroutine	file_cartesc_write_var_3d_t (fid, vid, var, varname, dim_type, timeintv, timetarg, timeofs, fill_halo)
	Write 3D data with time dimension to file. More...

subroutine	file_cartesc_write_var_4d (fid, vid, var, varname, dim_type, timeintv, timetarg, timeofs, fill_halo)
	Write 4D data to file. More...

subroutine	set_dimension_informations

subroutine	set_dimension (name, ndims, dims, size, mapping, area, area_x, area_y, volume, location, grid)

subroutine	construct_derived_datatype
	construct MPI derived datatypes for read buffers More...

subroutine	free_derived_datatype
	free MPI derived datatypes More...

Detailed Description

module file / cartesianC

Description: file I/O handling for the cartesianC grid

Author: Team SCALE

NAMELIST

PARAM_FILE_CARTESC

name type default value comment

FILE_CARTESC_DATACHECK_CRITERIA real(RP)

History Output: No history output

Function/Subroutine Documentation

◆ file_cartesc_setup()

subroutine, public scale_file_cartesc::file_cartesc_setup

Setup.

Definition at line 215 of file scale_file_cartesC.F90.

     use scale_prc, only: &
        prc_myrank, &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_2drank, &
        prc_num_x, &
        prc_num_y
     use scale_file, only: &
        file_setup
     implicit none
  
     namelist / param_file_cartesc / &
        file_cartesc_datacheck_criteria
  
     integer :: IM, JM
     integer :: ierr
     !---------------------------------------------------------------------------
  
     call file_setup( prc_myrank )
  
  
     log_newline
     log_info("FILE_CARTESC_setup",*) 'Setup'
  
     file_cartesc_datacheck_criteria = 0.1_rp**(rp)
  
     !--- read namelist
     rewind(io_fid_conf)
     read(io_fid_conf,nml=param_file_cartesc,iostat=ierr)
     if( ierr < 0 ) then !--- missing
        log_info("FILE_CARTESC_setup",*) 'Not found namelist. Default used.'
     elseif( ierr > 0 ) then !--- fatal error
        log_error("FILE_CARTESC_setup",*) 'Not appropriate names in namelist PARAM_FILE_CARTESC. Check!'
        call prc_abort
     endif
     log_nml(param_file_cartesc)
  
     log_newline
     log_info("FILE_CARTESC_setup",*) 'NetCDF header information '
     log_info_cont(*) 'Data source : ', trim(h_source)
     log_info_cont(*) 'Institute   : ', trim(h_institute)
  
     log_newline
     log_info("FILE_CARTESC_setup",*) 'Data consistency criteria : ', &
                                    '(file-internal)/internal = ', file_cartesc_datacheck_criteria
  
     ! construct indices independent from PRC_PERIODIC_X/Y
     isb2 = is
     if( prc_2drank(prc_myrank,1) == 0           ) isb2 = 1
     ieb2 = ie
     if( prc_2drank(prc_myrank,1) == prc_num_x-1 ) ieb2 = ia
  
     jsb2 = js
     if( prc_2drank(prc_myrank,2) == 0           ) jsb2 = 1
     jeb2 = je
     if( prc_2drank(prc_myrank,2) == prc_num_y-1 ) jeb2 = ja
  
     im = ieb2 - isb2 + 1
     jm = jeb2 - jsb2 + 1
     allocate( axis_hgt(kmax  ,im,jm) )
     allocate( axis_hgtwxy(kmax+1,im,jm) )
  
     allocate( axis_lon(im,jm) )
     allocate( axis_lonuy(im,jm) )
     allocate( axis_lonxv(im,jm) )
     allocate( axis_lonuv(im,jm) )
     allocate( axis_lat(im,jm) )
     allocate( axis_latuy(im,jm) )
     allocate( axis_latxv(im,jm) )
     allocate( axis_latuv(im,jm) )
  
     allocate( axis_topo(im,jm) )
     allocate( axis_lsmask(im,jm) )
  
     allocate( axis_area(       im,jm) )
     allocate( axis_areazuy_x(kmax,  im,jm) )
     allocate( axis_areazxv_y(kmax,  im,jm) )
     allocate( axis_areawuy_x(kmax+1,im,jm) )
     allocate( axis_areawxv_y(kmax+1,im,jm) )
     allocate( axis_areauy(       im,jm) )
     allocate( axis_areazxy_x(kmax,  im,jm) )
     allocate( axis_areazuv_y(kmax,  im,jm) )
     allocate( axis_areaxv(       im,jm) )
     allocate( axis_areazuv_x(kmax,  im,jm) )
     allocate( axis_areazxy_y(kmax,  im,jm) )
  
     allocate( axis_vol(kmax  ,im,jm) )
     allocate( axis_volwxy(kmax+1,im,jm) )
     allocate( axis_volzuy(kmax  ,im,jm) )
     allocate( axis_volzxv(kmax  ,im,jm) )
  
     allocate( axis_volo(okmax,im,jm) )
     allocate( axis_voll(lkmax,im,jm) )
     allocate( axis_volu(ukmax,im,jm) )
  
     call construct_derived_datatype
  
     write_buf_amount(:) = 0
  
     return

References construct_derived_datatype(), scale_file::file_setup(), scale_io::h_institute, scale_io::h_source, scale_atmos_grid_cartesc_index::ia, scale_atmos_grid_cartesc_index::ie, scale_io::io_fid_conf, scale_atmos_grid_cartesc_index::is, scale_atmos_grid_cartesc_index::ja, scale_atmos_grid_cartesc_index::je, scale_atmos_grid_cartesc_index::js, scale_atmos_grid_cartesc_index::kmax, scale_land_grid_cartesc_index::lkmax, scale_ocean_grid_cartesc_index::okmax, scale_prc_cartesc::prc_2drank, scale_prc::prc_abort(), scale_prc::prc_myrank, scale_prc_cartesc::prc_num_x, scale_prc_cartesc::prc_num_y, scale_precision::rp, and scale_urban_grid_cartesc_index::ukmax.

Referenced by mod_rm_driver::rm_driver(), and mod_rm_prep::rm_prep().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_finalize()

subroutine, public scale_file_cartesc::file_cartesc_finalize

deallocate buffers

Definition at line 320 of file scale_file_cartesC.F90.

     implicit none
  
     integer :: n
     !---------------------------------------------------------------------------
  
     do n = 1, nfiles
        call file_cartesc_close( fids(nfiles) )
     end do
     nfiles = 0
  
     deallocate( axis_hgt    )
     deallocate( axis_hgtwxy )
  
     deallocate( axis_lon   )
     deallocate( axis_lonuy )
     deallocate( axis_lonxv )
     deallocate( axis_lonuv )
     deallocate( axis_lat   )
     deallocate( axis_latuy )
     deallocate( axis_latxv )
     deallocate( axis_latuv )
  
     deallocate( axis_topo   )
     deallocate( axis_lsmask )
  
     deallocate( axis_area      )
     deallocate( axis_areazuy_x )
     deallocate( axis_areazxv_y )
     deallocate( axis_areawuy_x )
     deallocate( axis_areawxv_y )
     deallocate( axis_areauy    )
     deallocate( axis_areazxy_x )
     deallocate( axis_areazuv_y )
     deallocate( axis_areaxv    )
     deallocate( axis_areazuv_x )
     deallocate( axis_areazxy_y )
  
     deallocate( axis_vol    )
     deallocate( axis_volwxy )
     deallocate( axis_volzuy )
     deallocate( axis_volzxv )
  
     deallocate( axis_volo )
     deallocate( axis_voll )
     deallocate( axis_volu )
  
     call free_derived_datatype
  
     set_coordinates = .false.
  
     return

References file_cartesc_close(), file_cartesc_get_size_id(), scale_file::file_open(), free_derived_datatype(), scale_atmos_grid_cartesc_index::ihalo, scale_atmos_grid_cartesc_index::imaxg, scale_atmos_grid_cartesc_index::jhalo, scale_atmos_grid_cartesc_index::jmaxg, scale_atmos_grid_cartesc_index::khalo, scale_atmos_grid_cartesc_index::kmax, scale_land_grid_cartesc_index::lkmax, scale_ocean_grid_cartesc_index::okmax, and scale_urban_grid_cartesc_index::ukmax.

Referenced by mod_rm_driver::rm_driver(), and mod_rm_prep::rm_prep().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_get_size_id()

subroutine scale_file_cartesc::file_cartesc_get_size_id	(	integer, intent(in)	fid,
		integer, intent(out)	KMAX,
		integer, intent(out)	OKMAX,
		integer, intent(out)	LKMAX,
		integer, intent(out)	UKMAX,
		integer, intent(out)	IMAXG,
		integer, intent(out)	JMAXG,
		integer, intent(out)	KHALO,
		integer, intent(out)	IHALO,
		integer, intent(out)	JHALO
	)

Definition at line 412 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_attribute
  
     integer, intent(in) :: fid
  
     integer, intent(out) :: KMAX, OKMAX, LKMAX, UKMAX
     integer, intent(out) :: IMAXG, JMAXG
     integer, intent(out) :: KHALO, IHALO, JHALO
  
     integer :: buf(1)
     logical :: existed
  
     call file_get_attribute( fid, "global", "scale_atmos_grid_cartesC_index_kmax",  buf(:)  )
     kmax = buf(1)
     call file_get_attribute( fid, "global", "scale_ocean_grid_cartesC_index_kmax",  buf(:), existed=existed  )
     if ( existed ) then
        okmax = buf(1)
     else
        okmax = -1
     end if
     call file_get_attribute( fid, "global", "scale_land_grid_cartesC_index_kmax",  buf(:), existed=existed  )
     if ( existed ) then
        lkmax = buf(1)
     else
        lkmax = -1
     end if
     call file_get_attribute( fid, "global", "scale_urban_grid_cartesC_index_kmax",  buf(:), existed=existed  )
     if ( existed ) then
        ukmax = buf(1)
     else
        ukmax = -1
     end if
  
     call file_get_attribute( fid, "global", "scale_atmos_grid_cartesC_index_imaxg", buf(:)  )
     imaxg = buf(1)
     call file_get_attribute( fid, "global", "scale_atmos_grid_cartesC_index_jmaxg", buf(:)  )
     jmaxg = buf(1)
  
     call file_get_attribute( fid, "global", "scale_atmos_grid_cartesC_index_khalo", buf(:)  )
     khalo = buf(1)
     call file_get_attribute( fid, "global", "scale_atmos_grid_cartesC_index_ihalo", buf(:)  )
     ihalo = buf(1)
     call file_get_attribute( fid, "global", "scale_atmos_grid_cartesC_index_jhalo", buf(:)  )
     jhalo = buf(1)
  
     return

Referenced by file_cartesc_finalize().

Here is the caller graph for this function:

◆ file_cartesc_set_coordinates_atmos()

subroutine, public scale_file_cartesc::file_cartesc_set_coordinates_atmos	(	real(rp), dimension( ka,ia,ja), intent(in)	CZ,
		real(rp), dimension(0:ka,ia,ja), intent(in)	FZ,
		real(rp), dimension ( ia, ja), intent(in)	LON,
		real(rp), dimension(0:ia, ja), intent(in)	LONUY,
		real(rp), dimension( ia,0:ja), intent(in)	LONXV,
		real(rp), dimension(0:ia,0:ja), intent(in)	LONUV,
		real(rp), dimension ( ia, ja), intent(in)	LAT,
		real(rp), dimension(0:ia, ja), intent(in)	LATUY,
		real(rp), dimension( ia,0:ja), intent(in)	LATXV,
		real(rp), dimension(0:ia,0:ja), intent(in)	LATUV,
		real(rp), dimension ( ia, ja), intent(in)	TOPO,
		real(rp), dimension( ia, ja), intent(in)	LSMASK
	)

set latlon and z for atmosphere

Definition at line 467 of file scale_file_cartesC.F90.

     use scale_const, only: &
        d2r => const_d2r
     implicit none
  
     real(RP), intent(in) :: CZ(  KA,IA,JA)
     real(RP), intent(in) :: FZ(0:KA,IA,JA)
     real(RP), intent(in) :: LON  (  IA,  JA)
     real(RP), intent(in) :: LONUY(0:IA,  JA)
     real(RP), intent(in) :: LONXV(  IA,0:JA)
     real(RP), intent(in) :: LONUV(0:IA,0:JA)
     real(RP), intent(in) :: LAT  (  IA,  JA)
     real(RP), intent(in) :: LATUY(0:IA,  JA)
     real(RP), intent(in) :: LATXV(  IA,0:JA)
     real(RP), intent(in) :: LATUV(0:IA,0:JA)
     real(RP), intent(in) :: TOPO  (  IA,  JA)
     real(RP), intent(in) :: LSMASK(  IA,  JA)
     !---------------------------------------------------------------------------
  
     axis_hgt(:,:,:) = cz(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_hgtwxy(:,:,:) = fz(ks-1:ke,isb2:ieb2,jsb2:jeb2)
  
     axis_lon(:,:) = lon(isb2:ieb2,jsb2:jeb2) / d2r
     axis_lonuy(:,:) = lonuy(isb2:ieb2,jsb2:jeb2) / d2r
     axis_lonxv(:,:) = lonxv(isb2:ieb2,jsb2:jeb2) / d2r
     axis_lonuv(:,:) = lonuv(isb2:ieb2,jsb2:jeb2) / d2r
     axis_lat(:,:) = lat(isb2:ieb2,jsb2:jeb2) / d2r
     axis_latuy(:,:) = latuy(isb2:ieb2,jsb2:jeb2) / d2r
     axis_latxv(:,:) = latxv(isb2:ieb2,jsb2:jeb2) / d2r
     axis_latuv(:,:) = latuv(isb2:ieb2,jsb2:jeb2) / d2r
  
     axis_topo(:,:) = topo(isb2:ieb2,jsb2:jeb2)
     axis_lsmask(:,:) = lsmask(isb2:ieb2,jsb2:jeb2)
  
     set_coordinates = .true.
  
     return

References scale_const::const_d2r, scale_atmos_grid_cartesc_index::ke, and scale_atmos_grid_cartesc_index::ks.

Referenced by scale_atmos_grid_cartesc_real::atmos_grid_cartesc_real_calc_z().

Here is the caller graph for this function:

◆ file_cartesc_set_areavol_atmos()

subroutine, public scale_file_cartesc::file_cartesc_set_areavol_atmos	(	real(rp), dimension ( ia,ja), intent(in)	AREA,
		real(rp), dimension( ka,ia,ja), intent(in)	AREAZUY_X,
		real(rp), dimension( ka,ia,ja), intent(in)	AREAZXV_Y,
		real(rp), dimension(0:ka,ia,ja), intent(in)	AREAWUY_X,
		real(rp), dimension(0:ka,ia,ja), intent(in)	AREAWXV_Y,
		real(rp), dimension ( ia,ja), intent(in)	AREAUY,
		real(rp), dimension( ka,ia,ja), intent(in)	AREAZXY_X,
		real(rp), dimension( ka,ia,ja), intent(in)	AREAZUV_Y,
		real(rp), dimension ( ia,ja), intent(in)	AREAXV,
		real(rp), dimension( ka,ia,ja), intent(in)	AREAZUV_X,
		real(rp), dimension( ka,ia,ja), intent(in)	AREAZXY_Y,
		real(rp), dimension ( ka,ia,ja), intent(in)	VOL,
		real(rp), dimension(0:ka,ia,ja), intent(in)	VOLWXY,
		real(rp), dimension( ka,ia,ja), intent(in)	VOLZUY,
		real(rp), dimension( ka,ia,ja), intent(in)	VOLZXV
	)

set area and volume

Definition at line 513 of file scale_file_cartesC.F90.

     use scale_const, only: &
        d2r => const_d2r
     implicit none
     real(RP), intent(in) :: AREA     (     IA,JA)
     real(RP), intent(in) :: AREAZUY_X(  KA,IA,JA)
     real(RP), intent(in) :: AREAZXV_Y(  KA,IA,JA)
     real(RP), intent(in) :: AREAWUY_X(0:KA,IA,JA)
     real(RP), intent(in) :: AREAWXV_Y(0:KA,IA,JA)
     real(RP), intent(in) :: AREAUY   (     IA,JA)
     real(RP), intent(in) :: AREAZXY_X(  KA,IA,JA)
     real(RP), intent(in) :: AREAZUV_Y(  KA,IA,JA)
     real(RP), intent(in) :: AREAXV   (     IA,JA)
     real(RP), intent(in) :: AREAZUV_X(  KA,IA,JA)
     real(RP), intent(in) :: AREAZXY_Y(  KA,IA,JA)
     real(RP), intent(in) :: VOL   (  KA,IA,JA)
     real(RP), intent(in) :: VOLWXY(0:KA,IA,JA)
     real(RP), intent(in) :: VOLZUY(  KA,IA,JA)
     real(RP), intent(in) :: VOLZXV(  KA,IA,JA)
  
     axis_area(:,:)   = area(        isb2:ieb2,jsb2:jeb2)
     axis_areazuy_x(:,:,:) = areazuy_x(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_areazxv_y(:,:,:) = areazxv_y(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_areawuy_x(:,:,:) = areawuy_x(ks-1:ke,isb2:ieb2,jsb2:jeb2)
     axis_areawxv_y(:,:,:) = areawxv_y(ks-1:ke,isb2:ieb2,jsb2:jeb2)
     axis_areauy(:,:)   = areauy(        isb2:ieb2,jsb2:jeb2)
     axis_areazxy_x(:,:,:) = areazxy_x(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_areazuv_y(:,:,:) = areazuv_y(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_areaxv(:,:)   = areaxv(        isb2:ieb2,jsb2:jeb2)
     axis_areazuv_x(:,:,:) = areazuv_x(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_areazxy_y(:,:,:) = areazxy_y(ks  :ke,isb2:ieb2,jsb2:jeb2)
  
     axis_vol(:,:,:) = vol(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_volwxy(:,:,:) = volwxy(ks-1:ke,isb2:ieb2,jsb2:jeb2)
     axis_volzuy(:,:,:) = volzuy(ks  :ke,isb2:ieb2,jsb2:jeb2)
     axis_volzxv(:,:,:) = volzxv(ks  :ke,isb2:ieb2,jsb2:jeb2)
  
     return

References scale_const::const_d2r, scale_atmos_grid_cartesc_index::ke, and scale_atmos_grid_cartesc_index::ks.

Referenced by scale_atmos_grid_cartesc_real::atmos_grid_cartesc_real_calc_areavol().

Here is the caller graph for this function:

◆ file_cartesc_set_coordinates_ocean()

subroutine, public scale_file_cartesc::file_cartesc_set_coordinates_ocean ( real(rp), dimension(oka,oia,oja), intent(in) VOL )

set volume for ocean

Definition at line 556 of file scale_file_cartesC.F90.

     implicit none
  
     real(RP), intent(in) :: VOL(OKA,OIA,OJA)
     !---------------------------------------------------------------------------
  
     axis_volo(:,:,:) = vol(oks:oke,isb2:ieb2,jsb2:jeb2)
  
     return

References scale_ocean_grid_cartesc_index::oke, and scale_ocean_grid_cartesc_index::oks.

Referenced by scale_ocean_grid_cartesc_real::ocean_grid_cartesc_real_set_areavol().

Here is the caller graph for this function:

◆ file_cartesc_set_coordinates_land()

subroutine, public scale_file_cartesc::file_cartesc_set_coordinates_land ( real(rp), dimension(lka,lia,lja), intent(in) VOL )

set volume for land

Definition at line 570 of file scale_file_cartesC.F90.

     implicit none
  
     real(RP), intent(in) :: VOL(LKA,LIA,LJA)
     !---------------------------------------------------------------------------
  
     axis_voll(:,:,:) = vol(lks:lke,isb2:ieb2,jsb2:jeb2)
  
     return

References scale_land_grid_cartesc_index::lke, and scale_land_grid_cartesc_index::lks.

Referenced by scale_land_grid_cartesc_real::land_grid_cartesc_real_set_areavol().

Here is the caller graph for this function:

◆ file_cartesc_set_coordinates_urban()

subroutine, public scale_file_cartesc::file_cartesc_set_coordinates_urban ( real(rp), dimension(uka,uia,uja), intent(in) VOL )

set volume for urban

Definition at line 584 of file scale_file_cartesC.F90.

     implicit none
  
     real(RP), intent(in) :: VOL(UKA,UIA,UJA)
     !---------------------------------------------------------------------------
  
     axis_volu(:,:,:) = vol(uks:uke,isb2:ieb2,jsb2:jeb2)
  
     return

Referenced by scale_urban_grid_cartesc_real::urban_grid_cartesc_real_set_areavol().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_open()

subroutine, public scale_file_cartesc::file_cartesc_open	(	character(len=*), intent(in)	basename,
		integer, intent(out)	fid,
		logical, intent(in), optional	single,
		logical, intent(in), optional	aggregate
	)

open a netCDF file for read

Parameters

[in]	basename	basename of the file
[out]	fid	file ID

Definition at line 760 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        file_fread
     use scale_file, only: &
        file_aggregate, &
        file_open
     use scale_prc, only: &
        prc_myrank
     implicit none
  
     character(len=*), intent(in)  :: basename
     integer,          intent(out) :: fid
     logical,          intent(in), optional :: single
     logical,          intent(in), optional :: aggregate
     !---------------------------------------------------------------------------
  
     call prof_rapstart('FILE_Write', 2)
  
     call file_open( basename,            & ! [IN]
                     fid,                 & ! [OUT]
                     single=single,       & ! [IN]
                     aggregate=aggregate, & ! [IN]
                     rankid=prc_myrank    ) ! [IN]
  
     call prof_rapend  ('FILE_Write', 2)
  
     return

References scale_file::file_aggregate, scale_file_h::file_fread, scale_file::file_open(), scale_prc::prc_myrank, scale_prof::prof_rapend(), and scale_prof::prof_rapstart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_create()

subroutine, public scale_file_cartesc::file_cartesc_create	(	character(len=*), intent(in)	basename,
		character(len=*), intent(in)	title,
		character(len=*), intent(in)	datatype,
		integer, intent(out)	fid,
		integer, dimension(6), intent(in), optional	date,
		real(dp), intent(in), optional	subsec,
		logical, intent(in), optional	haszcoord,
		logical, intent(in), optional	append,
		logical, intent(in), optional	aggregate,
		logical, intent(in), optional	single
	)

Create/open a netCDF file.

Parameters

[in]	basename	basename of the file
[in]	title	title of the file
[in]	datatype	data type (REAL8/REAL4/default)
[out]	fid	file ID
[in]	date	ymdhms of the time
[in]	subsec	subsec of the time
[in]	append	switch whether append existing file or not (default=false)
[in]	haszcoord	switch whether include zcoordinate or not (default=true)

Definition at line 796 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        file_real8, &
        file_real4
     use scale_file, only: &
        file_aggregate,    &
        file_create,       &
        file_get_cftunits
     use scale_calendar, only: &
        calendar_get_name
     use scale_prc, only: &
        prc_myrank, &
        prc_abort
     use scale_time, only: &
        nowdate   => time_nowdate, &
        nowsubsec => time_nowsubsec
     use scale_prc_cartesc, only: &
        prc_2drank,     &
        prc_num_x,      &
        prc_num_y,      &
        prc_periodic_x, &
        prc_periodic_y
     implicit none
  
     character(len=*), intent(in)  :: basename
     character(len=*), intent(in)  :: title
     character(len=*), intent(in)  :: datatype
     integer,          intent(out) :: fid
     integer,          intent(in), optional :: date(6)
     real(DP),         intent(in), optional :: subsec
     logical,          intent(in), optional :: append
     logical,          intent(in), optional :: haszcoord
     logical,          intent(in), optional :: aggregate
     logical,          intent(in), optional :: single
  
     integer                :: dtype
     logical                :: append_sw
     character(len=34)      :: tunits
     character(len=H_SHORT) :: calendar
     real(DP)               :: subsec_
     integer                :: rank_x, rank_y
     integer                :: num_x, num_y
     logical                :: fileexisted
     logical                :: aggregate_
     logical                :: single_
     integer                :: date_(6)
     !---------------------------------------------------------------------------
  
     prof = .true.
     call prof_rapstart('FILE_Write', 2)
  
     if ( present(single) ) then
        single_ = single
     else
        single_ = .false.
     end if
  
     ! dtype is used to define the data type of axis variables in file
     if    ( datatype == 'REAL8' ) then
        dtype = file_real8
     elseif( datatype == 'REAL4' ) then
        dtype = file_real4
     else
        if    ( rp == 8 ) then
           dtype = file_real8
        elseif( rp == 4 ) then
           dtype = file_real4
        else
           log_error("FILE_CARTESC_create",*) 'unsupported data type. Check!', trim(datatype)
           call prc_abort
        endif
     endif
  
     append_sw = .false.
     if ( present(append) ) then
        append_sw = append
     endif
  
     ! create a netCDF file if not already existed. Otherwise, open it.
     if ( present(date) ) then
        date_(:) = date(:)
     else
        date_(:) = nowdate(:)
     end if
     if ( date_(1) > 0 ) then
        call file_get_cftunits( date_(:), tunits )
        call calendar_get_name( calendar )
     else
        tunits = 'seconds'
        calendar = ''
     endif
  
  
     ! check to use PnetCDF I/O
     if ( present(aggregate) ) then
        aggregate_ = aggregate
     else
        aggregate_ = file_aggregate
     endif
  
     call file_create( basename,                & ! [IN]
                       title,                   & ! [IN]
                       h_source,                & ! [IN]
                       h_institute,             & ! [IN]
                       fid,                     & ! [OUT]
                       fileexisted,             & ! [OUT]
                       rankid     = prc_myrank, & ! [IN]
                       single     = single_,    & ! [IN]
                       aggregate  = aggregate_, & ! [IN]
                       time_units = tunits,     & ! [IN]
                       calendar   = calendar,   & ! [IN]
                       append     = append_sw   ) ! [IN]
  
  
     if ( fid > 0 .and. (.not. fileexisted) ) then ! do below only once when file is created
  
        nfiles = nfiles + 1
        fids(nfiles) = fid
  
        file_axes_written(fid) = .false.  ! indicating axes have not been written yet
  
        if ( present( haszcoord ) ) then
           file_haszcoord(fid) = haszcoord
        else
           file_haszcoord(fid) = .true.
        endif
  
        if ( aggregate_ ) then
           rank_x = 0
           rank_y = 0
           num_x = 1
           num_y = 1
        else
           rank_x = prc_2drank(prc_myrank,1)
           rank_y = prc_2drank(prc_myrank,2)
           num_x = prc_num_x
           num_y = prc_num_y
        end if
  
        if ( present( subsec ) ) then
           subsec_ = subsec
        else
           subsec_= nowsubsec
        end if
  
        call file_cartesc_put_globalattributes( fid,                            & ! [IN]
                                                rank_x, rank_y,                 & ! [IN]
                                                num_x, num_y,                   & ! [IN]
                                                prc_periodic_x, prc_periodic_y, & ! [IN]
                                                kmax, okmax, lkmax, ukmax,      & ! [IN]
                                                imaxg, jmaxg,                   & ! [IN]
                                                khalo, ihalo, jhalo,            & ! [IN]
                                                subsec_, tunits, calendar       ) ! [IN]
  
        call file_cartesc_def_axes( fid,                & ! [IN]
                                    dtype,              & ! [IN]
                                    file_haszcoord(fid) ) ! [IN]
  
     end if
  
     call prof_rapend  ('FILE_Write', 2)
     prof = .false.
  
     return

References scale_calendar::calendar_get_name(), scale_file::file_aggregate, file_cartesc_def_axes(), file_cartesc_put_globalattributes(), scale_file::file_create(), scale_file::file_get_cftunits(), scale_file_h::file_real4, scale_file_h::file_real8, scale_io::h_institute, scale_io::h_source, scale_atmos_grid_cartesc_index::ihalo, scale_atmos_grid_cartesc_index::imaxg, scale_atmos_grid_cartesc_index::jhalo, scale_atmos_grid_cartesc_index::jmaxg, scale_atmos_grid_cartesc_index::khalo, scale_atmos_grid_cartesc_index::kmax, scale_land_grid_cartesc_index::lkmax, scale_ocean_grid_cartesc_index::okmax, scale_prc_cartesc::prc_2drank, scale_prc::prc_abort(), scale_prc::prc_myrank, scale_prc_cartesc::prc_num_x, scale_prc_cartesc::prc_num_y, scale_prc_cartesc::prc_periodic_x, scale_prc_cartesc::prc_periodic_y, scale_prof::prof_rapend(), scale_prof::prof_rapstart(), scale_precision::rp, scale_time::time_nowdate, scale_time::time_nowsubsec, and scale_urban_grid_cartesc_index::ukmax.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_enddef()

subroutine, public scale_file_cartesc::file_cartesc_enddef ( integer, intent(in) fid )

Exit netCDF file define mode.

Parameters

[in] fid file ID

Definition at line 964 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened,    &
        file_allnodes,  &
        file_enddef,    &
        file_flush,     &
        file_attach_buffer
     implicit none
  
     integer, intent(in) :: fid
  
     integer :: start(3)
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     call file_enddef( fid ) ! [IN]
  
     ! If this enddef is called the first time, write axis variables
     if ( .NOT. file_axes_written(fid) ) then
  
        if ( file_get_aggregate(fid) ) then
           start(1) = 1
           start(2) = isga
           start(3) = jsga
        else
           start(1) = 1
           start(2) = 1
           start(3) = 1
        endif
  
        call file_cartesc_write_axes( fid,                 & ! [IN]
                                      file_haszcoord(fid), & ! [IN]
                                      start(:)             ) ! [IN]
  
        file_axes_written(fid) = .true.
     endif
  
     ! Tell PnetCDF library to use a buffer of size write_buf_amount to aggregate write requests to be post in FILE_CARTESC_write_var
     if ( file_get_aggregate(fid) ) then
        call file_flush( fid )
        call file_attach_buffer( fid, write_buf_amount(fid) )
     endif
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

References scale_file::file_allnodes(), scale_file::file_attach_buffer(), file_cartesc_write_axes(), scale_file::file_enddef(), scale_file::file_flush(), scale_file::file_get_aggregate(), scale_file::file_opened(), scale_atmos_grid_cartesc_index::isga, scale_atmos_grid_cartesc_index::jsga, scale_prof::prof_rapend(), and scale_prof::prof_rapstart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_flush()

subroutine, public scale_file_cartesc::file_cartesc_flush ( integer, intent(in) fid )

Flush all pending requests to a netCDF file (PnetCDF only)

Parameters

[in] fid file ID

Definition at line 1018 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_flush
     implicit none
  
     integer, intent(in) :: fid
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     if ( file_get_aggregate(fid) ) then
        call file_flush( fid ) ! flush all pending read/write requests
     end if
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

References scale_file::file_allnodes(), scale_file::file_flush(), scale_file::file_get_aggregate(), scale_file::file_opened(), scale_prof::prof_rapend(), and scale_prof::prof_rapstart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_close()

subroutine, public scale_file_cartesc::file_cartesc_close ( integer, intent(in) fid )

Close a netCDF file.

Parameters

[in] fid file ID

Definition at line 1044 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened,    &
        file_allnodes,  &
        file_close,     &
        file_flush,     &
        file_detach_buffer
     implicit none
  
     integer, intent(in) :: fid
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     if ( file_get_aggregate(fid) ) then
        call file_flush( fid )        ! flush all pending read/write requests
        if ( write_buf_amount(fid) > 0 ) then
           call file_detach_buffer( fid ) ! detach PnetCDF aggregation buffer
           write_buf_amount(fid) = 0      ! reset write request amount
        endif
     endif
  
     call file_close( fid ) ! [IN]
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

References scale_file::file_allnodes(), scale_file::file_close(), scale_file::file_detach_buffer(), scale_file::file_flush(), scale_file::file_get_aggregate(), scale_file::file_opened(), scale_prof::prof_rapend(), and scale_prof::prof_rapstart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_read_1d()

subroutine scale_file_cartesc::file_cartesc_read_1d	(	character(len=*), intent(in)	basename,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		real(rp), dimension(:), intent(out)	var,
		integer, intent(in), optional	step,
		logical, intent(in), optional	aggregate,
		logical, intent(in), optional	allow_missing
	)

interface FILE_CARTESC_read Read data from file This routine is a wrapper of the lower primitive routines

Parameters

[in]	basename	basename of the file
[in]	varname	name of the variable
[in]	dim_type	dimension type (Z/X/Y)
[out]	var	value of the variable
[in]	step	step number

Definition at line 1088 of file scale_file_cartesC.F90.

     implicit none
     character(len=*), intent(in)  :: basename
     character(len=*), intent(in)  :: varname
     character(len=*), intent(in)  :: dim_type
  
     real(RP),         intent(out) :: var(:)
  
     integer,          intent(in), optional :: step
     logical,          intent(in), optional :: aggregate
     logical,          intent(in), optional :: allow_missing
  
     integer :: fid
     !---------------------------------------------------------------------------
  
     call file_cartesc_open( basename,           & ! [IN]
                             fid,                & ! [OUT]
                             aggregate=aggregate ) ! [IN]
  
     call file_cartesc_read_var_1d( fid, varname, dim_type,     & ! [IN]
                                    var(:),                     & ! [OUT]
                                    step=step,                  & ! [IN]
                                    allow_missing=allow_missing ) ! [IN]
  
     call file_cartesc_close( fid )
  
     return

Here is the call graph for this function:

◆ file_cartesc_read_var_2d()

subroutine scale_file_cartesc::file_cartesc_read_var_2d	(	integer, intent(in)	fid,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		real(rp), dimension(:,:), intent(out)	var,
		integer, intent(in), optional	step,
		logical, intent(in), optional	allow_missing
	)

Read 2D data from file.

Parameters

[in]	fid	file ID
[in]	varname	name of the variable
[in]	dim_type	dimension type (Z/X/Y)
[out]	var	value of the variable
[in]	step	step number

Definition at line 1371 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_read
     use scale_prc, only: &
        prc_abort
     implicit none
     integer,          intent(in)  :: fid
     character(len=*), intent(in)  :: varname
     character(len=*), intent(in)  :: dim_type
  
     real(RP),         intent(out) :: var(:,:)
  
     integer,          intent(in), optional :: step
     logical,          intent(in), optional :: allow_missing
  
     integer :: vsize
     integer :: ntypes, dtype
     integer, pointer :: start(:), count(:)
     integer :: dim1_S, dim1_E
     integer :: dim2_S, dim2_E
  
     real(RP), allocatable :: buf(:,:)
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     log_info("FILE_CARTESC_read_var_2D",'(1x,2A)') 'Read from file (2D), name : ', trim(varname)
  
     if ( file_get_aggregate(fid) ) then
  
        ! read data and halos into the local buffer
        if    ( dim_type == 'XY' ) then
           vsize = ia * ja
           ntypes = ia * ja
           dtype = etype
           start => startxy
           count => countxy
        elseif( dim_type == 'ZX' ) then
           ! Because KHALO is not saved in files, we use centerTypeZX, an MPI
           ! derived datatype to describe the layout of local read buffer
           vsize = ka * ia
           ntypes = 1
           dtype = centertypezx
           start => startzx
           count => countzx
        else
           log_error("FILE_CARTESC_read_var_2D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
           call prc_abort
        endif
  
        if ( size(var) .ne. vsize ) then
           log_error("FILE_CARTESC_read_var_2D",*) 'size of var is invalid: ', trim(varname), size(var), vsize
           call prc_abort
        end if
        call file_read( fid, varname,                             & ! (in)
             var(:,:),                                            & ! (out)
             step=step, allow_missing=allow_missing,              & ! (in)
             ntypes=ntypes, dtype=dtype, start=start, count=count ) ! (in)
  
     else
  
        if    ( dim_type == 'XY' ) then
           vsize = ia * ja
           dim1_s = isb
           dim1_e = ieb
           dim2_s = jsb
           dim2_e = jeb
        elseif( dim_type == 'ZX' ) then
           vsize = ka * ia
           dim1_s = ks
           dim1_e = ke
           dim2_s = isb
           dim2_e = ieb
        else
           log_error("FILE_CARTESC_read_var_2D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
           call prc_abort
        endif
  
        if ( size(var) .ne. vsize ) then
           log_error("FILE_CARTESC_read_var_2D",*) 'size of var is invalid: ', trim(varname), size(var), vsize
           call prc_abort
        end if
        allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e) )
        call file_read( fid, varname, buf(:,:), step=step )
        !$omp workshare
        var(dim1_s:dim1_e,dim2_s:dim2_e) = buf(:,:)
        !$omp endworkshare
        deallocate( buf )
  
        !$acc update device(var) if(acc_is_present(var))
     endif
  
     call prof_rapend('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_read_1d(), and file_cartesc_set_coordinates_urban().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_read_var_3d()

subroutine scale_file_cartesc::file_cartesc_read_var_3d	(	integer, intent(in)	fid,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		real(rp), dimension(:,:,:), intent(out)	var,
		integer, intent(in), optional	step,
		logical, intent(in), optional	allow_missing
	)

Read 3D data from file.

Parameters

[in]	fid	file ID
[in]	varname	name of the variable
[in]	dim_type	dimension type (Z/X/Y/T)
[out]	var	value of the variable
[in]	step	step number

Definition at line 1480 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_read
     use scale_prc, only: &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_num_x, &
        prc_num_y
     implicit none
     integer,          intent(in)  :: fid
     character(len=*), intent(in)  :: varname
     character(len=*), intent(in)  :: dim_type
  
     real(RP),         intent(out) :: var(:,:,:)
  
     integer,          intent(in), optional :: step
     logical,          intent(in), optional :: allow_missing
  
     integer :: vsize
     integer :: ntypes, dtype
     integer, pointer :: start(:), count(:)
     integer :: dim1_S, dim1_E
     integer :: dim2_S, dim2_E
     integer :: dim3_S, dim3_E
     real(RP), allocatable :: buf(:,:,:)
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     log_info("FILE_CARTESC_read_var_3D",'(1x,2A)') 'Read from file (3D), name : ', trim(varname)
  
     if ( file_get_aggregate(fid) ) then
  
        ! read data and halos into the local buffer
        ! Because KHALO is not saved in files, we use mpi derived datatypes to
        ! describe the layout of local read buffer
        if(      dim_type == 'ZXY'  &
            .or. dim_type == 'ZXHY' &
            .or. dim_type == 'ZXYH' ) then
           vsize = ka * ia * ja
           ntypes = 1
           dtype = centertypezxy
           start => startzxy
           count => countzxy
        elseif( dim_type == 'ZHXY' ) then
           vsize = ka * ia * ja
           ntypes = 1
           dtype = centertypezhxy
           start => startzhxy
           count => countzhxy
        elseif( dim_type == 'XYT' ) then
           if ( .not. present(step) ) then
              log_error("FILE_CARTESC_read_var_3D",*) 'step is necessary for "XYT"'
              call prc_abort
           end if
           vsize = ia * ja * step
           ntypes = ia * ja * step
           dtype = etype
           startxy(3) = 1
           countxy(3) = step
           start => startxy
           count => countxy
        elseif( dim_type == 'OXY' ) then
           vsize = oka * oia * oja
           ntypes = 1
           dtype = centertypeocean
           start => startocean
           count => countocean
        elseif( dim_type == 'LXY' ) then
           vsize = lka * lia * lja
           ntypes = 1
           dtype = centertypeland
           start => startland
           count => countland
        elseif( dim_type == 'UXY' ) then
           vsize = uka * uia * uja
           ntypes = 1
           dtype = centertypeurban
           start => starturban
           count => counturban
        else
           log_error("FILE_CARTESC_read_var_3D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
           call prc_abort
        endif
  
        if ( size(var) .ne. vsize ) then
           log_error("FILE_CARTESC_read_var_3D",*) 'size of var is invalid: ', trim(varname), size(var), vsize
           call prc_abort
        end if
        call file_read( fid, varname,                             & ! (in)
             var(:,:,:),                                          & ! (out)
             step=step, allow_missing=allow_missing,              & ! (in)
             ntypes=ntypes, dtype=dtype, start=start, count=count ) ! (in)
  
     else
        if(      dim_type == 'ZXY'  &
            .or. dim_type == 'ZXHY' &
            .or. dim_type == 'ZXYH' ) then
           vsize = ka * ia * ja
           dim1_s = ks
           dim1_e = ke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif( dim_type == 'ZHXY' ) then
           vsize = ka * ia * ja
           dim1_s = ks-1
           dim1_e = ke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif( dim_type == 'XYT' ) then
           if ( .not. present(step) ) then
              log_error("FILE_CARTESC_read_var_3D",*) 'step is necessary for "XYT"'
              call prc_abort
           end if
           vsize = ia * ja * step
           dim1_s = isb
           dim1_e = ieb
           dim2_s = jsb
           dim2_e = jeb
           dim3_s = 1
           dim3_e = step
        elseif( dim_type == 'OXY' ) then
           vsize = oka * oia * oja
           dim1_s = oks
           dim1_e = oke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif( dim_type == 'LXY' ) then
           vsize = lka * lia * lja
           dim1_s = lks
           dim1_e = lke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif( dim_type == 'UXY' ) then
           vsize = uka * uia * uja
           dim1_s = uks
           dim1_e = uke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        else
           log_error("FILE_CARTESC_read_var_3D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
           call prc_abort
        endif
  
        if ( size(var) .ne. vsize ) then
           log_error("FILE_CARTESC_read_var_3D",*) 'size of var is invalid: ', trim(varname), size(var), vsize
           call prc_abort
        end if
  
        allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e,dim3_s:dim3_e) )
        call file_read( fid, varname, buf(:,:,:), &
                        step=step, allow_missing=allow_missing )
        !$omp workshare
        var(dim1_s:dim1_e,dim2_s:dim2_e,dim3_s:dim3_e) = buf(:,:,:)
        !$omp end workshare
        deallocate( buf )
  
        !$acc update device(var) if(acc_is_present(var))
     endif
  
     call prof_rapend('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_read_1d(), and file_cartesc_set_coordinates_urban().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_read_var_4d()

subroutine scale_file_cartesc::file_cartesc_read_var_4d	(	integer, intent(in)	fid,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		integer, intent(in)	step,
		real(rp), dimension(:,:,:,:), intent(out)	var,
		logical, intent(in), optional	allow_missing
	)

Read 4D data from file.

Parameters

[in]	fid	file ID
[in]	varname	name of the variable
[in]	dim_type	dimension type (Z/X/Y/Time)
[in]	step	step number
[out]	var	value of the variable

Definition at line 1667 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_read
     use scale_prc, only: &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_num_x, &
        prc_num_y
     implicit none
     integer,          intent(in)  :: fid
     character(len=*), intent(in)  :: varname
     character(len=*), intent(in)  :: dim_type
     integer,          intent(in)  :: step
  
     real(RP),         intent(out) :: var(:,:,:,:)
  
     logical,          intent(in), optional :: allow_missing
  
     integer :: vsize
     integer :: dtype
     integer, pointer :: start(:), count(:)
     integer :: dim1_S, dim1_E
     integer :: dim2_S, dim2_E
     integer :: dim3_S, dim3_E
     integer :: dim4_S, dim4_E
  
     real(RP), allocatable :: buf(:,:,:,:)
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     log_info("FILE_CARTESC_read_var_4D",'(1x,2A)') 'Read from file (4D), name : ', trim(varname)
  
     if ( file_get_aggregate(fid) ) then
        ! read data and halos into the local buffer
        if (      dim_type == 'ZXYT'  &
             .or. dim_type == 'ZXHYT' &
             .or. dim_type == 'ZXYHT' ) then
           vsize = ka * ia * ja * step
           dtype = centertypezxy
           start => startzxy
           count => countzxy
        elseif ( dim_type == 'ZHXYT' ) then
           vsize = ka * ia * ja * step
           dtype = centertypezhxy
           start => startzhxy
           count => countzhxy
        elseif ( dim_type == 'OXYT' ) then
           vsize = oka * oia * oja * step
           dtype = centertypeocean
           start => startocean
           count => countocean
        elseif ( dim_type == 'LXYT' ) then
           vsize = lka * lia * lja * step
           dtype = centertypeland
           start => startland
           count => countland
        elseif ( dim_type == 'UXYT' ) then
           vsize = uka * uia * uja * step
           dtype = centertypeurban
           start => starturban
           count => counturban
        else
           log_error("FILE_CARTESC_read_var_4D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
           call prc_abort
        endif
  
        if ( size(var) .ne. vsize ) then
           log_error("FILE_CARTESC_read_var_4D",*) 'size of var is invalid: ', trim(varname), size(var), vsize
           call prc_abort
        end if
        start(4) = 1
        count(4) = step
        call file_read( fid, varname,                           & ! (in)
             var(:,:,:,:),                                      & ! (out)
             allow_missing=allow_missing,                       & ! (in)
             ntypes=step, dtype=dtype, start=start, count=count ) ! (in)
  
     else
        if (      dim_type == 'ZXYT'  &
             .or. dim_type == 'ZXHYT' &
             .or. dim_type == 'ZXYHT' ) then
           vsize = ka * ia * ja * step
           dim1_s = ks
           dim1_e = ke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif ( dim_type == 'ZHXYT' ) then
           vsize = ka * ia * ja * step
           dim1_s = ks-1
           dim1_e = ke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif ( dim_type == 'OXYT' ) then
           vsize = oka * oia * oja * step
           dim1_s = oks
           dim1_e = oke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif ( dim_type == 'LXYT' ) then
           vsize = lka * lia * lja * step
           dim1_s = lks
           dim1_e = lke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        elseif ( dim_type == 'UXYT' ) then
           vsize = uka * uia * uja * step
           dim1_s = uks
           dim1_e = uke
           dim2_s = isb
           dim2_e = ieb
           dim3_s = jsb
           dim3_e = jeb
        else
           log_error("FILE_CARTESC_read_var_4D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
           call prc_abort
        endif
  
        if ( size(var) .ne. vsize ) then
           log_error("FILE_CARTESC_read_var_4D",*) 'size of var is invalid: ', trim(varname), size(var), vsize
           call prc_abort
        end if
        dim4_s   = 1
        dim4_e   = step
  
        allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e,dim3_s:dim3_e,dim4_s:dim4_e) )
        call file_read( fid, varname, & ! (in)
                        buf(:,:,:,:)  ) ! (out)
        !$omp workshare
        var(dim1_s:dim1_e,dim2_s:dim2_e,dim3_s:dim3_e,dim4_s:dim4_e) = buf(:,:,:,:)
        !$omp end workshare
        deallocate( buf )
  
        !$acc update device(var) if(acc_is_present(var))
     endif
  
     call prof_rapend('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_read_1d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_read_auto_2d()

subroutine scale_file_cartesc::file_cartesc_read_auto_2d	(	integer, intent(in)	fid,
		character(len=*), intent(in)	varname,
		real(rp), dimension(:,:), intent(out)	var,
		integer, intent(in), optional	step,
		logical, intent(out), optional	existed
	)

Read 2D data from file.

Parameters

[in]	fid	file ID
[in]	varname	name of the variable
[out]	var	value of the variable
[in]	step	step number

Definition at line 1826 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_opened, &
        file_allnodes, &
        file_get_shape, &
        file_get_datainfo, &
        file_get_attribute, &
        file_read
     use scale_prc, only: &
        prc_abort
     implicit none
     integer,          intent(in)  :: fid
     character(len=*), intent(in)  :: varname
  
     real(RP),         intent(out) :: var(:,:)
  
     integer, intent(in), optional :: step
  
     logical, intent(out), optional :: existed
  
     integer :: dims(2)
     integer :: halos(2)
     integer :: start(2)
     integer :: count(2)
     character(len=H_SHORT) :: dnames(2)
  
     integer :: nx, ny
     integer :: n
  
     logical :: existed2
  
     intrinsic size
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     log_info("FILE_CARTESC_read_auto_2D",'(1x,2A)') 'Read from file (2D), name : ', trim(varname)
  
     call file_get_datainfo( fid, varname, dim_name=dnames(:), existed=existed2 )
  
     if ( present( existed ) ) then
        existed = existed2
        if ( .not. existed2 ) then
           call prof_rapend  ('FILE_Read', 2)
           return
        end if
     end if
  
     if ( .not. existed2 ) then
        log_error("FILE_CARTESC_read_auto_2D",*) 'variable not found: ', trim(varname)
        call prc_abort
     end if
  
     call file_get_shape( fid, varname, dims(:) )
     nx = size(var,1)
     ny = size(var,2)
  
     if ( nx==dims(1) .and. ny==dims(2) ) then
        start(:) = (/1,1/)
     else
        do n = 1, 2
           call file_get_attribute( fid, dnames(n), "halo_local", halos(:), existed=existed2 )
           if ( existed2 ) then
              start(n) = halos(1) + 1
           else
              start(n) = 1
           end if
        end do
     end if
     count(:) = (/nx,ny/)
  
     call file_read( fid, varname, var(:,:), step=step, start=start(:), count=count(:) )
     call file_cartesc_flush( fid )
     !$acc update device(var) if(acc_is_present(var))
  
     call prof_rapend('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

References scale_file::file_allnodes(), file_cartesc_flush(), scale_file::file_opened(), scale_prc::prc_abort(), scale_prof::prof_rapend(), and scale_prof::prof_rapstart().

Here is the call graph for this function:

◆ file_cartesc_read_auto_3d()

subroutine scale_file_cartesc::file_cartesc_read_auto_3d	(	integer, intent(in)	fid,
		character(len=*), intent(in)	varname,
		real(rp), dimension(:,:,:), intent(out)	var,
		integer, intent(in), optional	step,
		logical, intent(out), optional	existed
	)

Read 3D data from file.

Parameters

[in]	fid	file ID
[in]	varname	name of the variable
[out]	var	value of the variable
[in]	step	step number

Definition at line 1913 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_opened, &
        file_allnodes, &
        file_get_shape, &
        file_get_datainfo, &
        file_get_attribute, &
        file_read
     use scale_prc, only: &
        prc_abort
     implicit none
     integer,          intent(in)  :: fid
     character(len=*), intent(in)  :: varname
  
     real(RP),         intent(out) :: var(:,:,:)
  
     integer, intent(in), optional :: step
  
     logical, intent(out), optional :: existed
  
     integer :: dims(3)
     integer :: halos(3)
     integer :: start(3)
     integer :: count(3)
     character(len=H_SHORT) :: dnames(3)
  
     logical :: existed2
  
     real(RP), allocatable :: buf(:,:,:)
     integer :: nx, ny, nz
     integer :: n
     integer :: k, i, j
  
     intrinsic size
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     log_info("FILE_CARTESC_read_auto_3D",'(1x,2A)') 'Read from file (3D), name : ', trim(varname)
  
     call file_get_datainfo( fid, varname, dim_name=dnames(:), existed=existed2 )
  
     if ( present(existed) ) then
        existed = existed2
        if ( .not. existed2 ) then
           call prof_rapend  ('FILE_Read', 2)
           return
        end if
     end if
  
     if ( .not. existed2 ) then
        log_error("FILE_CARTESC_read_auto_3D",*) 'variable not found: ', trim(varname)
        call prc_abort
     end if
  
     call file_get_shape( fid, varname, dims(:) )
     nz = size(var,1)
     nx = size(var,2)
     ny = size(var,3)
  
     if      ( ( dnames(1)(1:1)=="z" .or. dnames(1)(2:2)=="z" ) .and. dnames(2)(1:1)=="x" .and. dnames(3)(1:1)=="y" ) then
        if ( nz==dims(1) .and. nx==dims(2) .and. ny==dims(3) ) then
           start(:) = (/1,1,1/)
        else if ( dnames(1)=="zh" .and. nz+1==dims(1) .and. nx==dims(2) .and. ny==dims(3) ) then
           start(:) = (/2,1,1/)
        else
           do n = 1, 3
              call file_get_attribute( fid, dnames(n), "halo_local", halos(:), existed=existed2 )
              if ( existed2 ) then
                 start(n) = halos(1) + 1
              else if ( dnames(n)=="zh" ) then
                 start(n) = 2
              else
                 start(n) = 1
              end if
           end do
        end if
        count(:) = (/nz,nx,ny/)
        call file_read( fid, varname, var(:,:,:), step=step, start=start(:), count=count(:) )
        call file_cartesc_flush( fid )
        !$acc update device(var) if(acc_is_present(var))
     else if ( dnames(1)(1:1)=="x" .and. dnames(2)(1:1)=="y" .and. ( dnames(3)(1:1)=="z" .or. dnames(3)(2:2)=="z" ) ) then
        allocate( buf(nx,ny,nz) )
        if ( nx==dims(1) .and. ny==dims(2) .and. nz==dims(3) ) then
           start(:) = (/1,1,1/)
        else if ( nx==dims(1) .and. ny==dims(2) .and. nz+1==dims(3) .and. dnames(3)=="zh" ) then
           start(:) = (/1,1,2/)
        else
           do n = 1, 3
              call file_get_attribute( fid, dnames(n), "halo_local", halos(:), existed=existed2 )
              if ( existed2 ) then
                 start(n) = halos(1) + 1
              else if ( dnames(n)=="zh" ) then
                 start(n) = 2
              else
                 start(n) = 1
              end if
           end do
        end if
        count(:) = (/nx,ny,nz/)
        call file_read( fid, varname, buf(:,:,:), step=step, start=start(:), count=count(:) )
        call file_cartesc_flush( fid )
  
        !$omp parallel do
        !$acc kernels if(acc_is_present(var))
        do j = 1, ny
        do i = 1, nx
        do k = 1, nz
           var(k,i,j) = buf(i,j,k)
        end do
        end do
        end do
        !$acc end kernels
        deallocate(buf)
     else
        log_error("FILE_CARTESC_read_auto_3D",*) 'invalid dimension'
        call prc_abort
     end if
  
     call prof_rapend('FILE_Read', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

References scale_file::file_allnodes(), file_cartesc_flush(), scale_file::file_opened(), scale_prc::prc_abort(), scale_prof::prof_rapend(), and scale_prof::prof_rapstart().

Here is the call graph for this function:

◆ file_cartesc_write_1d()

subroutine scale_file_cartesc::file_cartesc_write_1d	(	real(rp), dimension(:), intent(in)	var,
		character(len=*), intent(in)	basename,
		character(len=*), intent(in)	title,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	desc,
		character(len=*), intent(in)	unit,
		character(len=*), intent(in)	dim_type,
		character(len=*), intent(in)	datatype,
		integer, dimension(6), intent(in), optional	date,
		real(dp), intent(in), optional	subsec,
		logical, intent(in), optional	append,
		logical, intent(in), optional	aggregate,
		character(len=*), intent(in), optional	standard_name,
		character(len=*), intent(in), optional	cell_measures
	)

interface FILE_CARTESC_write Write data to file This routine is a wrapper of the lowere primitive routines

Parameters

[in]	var	value of the variable
[in]	basename	basename of the file
[in]	title	title of the file
[in]	varname	name of the variable
[in]	desc	description of the variable
[in]	unit	unit of the variable
[in]	dim_type	dimension type (Z/X/Y)
[in]	datatype	data type (REAL8/REAL4/default)
[in]	date	ymdhms of the time
[in]	subsec	subsec of the time
[in]	append	switch whether append existing file or not (default=false)

Definition at line 2053 of file scale_file_cartesC.F90.

     implicit none
  
     real(RP),         intent(in) :: var(:)
     character(len=*), intent(in) :: basename
     character(len=*), intent(in) :: title
     character(len=*), intent(in) :: varname
     character(len=*), intent(in) :: desc
     character(len=*), intent(in) :: unit
     character(len=*), intent(in) :: dim_type
     character(len=*), intent(in) :: datatype
  
     integer,          intent(in), optional :: date(6)
     real(DP),         intent(in), optional :: subsec
     logical,          intent(in), optional :: append
     logical,          intent(in), optional :: aggregate
     character(len=*), intent(in), optional :: standard_name
     character(len=*), intent(in), optional :: cell_measures
  
     integer :: fid, vid
     !---------------------------------------------------------------------------
  
     log_info("FILE_CARTESC_write_1D",'(1x,2A)') 'Write to file (1D), name : ', trim(varname)
  
     call file_cartesc_create( basename, title, datatype,                        & ! [IN]
                               fid,                                              & ! [OUT]
                               date=date, subsec=subsec,                         & ! [IN]
                               append=append, aggregate=aggregate, single=.true. ) ! [IN]
  
     call file_cartesc_def_var( fid, varname, desc, unit, dim_type, datatype, & ! [IN]
                                vid,                                          & ! [OUT]
                                standard_name=standard_name,                  & ! [IN]
                                cell_measures=cell_measures                   ) ! [IN]
  
     call file_cartesc_enddef( fid )
  
     call file_cartesc_write_var_1d( fid, vid, var, varname, dim_type )
  
     return

References file_cartesc_create(), file_cartesc_def_var(), file_cartesc_enddef(), file_cartesc_write_var_1d(), file_cartesc_write_var_2d(), file_cartesc_write_var_3d(), file_cartesc_write_var_3d_t(), and file_cartesc_write_var_4d().

Here is the call graph for this function:

◆ file_cartesc_put_globalattributes()

subroutine, public scale_file_cartesc::file_cartesc_put_globalattributes	(	integer, intent(in)	fid,
		integer, intent(in)	prc_rank_x,
		integer, intent(in)	prc_rank_y,
		integer, intent(in)	prc_num_x,
		integer, intent(in)	prc_num_y,
		logical, intent(in)	prc_periodic_x,
		logical, intent(in)	prc_periodic_y,
		integer, intent(in)	kmax,
		integer, intent(in)	okmax,
		integer, intent(in)	lkmax,
		integer, intent(in)	ukmax,
		integer, intent(in)	imaxg,
		integer, intent(in)	jmaxg,
		integer, intent(in)	khalo,
		integer, intent(in)	ihalo,
		integer, intent(in)	jhalo,
		real(dp), intent(in)	time,
		character(len=*), intent(in)	tunits,
		character(len=*), intent(in)	calendar
	)

put global attributes

Definition at line 2345 of file scale_file_cartesC.F90.

     use scale_atmos_grid_cartesc, only: &
        atmos_grid_cartesc_name
     use scale_file, only: &
        file_opened, &
        file_allnodes, &
        file_set_attribute
  
     integer,          intent(in) :: fid
     integer,          intent(in) :: prc_rank_x, prc_rank_y
     integer,          intent(in) :: prc_num_x, prc_num_y
     logical,          intent(in) :: prc_periodic_x, prc_periodic_y
     integer,          intent(in) :: kmax, okmax, lkmax, ukmax
     integer,          intent(in) :: imaxg, jmaxg
     integer,          intent(in) :: khalo, ihalo, jhalo
     real(DP),         intent(in) :: time
     character(len=*), intent(in) :: tunits
     character(len=*), intent(in) :: calendar
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     if ( .not. prof ) call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     call file_set_attribute( fid, "global", "Conventions", "CF-1.6" ) ! [IN]
  
     call file_set_attribute( fid, "global", "grid_name", atmos_grid_cartesc_name ) ! [IN]
  
     call file_set_attribute( fid, "global", "scale_cartesC_prc_rank_x", (/prc_rank_x/) ) ! [IN]
     call file_set_attribute( fid, "global", "scale_cartesC_prc_rank_y", (/prc_rank_y/) ) ! [IN]
  
     call file_set_attribute( fid, "global", "scale_cartesC_prc_num_x",  (/prc_num_x/) ) ! [IN]
     call file_set_attribute( fid, "global", "scale_cartesC_prc_num_y",  (/prc_num_y/) ) ! [IN]
  
     call file_set_attribute( fid, "global", "scale_cartesC_prc_periodic_z", .false.        ) ! [IN]
     call file_set_attribute( fid, "global", "scale_cartesC_prc_periodic_x", prc_periodic_x ) ! [IN]
     call file_set_attribute( fid, "global", "scale_cartesC_prc_periodic_y", prc_periodic_y ) ! [IN]
  
     call file_set_attribute( fid, "global", "scale_atmos_grid_cartesC_index_imaxg", (/imaxg/) ) ! [IN]
     call file_set_attribute( fid, "global", "scale_atmos_grid_cartesC_index_jmaxg", (/jmaxg/) ) ! [IN]
  
                      call file_set_attribute( fid, "global", "scale_atmos_grid_cartesC_index_kmax", (/kmax/)  ) ! [IN]
     if ( okmax > 0 ) call file_set_attribute( fid, "global", "scale_ocean_grid_cartesC_index_kmax", (/okmax/) ) ! [IN]
     if ( lkmax > 0 ) call file_set_attribute( fid, "global", "scale_land_grid_cartesC_index_kmax",  (/lkmax/) ) ! [IN]
     if ( ukmax > 0 ) call file_set_attribute( fid, "global", "scale_urban_grid_cartesC_index_kmax", (/ukmax/) ) ! [IN]
  
     call file_set_attribute( fid, "global", "scale_atmos_grid_cartesC_index_khalo", (/khalo/) ) ! [IN]
     call file_set_attribute( fid, "global", "scale_atmos_grid_cartesC_index_ihalo", (/ihalo/) ) ! [IN]
     call file_set_attribute( fid, "global", "scale_atmos_grid_cartesC_index_jhalo", (/jhalo/) ) ! [IN]
  
     if ( calendar /= "" ) call file_set_attribute( fid, "global", "calendar", calendar )
     call file_set_attribute( fid, "global", "time_units", tunits )
     call file_set_attribute( fid, "global", "time_start", (/time/) )
  
     if ( .not. prof ) call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_def_axes()

subroutine scale_file_cartesc::file_cartesc_def_axes	(	integer, intent(in)	fid,
		integer, intent(in)	dtype,
		logical, intent(in)	hasZ
	)

define axis variables in the file

Definition at line 2409 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_opened,                   &
        file_get_aggregate,            &
        file_def_axis,                 &
        file_set_attribute,            &
        file_def_associatedcoordinate, &
        file_add_associatedvariable
     use scale_const, only: &
        undef => const_undef
     use scale_mapprojection, only: &
        mapprojection_mappinginfo
     implicit none
  
     integer, intent(in) :: fid
     integer, intent(in) :: dtype
     logical, intent(in) :: hasZ
  
     integer :: iall  ! grid size, x-axis, (whole domain or local tile), including halo
     integer :: jall  ! grid size, y-axis, (whole domain or local tile), including halo
     integer :: isize ! grid size, x-axis, (whole domain or local tile), without halo except domain edge
     integer :: jsize ! grid size, y-axis, (whole domain or local tile), without halo except domain edge
  
     character(len=2) :: axisname(3)
  
     logical, save :: set_dim = .false.
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     if ( .not. set_dim ) then
        call set_dimension_informations
        set_dim = .true.
     end if
  
     if ( file_get_aggregate(fid) ) then
        iall  = iag
        jall  = jag
        isize = iag
        jsize = jag
     else
        iall  = ia
        jall  = ja
        isize = imaxb
        jsize = jmaxb
     endif
  
     if ( hasz ) then
        call file_def_axis( fid, 'z'  , 'Z'              , 'm', 'z'  , dtype, kmax,   bounds=.true. )
        call file_def_axis( fid, 'zh' , 'Z (half level)' , 'm', 'zh' , dtype, kmax+1, bounds=.true. )
  
        if ( okmax > 0 ) then
           call file_def_axis( fid, 'oz' , 'OZ'             , 'm', 'oz' , dtype, okmax,   bounds=.true. )
           call file_def_axis( fid, 'ozh', 'OZ (half level)', 'm', 'ozh', dtype, okmax+1, bounds=.true. )
        end if
  
        if ( lkmax > 0 ) then
           call file_def_axis( fid, 'lz' , 'LZ'             , 'm', 'lz' , dtype, lkmax,   bounds=.true. )
           call file_def_axis( fid, 'lzh', 'LZ (half level)', 'm', 'lzh', dtype, lkmax+1, bounds=.true. )
        end if
  
        if ( ukmax > 0 ) then
           call file_def_axis( fid, 'uz' , 'UZ'             , 'm', 'uz' , dtype, ukmax,   bounds=.true. )
           call file_def_axis( fid, 'uzh', 'UZ (half level)', 'm', 'uzh', dtype, ukmax+1, bounds=.true. )
        end if
     end if
  
     call file_def_axis( fid, 'x'  , 'X'              , 'm', 'x'  , dtype, isize, bounds=.true. )
     call file_def_axis( fid, 'xh' , 'X (half level)' , 'm', 'xh' , dtype, isize, bounds=.true. )
     call file_def_axis( fid, 'y'  , 'Y'              , 'm', 'y'  , dtype, jsize, bounds=.true. )
     call file_def_axis( fid, 'yh' , 'Y (half level)' , 'm', 'yh' , dtype, jsize, bounds=.true. )
  
     if ( hasz ) then
        call file_def_axis( fid, 'CZ'   , 'Atmos Grid Center Position Z',      'm', 'CZ',   dtype, ka      )
        call file_def_axis( fid, 'FZ'   , 'Atmos Grid Face   Position Z',      'm', 'FZ',   dtype, ka+1    )
        call file_def_axis( fid, 'CDZ'  , 'Grid Cell length Z',                'm', 'CZ',   dtype, ka      )
        call file_def_axis( fid, 'FDZ'  , 'Grid distance Z',                   'm', 'FDZ',  dtype, ka-1    )
        call file_def_axis( fid, 'CBFZ' , 'Boundary factor Center Z',          '1', 'CZ',   dtype, ka      )
        call file_def_axis( fid, 'FBFZ' , 'Boundary factor Face Z',            '1', 'FZ',   dtype, ka+1    )
  
        if ( okmax > 0 ) then
           call file_def_axis( fid, 'OCZ'  , 'Ocean Grid Center Position Z',      'm', 'OCZ',  dtype, okmax   )
           call file_def_axis( fid, 'OFZ'  , 'Ocean Grid Face   Position Z',      'm', 'OFZ',  dtype, okmax+1 )
           call file_def_axis( fid, 'OCDZ' , 'Ocean Grid Cell length Z',          'm', 'OCZ',  dtype, okmax   )
        end if
  
        if ( lkmax > 0 ) then
           call file_def_axis( fid, 'LCZ'  , 'Land Grid Center Position Z',       'm', 'LCZ',  dtype, lkmax   )
           call file_def_axis( fid, 'LFZ'  , 'Land Grid Face   Position Z',       'm', 'LFZ',  dtype, lkmax+1 )
           call file_def_axis( fid, 'LCDZ' , 'Land Grid Cell length Z',           'm', 'LCZ',  dtype, lkmax   )
        end if
  
        if ( ukmax > 0 ) then
           call file_def_axis( fid, 'UCZ'  , 'Urban Grid Center Position Z',      'm', 'UCZ',  dtype, ukmax   )
           call file_def_axis( fid, 'UFZ'  , 'Urban Grid Face   Position Z',      'm', 'UFZ',  dtype, ukmax+1 )
           call file_def_axis( fid, 'UCDZ' , 'Urban Grid Cell length Z',          'm', 'UCZ',  dtype, ukmax   )
        end if
     end if
  
     call file_def_axis( fid, 'CX'   , 'Atmos Grid Center Position X',      'm', 'CX',  dtype, iall   )
     call file_def_axis( fid, 'CY'   , 'Atmos Grid Center Position Y',      'm', 'CY',  dtype, jall   )
     call file_def_axis( fid, 'FX'   , 'Atmos Grid Face   Position X',      'm', 'FX',  dtype, iall+1 )
     call file_def_axis( fid, 'FY'   , 'Atmos Grid Face   Position Y',      'm', 'FY',  dtype, jall+1 )
     call file_def_axis( fid, 'CDX'  , 'Grid Cell length X',                'm', 'CX',  dtype, iall   )
     call file_def_axis( fid, 'CDY'  , 'Grid Cell length Y',                'm', 'CY',  dtype, jall   )
     call file_def_axis( fid, 'FDX'  , 'Grid distance X',                   'm', 'FX',  dtype, iall+1 )
     call file_def_axis( fid, 'FDY'  , 'Grid distance Y',                   'm', 'FY',  dtype, jall+1 )
     call file_def_axis( fid, 'CBFX' , 'Boundary factor Center X',          '1', 'CX',  dtype, iall   )
     call file_def_axis( fid, 'CBFY' , 'Boundary factor Center Y',          '1', 'CY',  dtype, jall   )
     call file_def_axis( fid, 'FBFX' , 'Boundary factor Face X',            '1', 'FX',  dtype, iall+1 )
     call file_def_axis( fid, 'FBFY' , 'Boundary factor Face Y',            '1', 'FY',  dtype, jall+1 )
  
     call file_def_axis( fid, 'CXG'  , 'Grid Center Position X (global)',   'm', 'CXG', dtype, iag   )
     call file_def_axis( fid, 'CYG'  , 'Grid Center Position Y (global)',   'm', 'CYG', dtype, jag   )
     call file_def_axis( fid, 'FXG'  , 'Grid Face   Position X (global)',   'm', 'FXG', dtype, iag+1 )
     call file_def_axis( fid, 'FYG'  , 'Grid Face   Position Y (global)',   'm', 'FYG', dtype, jag+1 )
     call file_def_axis( fid, 'CDXG' , 'Grid Cell length X (global)',       'm', 'CXG', dtype, iag   )
     call file_def_axis( fid, 'CDYG' , 'Grid Cell length Y (global)',       'm', 'CYG', dtype, jag   )
     call file_def_axis( fid, 'FDXG' , 'Grid distance X (global)',          'm', 'FXG', dtype, iag+1 )
     call file_def_axis( fid, 'FDYG' , 'Grid distance Y (global)',          'm', 'FYG', dtype, jag+1 )
     call file_def_axis( fid, 'CBFXG', 'Boundary factor Center X (global)', '1', 'CXG', dtype, iag   )
     call file_def_axis( fid, 'CBFYG', 'Boundary factor Center Y (global)', '1', 'CYG', dtype, jag   )
     call file_def_axis( fid, 'FBFXG', 'Boundary factor Face   X (global)', '1', 'FXG', dtype, iag+1 )
     call file_def_axis( fid, 'FBFYG', 'Boundary factor Face   Y (global)', '1', 'FYG', dtype, jag+1 )
  
     ! associate coordinates
     axisname(1:2) = (/'x ','y '/)
     call file_def_associatedcoordinate( fid, 'lon'   , 'longitude',                 'degrees_east' , axisname(1:2), dtype )
     axisname(1:2) = (/'xh','y '/)
     call file_def_associatedcoordinate( fid, 'lon_uy', 'longitude (half level uy)', 'degrees_east' , axisname(1:2), dtype )
     axisname(1:2) = (/'x ','yh'/)
     call file_def_associatedcoordinate( fid, 'lon_xv', 'longitude (half level xv)', 'degrees_east' , axisname(1:2), dtype )
     axisname(1:2) = (/'xh','yh'/)
     call file_def_associatedcoordinate( fid, 'lon_uv', 'longitude (half level uv)', 'degrees_east' , axisname(1:2), dtype )
     axisname(1:2) = (/'x ','y '/)
     call file_def_associatedcoordinate( fid, 'lat'   , 'latitude',                  'degrees_north', axisname(1:2), dtype )
     axisname(1:2) = (/'xh','y '/)
     call file_def_associatedcoordinate( fid, 'lat_uy', 'latitude (half level uy)',  'degrees_north', axisname(1:2), dtype )
     axisname(1:2) = (/'x ','yh'/)
     call file_def_associatedcoordinate( fid, 'lat_xv', 'latitude (half level xv)',  'degrees_north', axisname(1:2), dtype )
     axisname(1:2) = (/'xh','yh'/)
     call file_def_associatedcoordinate( fid, 'lat_uv', 'latitude (half level uv)',  'degrees_north', axisname(1:2), dtype )
  
     if ( hasz ) then
        axisname(1:2) = (/'x ','y '/)
        call file_def_associatedcoordinate( fid, 'topo' ,  'topography',                 'm',            axisname(1:2), dtype )
     end if
     axisname(1:2) = (/'x ','y '/)
     call file_def_associatedcoordinate( fid, 'lsmask', 'fraction for land-sea mask', '1',            axisname(1:2), dtype )
  
     axisname(1:2) = (/'x ','y '/)
     call file_def_associatedcoordinate( fid, 'cell_area',    'area of grid cell',                  'm2', axisname(1:2), dtype )
     axisname(1:2) = (/'xh','y '/)
     call file_def_associatedcoordinate( fid, 'cell_area_uy', 'area of grid cell (half level uy)',  'm2', axisname(1:2), dtype )
     axisname(1:2) = (/'x ','yh'/)
     call file_def_associatedcoordinate( fid, 'cell_area_xv', 'area of grid cell (half level xv)',  'm2', axisname(1:2), dtype )
     axisname(1:2) = (/'xh','yh'/)
  
     if ( hasz ) then
        axisname = (/'z ', 'x ', 'y '/)
        call file_def_associatedcoordinate( fid, 'height',     'height above sea level', &
                                            'm', axisname(1:3), dtype                        )
        axisname = (/'zh', 'x ', 'y '/)
        call file_def_associatedcoordinate( fid, 'height_wxy', 'height above sea level (half level wxy)', &
                                            'm', axisname(1:3), dtype                                         )
  
        axisname = (/'z ', 'xh', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_area_zuy_x', 'area of grid cell face (half level zuy, normal x)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'z ', 'x ', 'yh'/)
        call file_def_associatedcoordinate( fid, 'cell_area_zxv_y', 'area of grid cell face (half level zxv, normal y)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'zh', 'xh', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_area_wuy_x', 'area of grid cell face (half level wuy, normal x)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'zh', 'x ', 'yh'/)
        call file_def_associatedcoordinate( fid, 'cell_area_wxv_y', 'area of grid cell face (half level wxv, normal y)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'z ', 'x ', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_area_zxy_x', 'area of grid cell face (half level zxy, normal x)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'z ', 'xh', 'yh'/)
        call file_def_associatedcoordinate( fid, 'cell_area_zuv_y', 'area of grid cell face (half level zuv, normal y)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'z ', 'xh', 'yh'/)
        call file_def_associatedcoordinate( fid, 'cell_area_zuv_x', 'area of grid cell face (half level zuv, normal x)', &
                                            'm2', axisname(1:3), dtype                       )
        axisname = (/'z ', 'x ', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_area_zxy_y', 'area of grid cell face (half level zxy, normal y)', &
                                            'm2', axisname(1:3), dtype                       )
  
        axisname = (/'z ', 'x ', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_volume',     'volume of grid cell', &
                                            'm3', axisname(1:3), dtype                       )
        axisname = (/'zh', 'x ', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_volume_wxy', 'volume of grid cell (half level wxy)', &
                                            'm3', axisname(1:3), dtype                                       )
        axisname = (/'z ', 'xh', 'y '/)
        call file_def_associatedcoordinate( fid, 'cell_volume_zuy', 'volume of grid cell (half level zuy)', &
                                            'm3', axisname(1:3), dtype                                       )
        axisname = (/'z ', 'x ', 'yh'/)
        call file_def_associatedcoordinate( fid, 'cell_volume_zxv', 'volume of grid cell (half level zxv)', &
                                            'm3', axisname(1:3), dtype                                       )
  
        if ( okmax > 0 ) then
           axisname = (/'oz', 'x ', 'y '/)
           call file_def_associatedcoordinate( fid, 'cell_volume_oxy', 'volume of grid cell', &
                                               'm3', axisname(1:3), dtype                      )
        end if
        if ( lkmax > 0 ) then
           axisname = (/'lz', 'x ', 'y '/)
           call file_def_associatedcoordinate( fid, 'cell_volume_lxy', 'volume of grid cell', &
                                               'm3', axisname(1:3), dtype                      )
        end if
        if ( ukmax > 0 ) then
           axisname = (/'uz', 'x ', 'y '/)
           call file_def_associatedcoordinate( fid, 'cell_volume_uxy', 'volume of grid cell', &
                                               'm3', axisname(1:3), dtype                      )
        end if
     endif
  
     ! attributes
  
     if ( hasz ) then
        if ( okmax > 0 ) then
           call file_set_attribute( fid, 'oz' , 'positive', 'down' )
           call file_set_attribute( fid, 'ozh', 'positive', 'down' )
        end if
        if ( lkmax > 0 ) then
           call file_set_attribute( fid, 'lz' , 'positive', 'down' )
           call file_set_attribute( fid, 'lzh', 'positive', 'down' )
        end if
        if ( ukmax > 0 ) then
           call file_set_attribute( fid, 'uz' , 'positive', 'down' )
           call file_set_attribute( fid, 'uzh', 'positive', 'down' )
        end if
        if ( okmax > 0 ) then
           call file_set_attribute( fid, 'OCZ', 'positive', 'down' )
           call file_set_attribute( fid, 'OFZ', 'positive', 'down' )
        end if
        if ( lkmax > 0 ) then
           call file_set_attribute( fid, 'LCZ', 'positive', 'down' )
           call file_set_attribute( fid, 'LFZ', 'positive', 'down' )
        end if
        if ( ukmax > 0 ) then
           call file_set_attribute( fid, 'UCZ', 'positive', 'down' )
           call file_set_attribute( fid, 'UFZ', 'positive', 'down' )
        end if
     endif
  
     if ( file_get_aggregate(fid) ) then
        call file_set_attribute( fid, "x" , "size_global" , (/ iag /) )
        call file_set_attribute( fid, "x" , "start_global", (/ 1   /) )
        call file_set_attribute( fid, "x" , "halo_global" , (/ ihalo, ihalo /) )
        call file_set_attribute( fid, "x" , "halo_local"  , (/ ihalo, ihalo /) )
  
        call file_set_attribute( fid, "xh", "size_global" , (/ iag+1 /) )
        call file_set_attribute( fid, "xh", "start_global", (/ 1     /) )
        call file_set_attribute( fid, "xh", "halo_global" , (/ ihalo, ihalo /) )
        call file_set_attribute( fid, "xh", "halo_local"  , (/ ihalo, ihalo /) )
  
        call file_set_attribute( fid, "y" , "size_global" , (/ jag /) )
        call file_set_attribute( fid, "y" , "start_global", (/ 1   /) )
        call file_set_attribute( fid, "y" , "halo_global" , (/ jhalo, jhalo /) )
        call file_set_attribute( fid, "y" , "halo_local"  , (/ jhalo, jhalo /) )
  
        call file_set_attribute( fid, "yh", "size_global" , (/ jag+1 /) )
        call file_set_attribute( fid, "yh", "start_global", (/ 1     /) )
        call file_set_attribute( fid, "yh", "halo_global" , (/ jhalo, jhalo /) )
        call file_set_attribute( fid, "yh", "halo_local"  , (/ jhalo, jhalo /) )
     else
        call file_set_attribute( fid, "x" , "size_global" , file_cartesc_axis_info(1)%size_global (:) )
        call file_set_attribute( fid, "x" , "start_global", file_cartesc_axis_info(1)%start_global(:) )
        call file_set_attribute( fid, "x" , "halo_global" , file_cartesc_axis_info(1)%halo_global (:) )
        call file_set_attribute( fid, "x" , "halo_local"  , file_cartesc_axis_info(1)%halo_local  (:) )
  
        call file_set_attribute( fid, "xh", "size_global" , file_cartesc_axis_info(2)%size_global (:) )
        call file_set_attribute( fid, "xh", "start_global", file_cartesc_axis_info(2)%start_global(:) )
        call file_set_attribute( fid, "xh", "halo_global" , file_cartesc_axis_info(2)%halo_global (:) )
        call file_set_attribute( fid, "xh", "halo_local"  , file_cartesc_axis_info(2)%halo_local  (:) )
  
        call file_set_attribute( fid, "y" , "size_global" , file_cartesc_axis_info(3)%size_global (:) )
        call file_set_attribute( fid, "y" , "start_global", file_cartesc_axis_info(3)%start_global(:) )
        call file_set_attribute( fid, "y" , "halo_global" , file_cartesc_axis_info(3)%halo_global (:) )
        call file_set_attribute( fid, "y" , "halo_local"  , file_cartesc_axis_info(3)%halo_local  (:) )
  
        call file_set_attribute( fid, "yh", "size_global" , file_cartesc_axis_info(4)%size_global (:) )
        call file_set_attribute( fid, "yh", "start_global", file_cartesc_axis_info(4)%start_global(:) )
        call file_set_attribute( fid, "yh", "halo_global" , file_cartesc_axis_info(4)%halo_global (:) )
        call file_set_attribute( fid, "yh", "halo_local"  , file_cartesc_axis_info(4)%halo_local  (:) )
     end if
  
     call file_set_attribute( fid, "x" , "periodic"    , file_cartesc_axis_info(1)%periodic        )
     call file_set_attribute( fid, "xh", "periodic"    , file_cartesc_axis_info(2)%periodic        )
     call file_set_attribute( fid, "y" , "periodic"    , file_cartesc_axis_info(3)%periodic        )
     call file_set_attribute( fid, "yh", "periodic"    , file_cartesc_axis_info(4)%periodic        )
  
     ! map projection info
  
     if ( mapprojection_mappinginfo%mapping_name /= "" ) then
        call file_set_attribute( fid, "x" , "standard_name", "projection_x_coordinate" )
        call file_set_attribute( fid, "xh", "standard_name", "projection_x_coordinate" )
        call file_set_attribute( fid, "y" , "standard_name", "projection_y_coordinate" )
        call file_set_attribute( fid, "yh", "standard_name", "projection_y_coordinate" )
  
        call file_add_associatedvariable( fid, mapprojection_mappinginfo%mapping_name )
        call file_set_attribute( fid, mapprojection_mappinginfo%mapping_name, "grid_mapping_name",  mapprojection_mappinginfo%mapping_name )
  
        if ( mapprojection_mappinginfo%false_easting /= undef ) then
           call file_set_attribute( fid,                                    & ! [IN]
                                    mapprojection_mappinginfo%mapping_name, & ! [IN]
                                    "false_easting",                        & ! [IN]
                                    mapprojection_mappinginfo%false_easting ) ! [IN]
        endif
  
        if ( mapprojection_mappinginfo%false_northing /= undef ) then
           call file_set_attribute( fid,                                     & ! [IN]
                                    mapprojection_mappinginfo%mapping_name,  & ! [IN]
                                    "false_northing",                        & ! [IN]
                                    mapprojection_mappinginfo%false_northing ) ! [IN]
        endif
  
        if ( mapprojection_mappinginfo%longitude_of_central_meridian /= undef ) then
           call file_set_attribute( fid,                                                    & ! [IN]
                                    mapprojection_mappinginfo%mapping_name,                 & ! [IN]
                                    "longitude_of_central_meridian",                        & ! [IN]
                                    mapprojection_mappinginfo%longitude_of_central_meridian ) ! [IN]
        endif
  
        if ( mapprojection_mappinginfo%longitude_of_projection_origin /= undef ) then
           call file_set_attribute( fid,                                                     & ! [IN]
                                    mapprojection_mappinginfo%mapping_name,                  & ! [IN]
                                    "longitude_of_projection_origin",                        & ! [IN]
                                    mapprojection_mappinginfo%longitude_of_projection_origin ) ! [IN]
        endif
  
        if ( mapprojection_mappinginfo%latitude_of_projection_origin /= undef ) then
           call file_set_attribute( fid,                                                    & ! [IN]
                                    mapprojection_mappinginfo%mapping_name,                 & ! [IN]
                                    "latitude_of_projection_origin",                        & ! [IN]
                                    mapprojection_mappinginfo%latitude_of_projection_origin ) ! [IN]
        endif
  
        if ( mapprojection_mappinginfo%straight_vertical_longitude_from_pole /= undef ) then
           call file_set_attribute( fid,                                                            & ! [IN]
                                    mapprojection_mappinginfo%mapping_name,                         & ! [IN]
                                    "straight_vertical_longitude_from_pole",                        & ! [IN]
                                    mapprojection_mappinginfo%straight_vertical_longitude_from_pole ) ! [IN]
        endif
  
        if ( mapprojection_mappinginfo%standard_parallel(1) /= undef ) then
           if ( mapprojection_mappinginfo%standard_parallel(2) /= undef ) then
              call file_set_attribute( fid,                                           & ! [IN]
                                       mapprojection_mappinginfo%mapping_name,        & ! [IN]
                                       "standard_parallel",                           & ! [IN]
                                       mapprojection_mappinginfo%standard_parallel(:) ) ! [IN]
           else
              call file_set_attribute( fid,                                           & ! [IN]
                                       mapprojection_mappinginfo%mapping_name,        & ! [IN]
                                       "standard_parallel",                           & ! [IN]
                                       mapprojection_mappinginfo%standard_parallel(1) ) ! [IN]
           endif
        endif
  
        if ( mapprojection_mappinginfo%rotation /= undef ) then
           call file_set_attribute( fid,                                    & ! [IN]
                                    mapprojection_mappinginfo%mapping_name, & ! [IN]
                                    "rotation",                             & ! [IN]
                                    mapprojection_mappinginfo%rotation      ) ! [IN]
        endif
  
     endif
  
     ! cell measures
  
     call file_set_attribute( fid, "cell_area",    "standard_name", "area" ) ! [IN]
     call file_set_attribute( fid, "cell_area_uy", "standard_name", "area" ) ! [IN]
     call file_set_attribute( fid, "cell_area_xv", "standard_name", "area" ) ! [IN]
  
     if ( hasz ) then
        call file_set_attribute( fid, "cell_area_zuy_x", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_zxv_y", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_wuy_x", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_wxv_y", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_zxy_x", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_zuv_y", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_zuv_x", "standard_name", "area" ) ! [IN]
        call file_set_attribute( fid, "cell_area_zxy_y", "standard_name", "area" ) ! [IN]
  
        call file_set_attribute( fid, "cell_volume",     "standard_name", "volume" ) ! [IN]
        call file_set_attribute( fid, "cell_volume_wxy", "standard_name", "volume" ) ! [IN]
        call file_set_attribute( fid, "cell_volume_zuy", "standard_name", "volume" ) ! [IN]
        call file_set_attribute( fid, "cell_volume_zxv", "standard_name", "volume" ) ! [IN]
  
        if ( okmax > 0 ) then
           call file_set_attribute( fid, "cell_volume_oxy", "standard_name", "volume" ) ! [IN]
        end if
        if ( lkmax > 0 ) then
           call file_set_attribute( fid, "cell_volume_lxy", "standard_name", "volume" ) ! [IN]
        end if
        if ( ukmax > 0 ) then
           call file_set_attribute( fid, "cell_volume_uxy", "standard_name", "volume" ) ! [IN]
        end if
     end if
  
     ! SGRID
     call file_add_associatedvariable( fid, "grid" )
     call file_set_attribute( fid, "grid", "cf_role",             "grid_topology" )
     call file_set_attribute( fid, "grid", "topology_dimension",  (/ 2 /) )
     call file_set_attribute( fid, "grid", "node_dimensions",     "xh yh" )
     call file_set_attribute( fid, "grid", "face_dimensions",     "x: xh (padding: none) y: yh (padding: none)" )
     call file_set_attribute( fid, "grid", "node_coordinates",    "lon_uv lat_uv" )
     call file_set_attribute( fid, "grid", "face_coordinates",    "lon lat" )
     call file_set_attribute( fid, "grid", "edge1_coordinates",   "lon_uy lat_uy" )
     call file_set_attribute( fid, "grid", "edge2_coordinates",   "lon_xv lat_xv" )
     call file_set_attribute( fid, "grid", "vertical_dimensions", "z: zh (padding: none)" )
  
     if ( okmax > 0 ) then
        call file_add_associatedvariable( fid, "grid_ocean" )
        call file_set_attribute( fid, "grid_ocean", "cf_role",             "grid_topology" )
        call file_set_attribute( fid, "grid_ocean", "topology_dimension",  (/ 2 /) )
        call file_set_attribute( fid, "grid_ocean", "node_dimensions",     "xh yh" )
        call file_set_attribute( fid, "grid_ocean", "face_dimensions",     "x: xh (padding: none) y: yh (padding: none)" )
        call file_set_attribute( fid, "grid_ocean", "node_coordinates",    "lon_uv lat_uv" )
        call file_set_attribute( fid, "grid_ocean", "face_coordinates",    "lon lat" )
        call file_set_attribute( fid, "grid_ocean", "edge1_coordinates",   "lon_uy lat_uy" )
        call file_set_attribute( fid, "grid_ocean", "edge2_coordinates",   "lon_xv lat_xv" )
        call file_set_attribute( fid, "grid_ocean", "vertical_dimensions", "oz: ozh (padding: none)" )
     end if
  
     if ( lkmax > 0 ) then
        call file_add_associatedvariable( fid, "grid_land" )
        call file_set_attribute( fid, "grid_land", "cf_role",             "grid_topology" )
        call file_set_attribute( fid, "grid_land", "topology_dimension",  (/ 2 /) )
        call file_set_attribute( fid, "grid_land", "node_dimensions",     "xh yh" )
        call file_set_attribute( fid, "grid_land", "face_dimensions",     "x: xh (padding: none) y: yh (padding: none)" )
        call file_set_attribute( fid, "grid_land", "node_coordinates",    "lon_uv lat_uv" )
        call file_set_attribute( fid, "grid_land", "face_coordinates",    "lon lat" )
        call file_set_attribute( fid, "grid_land", "edge1_coordinates",   "lon_uy lat_uy" )
        call file_set_attribute( fid, "grid_land", "edge2_coordinates",   "lon_xv lat_xv" )
        call file_set_attribute( fid, "grid_land", "vertical_dimensions", "lz: lzh (padding: none)" )
     end if
  
     if ( ukmax > 0 ) then
        call file_add_associatedvariable( fid, "grid_urban" )
        call file_set_attribute( fid, "grid_urban", "cf_role",             "grid_topology" )
        call file_set_attribute( fid, "grid_urban", "topology_dimension",  (/ 2 /) )
        call file_set_attribute( fid, "grid_urban", "node_dimensions",     "xh yh" )
        call file_set_attribute( fid, "grid_urban", "face_dimensions",     "x: xh (padding: none) y: yh (padding: none)" )
        call file_set_attribute( fid, "grid_urban", "node_coordinates",    "lon_uv lat_uv" )
        call file_set_attribute( fid, "grid_urban", "face_coordinates",    "lon lat" )
        call file_set_attribute( fid, "grid_urban", "edge1_coordinates",   "lon_uy lat_uy" )
        call file_set_attribute( fid, "grid_urban", "edge2_coordinates",   "lon_xv lat_xv" )
        call file_set_attribute( fid, "grid_urban", "vertical_dimensions", "uz: uzh (padding: none)" )
     end if
  
     call file_add_associatedvariable( fid, "grid_model" )
     call file_set_attribute( fid, "grid_model", "cf_role",             "grid_topology" )
     call file_set_attribute( fid, "grid_model", "topology_dimension",  (/ 2 /) )
     call file_set_attribute( fid, "grid_model", "node_dimensions",     "FX FY" )
     call file_set_attribute( fid, "grid_model", "face_dimensions",     "CX: FY (padding: none) CY: FY (padding: none)" )
     call file_set_attribute( fid, "grid_model", "vertical_dimensions", "CZ: FZ (padding: none)" )
  
     call file_add_associatedvariable( fid, "grid_model_global" )
     call file_set_attribute( fid, "grid_model_global", "cf_role",             "grid_topology" )
     call file_set_attribute( fid, "grid_model_global", "topology_dimension",  (/ 2 /) )
     call file_set_attribute( fid, "grid_model_global", "node_dimensions",     "FXG FYG" )
     call file_set_attribute( fid, "grid_model_global", "face_dimensions",     "CXG: FYG (padding: none) CYG: FYG (padding: none)" )
     call file_set_attribute( fid, "grid_model_global", "vertical_dimensions", "CZ: FZ (padding: none)" )
  
     return

Referenced by file_cartesc_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_write_axes()

subroutine scale_file_cartesc::file_cartesc_write_axes	(	integer, intent(in)	fid,
		logical, intent(in)	haszcoord,
		integer, dimension(3), intent(in)	start
	)

write axis to the file

Definition at line 2887 of file scale_file_cartesC.F90.

     use scale_const, only: &
        undef => const_undef
     use scale_file, only: &
        file_opened, &
        file_get_aggregate, &
        file_write_axis,                 &
        file_write_associatedcoordinate
     use scale_prc, only: &
        prc_myrank, &
        prc_ismaster
     use scale_prc_cartesc, only: &
        prc_2drank
     use scale_atmos_grid_cartesc, only: &
        atmos_grid_cartesc_cz,    &
        atmos_grid_cartesc_cx,    &
        atmos_grid_cartesc_cy,    &
        atmos_grid_cartesc_fz,    &
        atmos_grid_cartesc_fx,    &
        atmos_grid_cartesc_fy,    &
        atmos_grid_cartesc_cdz,   &
        atmos_grid_cartesc_cdx,   &
        atmos_grid_cartesc_cdy,   &
        atmos_grid_cartesc_fdz,   &
        atmos_grid_cartesc_fdx,   &
        atmos_grid_cartesc_fdy,   &
        atmos_grid_cartesc_cbfz,  &
        atmos_grid_cartesc_cbfx,  &
        atmos_grid_cartesc_cbfy,  &
        atmos_grid_cartesc_fbfz,  &
        atmos_grid_cartesc_fbfx,  &
        atmos_grid_cartesc_fbfy,  &
        atmos_grid_cartesc_cxg,   &
        atmos_grid_cartesc_cyg,   &
        atmos_grid_cartesc_fxg,   &
        atmos_grid_cartesc_fyg,   &
        atmos_grid_cartesc_cdxg,  &
        atmos_grid_cartesc_cdyg,  &
        atmos_grid_cartesc_fdxg,  &
        atmos_grid_cartesc_fdyg,  &
        atmos_grid_cartesc_cbfxg, &
        atmos_grid_cartesc_cbfyg, &
        atmos_grid_cartesc_fbfxg, &
        atmos_grid_cartesc_fbfyg
     use scale_ocean_grid_cartesc, only: &
        ocean_grid_cartesc_cz,  &
        ocean_grid_cartesc_fz,  &
        ocean_grid_cartesc_cdz
     use scale_land_grid_cartesc, only: &
        land_grid_cartesc_cz,  &
        land_grid_cartesc_fz,  &
        land_grid_cartesc_cdz
     use scale_urban_grid_cartesc, only: &
        urban_grid_cartesc_cz,  &
        urban_grid_cartesc_fz,  &
        urban_grid_cartesc_cdz
     implicit none
  
     integer, intent(in)  :: fid
     logical, intent(in)  :: haszcoord
     integer, intent(in)  :: start(3)
  
     logical :: put_z, put_x, put_y
     integer :: XSB, XEB, YSB, YEB
  
     real(RP) :: z_bnds(2,KA), zh_bnds(2,0:KA)
     real(RP) :: oz_bnds(2,OKA), ozh_bnds(2,0:OKA)
     real(RP) :: lz_bnds(2,LKA), lzh_bnds(2,0:LKA)
     real(RP) :: uz_bnds(2,UKA), uzh_bnds(2,0:UKA)
     real(RP) :: x_bnds(2,IA), xh_bnds(2,0:IA)
     real(RP) :: y_bnds(2,JA), yh_bnds(2,0:JA)
     integer  :: start_(2)
  
     real(RP) :: FDXG(0:IAG), FDYG(0:JAG)
     real(RP) :: FDX(0:IA), FDY(0:JA)
  
     integer :: k, i, j
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     if ( file_get_aggregate(fid) ) then
        ! For parallel I/O, not all variables are written by all processes.
        ! 1. Let PRC_myrank 0 writes all z axes
        ! 2. Let processes (rankidx(2) == 0) write x axes  (south-most processes)
        !        rankidx(1) == 0           writes west HALO
        !        rankidx(1) == PRC_NUM_X-1 writes east HALO
        !        others                    writes without HALO
        ! 3. Let processes (rankidx(1) == 0) write y axes  (west-most processes)
        !        rankidx(1) == 0           writes south HALO
        !        rankidx(1) == PRC_NUM_Y-1 writes north HALO
        !        others                    writes without HALO
  
        put_z = ( prc_ismaster                  ) ! only master process output the vertical coordinates
        put_x = ( prc_2drank(prc_myrank,2) == 0 ) ! only south-most row    processes write x coordinates
        put_y = ( prc_2drank(prc_myrank,1) == 0 ) ! only west-most  column processes write y coordinates
     else
        put_z = .true.
        put_x = .true.
        put_y = .true.
     end if
  
     if ( haszcoord .and. put_z ) then
        start_(1) = 1
        start_(2) = start(1)
  
        ! atmos
        call file_write_axis( fid, 'z', atmos_grid_cartesc_cz(ks:ke), start(1:1) )
        do k = ks, ke
           z_bnds(1,k) = atmos_grid_cartesc_fz(k-1)
           z_bnds(2,k) = atmos_grid_cartesc_fz(k  )
        end do
        call file_write_associatedcoordinate( fid, 'z_bnds', z_bnds(:,ks:ke), start_(:) )
  
        call file_write_axis( fid, 'zh', atmos_grid_cartesc_fz(ks-1:ke)  , start(1:1) )
        do k = ks-1, ke
           zh_bnds(1,k) = atmos_grid_cartesc_cz(k  )
           zh_bnds(2,k) = atmos_grid_cartesc_cz(k+1)
        end do
        call file_write_associatedcoordinate( fid, 'zh_bnds', zh_bnds(:,ks-1:ke), start_(:) )
  
        ! ocean
        if ( okmax > 0 ) then
           call file_write_axis( fid, 'oz', ocean_grid_cartesc_cz(oks:oke), start(1:1) )
           do k = oks, oke
              oz_bnds(1,k) = ocean_grid_cartesc_fz(k-1)
              oz_bnds(2,k) = ocean_grid_cartesc_fz(k  )
           end do
           call file_write_associatedcoordinate( fid, 'oz_bnds', oz_bnds(:,oks:oke), start_(:) )
  
           call file_write_axis( fid, 'ozh', ocean_grid_cartesc_fz(oks-1:oke), start(1:1) )
           ozh_bnds(1,oks-1) = ocean_grid_cartesc_fz(oks-1)
           do k = oks-1, oke-1
              ozh_bnds(2,k  ) = ocean_grid_cartesc_cz(k+1)
              ozh_bnds(1,k+1) = ocean_grid_cartesc_cz(k+1)
           end do
           ozh_bnds(2,oke) = ocean_grid_cartesc_fz(oke)
           call file_write_associatedcoordinate( fid, 'ozh_bnds', ozh_bnds(:,oks-1:oke), start_(:) )
        end if
  
        ! land
        if ( lkmax > 0 ) then
           call file_write_axis( fid, 'lz', land_grid_cartesc_cz(lks:lke), start(1:1) )
           do k = lks, lke
              lz_bnds(1,k) = land_grid_cartesc_fz(k-1)
              lz_bnds(2,k) = land_grid_cartesc_fz(k  )
           end do
           call file_write_associatedcoordinate( fid, 'lz_bnds', lz_bnds(:,lks:lke), start_(:) )
  
           call file_write_axis( fid, 'lzh', land_grid_cartesc_fz(lks-1:lke), start(1:1) )
           lzh_bnds(1,lks-1) = land_grid_cartesc_fz(lks-1)
           do k = lks-1, lke-1
              lzh_bnds(2,k  ) = land_grid_cartesc_cz(k+1)
              lzh_bnds(1,k+1) = land_grid_cartesc_cz(k+1)
           end do
           lzh_bnds(2,lke) = land_grid_cartesc_fz(lke)
           call file_write_associatedcoordinate( fid, 'lzh_bnds', lzh_bnds(:,lks-1:lke), start_(:) )
        end if
  
        ! urban
        if ( ukmax > 0 ) then
           call file_write_axis( fid, 'uz', urban_grid_cartesc_cz(uks:uke), start(1:1) )
           do k = uks, uke
              uz_bnds(1,k) = urban_grid_cartesc_fz(k-1)
              uz_bnds(2,k) = urban_grid_cartesc_fz(k  )
           end do
           call file_write_associatedcoordinate( fid, 'uz_bnds', uz_bnds(:,uks:uke), start_(:) )
  
           call file_write_axis( fid, 'uzh', urban_grid_cartesc_fz(uks-1:uke), start(1:1) )
           uzh_bnds(1,uks-1) = urban_grid_cartesc_fz(uks-1)
           do k = uks-1, uke-1
              uzh_bnds(2,k  ) = urban_grid_cartesc_cz(k+1)
              uzh_bnds(1,k+1) = urban_grid_cartesc_cz(k+1)
           end do
           uzh_bnds(2,uke) = urban_grid_cartesc_fz(uke)
           call file_write_associatedcoordinate( fid, 'uzh_bnds', uzh_bnds(:,uks-1:uke), start_(:) )
        end if
     end if
  
     if ( put_x ) then
        start_(1) = 1
        start_(2) = start(2)
  
        if ( file_get_aggregate(fid) ) then
           call file_write_axis( fid, 'x' ,  atmos_grid_cartesc_cx(isb2:ieb2),  start(2:2) )
           do i = isb2, ieb2
              x_bnds(1,i) = atmos_grid_cartesc_fx(i-1)
              x_bnds(2,i) = atmos_grid_cartesc_fx(i  )
           end do
           call file_write_associatedcoordinate( fid, 'x_bnds', x_bnds(:,isb2:ieb2), start_(:) )
  
           call file_write_axis( fid, 'xh',  atmos_grid_cartesc_fx(isb2:ieb2),  start(2:2) )
           do i = isb2, ieb2-1
              xh_bnds(1,i) = atmos_grid_cartesc_cx(i  )
              xh_bnds(2,i) = atmos_grid_cartesc_cx(i+1)
           end do
           xh_bnds(1,ieb2) = atmos_grid_cartesc_cx(ieb2)
           if ( ieb2 == ia ) then
              xh_bnds(2,ieb2) = atmos_grid_cartesc_fx(ieb2)
           else
              xh_bnds(2,ieb2) = atmos_grid_cartesc_cx(ieb2+1)
           end if
           call file_write_associatedcoordinate( fid, 'xh_bnds', xh_bnds(:,isb2:ieb2), start_(:) )
        else
           call file_write_axis( fid, 'x' ,  atmos_grid_cartesc_cx(isb:ieb),  start(2:2) )
           do i = isb2, ieb
              x_bnds(1,i) = atmos_grid_cartesc_fx(i-1)
              x_bnds(2,i) = atmos_grid_cartesc_fx(i  )
           end do
           call file_write_associatedcoordinate( fid, 'x_bnds', x_bnds(:,isb:ieb), start_(:) )
  
           call file_write_axis( fid, 'xh',  atmos_grid_cartesc_fx(isb:ieb),  start(2:2) )
           do i = isb, ieb-1
              xh_bnds(1,i) = atmos_grid_cartesc_cx(i  )
              xh_bnds(2,i) = atmos_grid_cartesc_cx(i+1)
           end do
           xh_bnds(1,ieb) = atmos_grid_cartesc_cx(ieb)
           if ( ieb == ia ) then
              xh_bnds(2,ieb) = atmos_grid_cartesc_fx(ieb)
           else
              xh_bnds(2,ieb) = atmos_grid_cartesc_cx(ieb+1)
           end if
           call file_write_associatedcoordinate( fid, 'xh_bnds', xh_bnds(:,isb:ieb), start_(:) )
        end if
     end if
  
     if ( put_y ) then
        start_(1) = 1
        start_(2) = start(3)
  
        if ( file_get_aggregate(fid) ) then
           call file_write_axis( fid, 'y' ,  atmos_grid_cartesc_cy(jsb2:jeb2),  start(3:3) )
           do j = jsb2, jeb2
              y_bnds(1,j) = atmos_grid_cartesc_fy(j-1)
              y_bnds(2,j) = atmos_grid_cartesc_fy(j  )
           end do
           call file_write_associatedcoordinate( fid, 'y_bnds', y_bnds(:,jsb2:jeb2), start_(:) )
  
           call file_write_axis( fid, 'yh',  atmos_grid_cartesc_fy(jsb2:jeb2),  start(3:3) )
           do j = jsb2, jeb2-1
              yh_bnds(1,j) = atmos_grid_cartesc_cy(j  )
              yh_bnds(2,j) = atmos_grid_cartesc_cy(j+1)
           end do
           yh_bnds(1,jeb2) = atmos_grid_cartesc_cy(jeb2)
           if ( jeb2 == ja ) then
              yh_bnds(2,jeb2) = atmos_grid_cartesc_fy(jeb2)
           else
              yh_bnds(2,jeb2) = atmos_grid_cartesc_cy(jeb2+1)
           end if
           call file_write_associatedcoordinate( fid, 'yh_bnds', yh_bnds(:,jsb2:jeb2), start_(:) )
        else
           call file_write_axis( fid, 'y' ,  atmos_grid_cartesc_cy(jsb:jeb),  start(3:3) )
           do j = jsb, jeb
              y_bnds(1,j) = atmos_grid_cartesc_fy(j-1)
              y_bnds(2,j) = atmos_grid_cartesc_fy(j  )
           end do
           call file_write_associatedcoordinate( fid, 'y_bnds', y_bnds(:,jsb:jeb), start_(:) )
  
           call file_write_axis( fid, 'yh',  atmos_grid_cartesc_fy(jsb:jeb),  start(3:3) )
           do j = jsb, jeb-1
              yh_bnds(1,j) = atmos_grid_cartesc_cy(j  )
              yh_bnds(2,j) = atmos_grid_cartesc_cy(j+1)
           end do
           yh_bnds(1,jeb) = atmos_grid_cartesc_cy(jeb2)
           if ( jeb == ja ) then
              yh_bnds(2,jeb) = atmos_grid_cartesc_fy(jeb)
           else
              yh_bnds(2,jeb) = atmos_grid_cartesc_cy(jeb+1)
           end if
           call file_write_associatedcoordinate( fid, 'yh_bnds', yh_bnds(:,jsb:jeb), start_(:) )
        end if
     end if
  
     fdxg(1:iag-1) = atmos_grid_cartesc_fdxg(:)
     fdxg(0  ) = undef
     fdxg(iag) = undef
     fdyg(1:jag-1) = atmos_grid_cartesc_fdyg(:)
     fdyg(0  ) = undef
     fdyg(jag) = undef
  
     fdx(1:ia-1) = atmos_grid_cartesc_fdx(:)
     fdx(0 ) = fdxg(is_ing-ihalo-1)
     fdx(ia) = fdxg(ie_ing+ihalo  )
     fdy(1:ja-1) = atmos_grid_cartesc_fdy(:)
     fdy(0 ) = fdyg(js_ing-jhalo-1)
     fdy(ja) = fdyg(je_ing+jhalo  )
  
     ! global coordinates (always including halo)
     if ( haszcoord .and. put_z ) then
        call file_write_axis( fid, 'CZ'  , atmos_grid_cartesc_cz(:), start(1:1) )
        call file_write_axis( fid, 'FZ'  , atmos_grid_cartesc_fz(:), start(1:1) )
        call file_write_axis( fid, 'CDZ' , atmos_grid_cartesc_cdz(:), start(1:1) )
        call file_write_axis( fid, 'FDZ' , atmos_grid_cartesc_fdz(:), start(1:1) )
        call file_write_axis( fid, 'CBFZ', atmos_grid_cartesc_cbfz(:), start(1:1) )
        call file_write_axis( fid, 'FBFZ', atmos_grid_cartesc_fbfz(:), start(1:1) )
  
        if ( okmax > 0 ) then
           call file_write_axis( fid, 'OCZ' , ocean_grid_cartesc_cz(:), start(1:1) )
           call file_write_axis( fid, 'OFZ' , ocean_grid_cartesc_fz(:), start(1:1) )
           call file_write_axis( fid, 'OCDZ', ocean_grid_cartesc_cdz(:), start(1:1) )
        end if
  
        if ( lkmax > 0 ) then
           call file_write_axis( fid, 'LCZ' , land_grid_cartesc_cz(:), start(1:1) )
           call file_write_axis( fid, 'LFZ' , land_grid_cartesc_fz(:), start(1:1) )
           call file_write_axis( fid, 'LCDZ', land_grid_cartesc_cdz(:), start(1:1) )
        end if
  
        if ( ukmax > 0 ) then
           call file_write_axis( fid, 'UCZ' , urban_grid_cartesc_cz(:), start(1:1) )
           call file_write_axis( fid, 'UFZ' , urban_grid_cartesc_fz(:), start(1:1) )
           call file_write_axis( fid, 'UCDZ', urban_grid_cartesc_cdz(:), start(1:1) )
        end if
     end if
  
     if ( file_get_aggregate(fid) ) then
        if ( prc_ismaster ) then
           call file_write_axis( fid, 'CX',   atmos_grid_cartesc_cxg(:) )
           call file_write_axis( fid, 'CY',   atmos_grid_cartesc_cyg(:) )
           call file_write_axis( fid, 'FX',   atmos_grid_cartesc_fxg(:) )
           call file_write_axis( fid, 'FY',   atmos_grid_cartesc_fyg(:) )
           call file_write_axis( fid, 'CDX',  atmos_grid_cartesc_cdxg(:) )
           call file_write_axis( fid, 'CDY',  atmos_grid_cartesc_cdyg(:) )
  
           call file_write_axis( fid, 'FDX',                     fdxg(:) )
           call file_write_axis( fid, 'FDY',                     fdyg(:) )
           call file_write_axis( fid, 'CBFX', atmos_grid_cartesc_cbfxg(:) )
           call file_write_axis( fid, 'CBFY', atmos_grid_cartesc_cbfyg(:) )
           call file_write_axis( fid, 'FBFX', atmos_grid_cartesc_fbfxg(:) )
           call file_write_axis( fid, 'FBFY', atmos_grid_cartesc_fbfyg(:) )
        endif
     else
        call file_write_axis( fid, 'CX',   atmos_grid_cartesc_cx(:) )
        call file_write_axis( fid, 'CY',   atmos_grid_cartesc_cy(:) )
        call file_write_axis( fid, 'FX',   atmos_grid_cartesc_fx(:) )
        call file_write_axis( fid, 'FY',   atmos_grid_cartesc_fy(:) )
        call file_write_axis( fid, 'CDX',  atmos_grid_cartesc_cdx(:) )
        call file_write_axis( fid, 'CDY',  atmos_grid_cartesc_cdy(:) )
        call file_write_axis( fid, 'FDX',                     fdx(:) )
        call file_write_axis( fid, 'FDY',                     fdy(:) )
        call file_write_axis( fid, 'CBFX', atmos_grid_cartesc_cbfx(:) )
        call file_write_axis( fid, 'CBFY', atmos_grid_cartesc_cbfy(:) )
        call file_write_axis( fid, 'FBFX', atmos_grid_cartesc_fbfx(:) )
        call file_write_axis( fid, 'FBFY', atmos_grid_cartesc_fbfy(:) )
     endif
  
     call file_write_axis( fid, 'CXG',   atmos_grid_cartesc_cxg(:) )
     call file_write_axis( fid, 'CYG',   atmos_grid_cartesc_cyg(:) )
     call file_write_axis( fid, 'FXG',   atmos_grid_cartesc_fxg(:) )
     call file_write_axis( fid, 'FYG',   atmos_grid_cartesc_fyg(:) )
     call file_write_axis( fid, 'CDXG',  atmos_grid_cartesc_cdxg(:) )
     call file_write_axis( fid, 'CDYG',  atmos_grid_cartesc_cdyg(:) )
     call file_write_axis( fid, 'FDXG',                     fdxg(:) )
     call file_write_axis( fid, 'FDYG',                     fdyg(:) )
     call file_write_axis( fid, 'CBFXG', atmos_grid_cartesc_cbfxg(:) )
     call file_write_axis( fid, 'CBFYG', atmos_grid_cartesc_cbfyg(:) )
     call file_write_axis( fid, 'FBFXG', atmos_grid_cartesc_fbfxg(:) )
     call file_write_axis( fid, 'FBFYG', atmos_grid_cartesc_fbfyg(:) )
  
     ! associate coordinates
     if ( file_get_aggregate(fid) ) then
        call file_write_associatedcoordinate( fid, 'lon'   , axis_lon(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lon_uy', axis_lonuy(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lon_xv', axis_lonxv(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lon_uv', axis_lonuv(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat'   , axis_lat(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat_uy', axis_latuy(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat_xv', axis_latxv(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat_uv', axis_latuv(:,:), start(2:3) )
  
        if ( haszcoord ) then
           call file_write_associatedcoordinate( fid, 'topo',   axis_topo(:,:), start(2:3) )
        end if
        call file_write_associatedcoordinate( fid, 'lsmask', axis_lsmask(:,:), start(2:3) )
  
        call file_write_associatedcoordinate( fid, 'cell_area',    axis_area(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'cell_area_uy', axis_areauy(:,:), start(2:3) )
        call file_write_associatedcoordinate( fid, 'cell_area_xv', axis_areaxv(:,:), start(2:3) )
  
        if ( haszcoord ) then
           call file_write_associatedcoordinate( fid, 'height'    , axis_hgt(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'height_wxy', axis_hgtwxy(:,:,:), start(1:3) )
  
           call file_write_associatedcoordinate( fid, 'cell_area_zuy_x', axis_areazuy_x(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zxv_y', axis_areazxv_y(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_wuy_x', axis_areawuy_x(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_wxv_y', axis_areawxv_y(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zxy_x', axis_areazxy_x(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zuv_y', axis_areazuv_y(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zuv_x', axis_areazuv_x(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zxy_y', axis_areazxy_y(:,:,:), start(1:3) )
  
           call file_write_associatedcoordinate( fid, 'cell_volume',     axis_vol(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_volume_wxy', axis_volwxy(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_volume_zuy', axis_volzuy(:,:,:), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_volume_zxv', axis_volzxv(:,:,:), start(1:3) )
  
           if ( okmax > 0 ) then
              call file_write_associatedcoordinate( fid, 'cell_volume_oxy', axis_volo(:,:,:), start(1:3) )
           end if
           if ( lkmax > 0 ) then
              call file_write_associatedcoordinate( fid, 'cell_volume_lxy', axis_voll(:,:,:), start(1:3) )
           end if
           if ( ukmax > 0 ) then
              call file_write_associatedcoordinate( fid, 'cell_volume_uxy', axis_volu(:,:,:), start(1:3) )
           end if
        end if
     else
        xsb = isb - isb2 + 1
        xeb = ieb - isb + xsb
        ysb = jsb - jsb2 + 1
        yeb = jeb - jsb + ysb
  
        call file_write_associatedcoordinate( fid, 'lon'   , axis_lon(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lon_uy', axis_lonuy(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lon_xv', axis_lonxv(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lon_uv', axis_lonuv(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat'   , axis_lat(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat_uy', axis_latuy(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat_xv', axis_latxv(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'lat_uv', axis_latuv(xsb:xeb,ysb:yeb), start(2:3) )
  
        if ( haszcoord ) then
           call file_write_associatedcoordinate( fid, 'topo',   axis_topo(xsb:xeb,ysb:yeb), start(2:3) )
        end if
        call file_write_associatedcoordinate( fid, 'lsmask', axis_lsmask(xsb:xeb,ysb:yeb), start(2:3) )
  
        call file_write_associatedcoordinate( fid, 'cell_area',    axis_area(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'cell_area_uy', axis_areauy(xsb:xeb,ysb:yeb), start(2:3) )
        call file_write_associatedcoordinate( fid, 'cell_area_xv', axis_areaxv(xsb:xeb,ysb:yeb), start(2:3) )
  
        if ( haszcoord ) then
           call file_write_associatedcoordinate( fid, 'height'    , axis_hgt(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'height_wxy', axis_hgtwxy(:,xsb:xeb,ysb:yeb), start(1:3) )
  
           call file_write_associatedcoordinate( fid, 'cell_area_zuy_x', axis_areazuy_x(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zxv_y', axis_areazxv_y(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_wuy_x', axis_areawuy_x(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_wxv_y', axis_areawxv_y(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zxy_x', axis_areazxy_x(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zuv_y', axis_areazuv_y(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zuv_x', axis_areazuv_x(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_area_zxy_y', axis_areazxy_y(:,xsb:xeb,ysb:yeb), start(1:3) )
  
           call file_write_associatedcoordinate( fid, 'cell_volume',     axis_vol(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_volume_wxy', axis_volwxy(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_volume_zuy', axis_volzuy(:,xsb:xeb,ysb:yeb), start(1:3) )
           call file_write_associatedcoordinate( fid, 'cell_volume_zxv', axis_volzxv(:,xsb:xeb,ysb:yeb), start(1:3) )
  
           if ( okmax > 0 ) then
              call file_write_associatedcoordinate( fid, 'cell_volume_oxy', axis_volo(:,xsb:xeb,ysb:yeb), start(1:3) )
           end if
           if ( lkmax > 0 ) then
              call file_write_associatedcoordinate( fid, 'cell_volume_lxy', axis_voll(:,xsb:xeb,ysb:yeb), start(1:3) )
           end if
           if ( ukmax > 0 ) then
              call file_write_associatedcoordinate( fid, 'cell_volume_uxy', axis_volu(:,xsb:xeb,ysb:yeb), start(1:3) )
           end if
        end if
     end if
  
     return

Referenced by file_cartesc_enddef().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_def_var()

subroutine, public scale_file_cartesc::file_cartesc_def_var	(	integer, intent(in)	fid,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	desc,
		character(len=*), intent(in)	unit,
		character(len=*), intent(in)	dim_type,
		character(len=*), intent(in)	datatype,
		integer, intent(out)	vid,
		character(len=*), intent(in), optional	standard_name,
		real(dp), intent(in), optional	timeintv,
		integer, intent(in), optional	nsteps,
		character(len=*), intent(in), optional	cell_measures
	)

Define a variable to file.

Parameters

[in]	fid	file ID
[in]	varname	name of the variable
[in]	desc	description of the variable
[in]	unit	unit of the variable
[in]	dim_type	axis type (Z/X/Y)
[in]	datatype	data type (REAL8/REAL4/default)
[out]	vid	variable ID
[in]	standard_name	standard name of the variable
[in]	timeintv	time interval [sec]
[in]	nsteps	number of time steps
[in]	cell_measures	"area" or "volume"

Definition at line 3360 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        file_real8, &
        file_real4
     use scale_file, only: &
        file_opened, &
        file_allnodes, &
        file_def_variable, &
        file_set_attribute
     use scale_prc, only: &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_twod
     use scale_mapprojection, only: &
        mapprojection_mappinginfo
     implicit none
  
     integer,          intent(in)  :: fid
     character(len=*), intent(in)  :: varname
     character(len=*), intent(in)  :: desc
     character(len=*), intent(in)  :: unit
     character(len=*), intent(in)  :: dim_type
     character(len=*), intent(in)  :: datatype
  
     integer, intent(out) :: vid
  
     character(len=*), intent(in), optional :: standard_name
     real(DP),         intent(in), optional :: timeintv
     integer,          intent(in), optional :: nsteps
     character(len=*), intent(in), optional :: cell_measures
  
     character(len=H_MID)   :: standard_name_
     character(len=H_SHORT) :: cell_measures_
  
     character(len=H_SHORT) :: dimtype
  
     integer :: dtype, elm_size, ndims
     integer :: dimid, n
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     if    ( datatype == 'REAL8' ) then
        dtype = file_real8
        elm_size = 4
     elseif( datatype == 'REAL4' ) then
        dtype = file_real4
        elm_size = 8
     else
        if    ( rp == 8 ) then
           dtype = file_real8
           elm_size = 8
        elseif( rp == 4 ) then
           dtype = file_real4
           elm_size = 4
        else
           log_error("FILE_CARTESC_def_var",*) 'unsupported data type. Check!', trim(datatype), ' item:',trim(varname)
           call prc_abort
        endif
     endif
  
     if ( prc_twod ) then
        select case( dim_type )
        case ( "UY" )
           dimtype = "XY"
        case ( "UV" )
           dimtype = "XV"
        case ( "ZXHY" )
           dimtype = "ZXY"
        case ( "ZXHYH")
           dimtype = "ZXYH"
        case ( "ZHXHY" )
           dimtype = "ZHXY"
        case default
           dimtype = dim_type
        end select
     else
        dimtype = dim_type
     end if
  
     dimid = -1
     do n = 1, file_cartesc_ndims
        if ( file_cartesc_dims(n)%name == dimtype ) then
           dimid = n
           exit
        end if
     end do
     if ( dimid <= -1 ) then
        log_error("FILE_CARTESC_def_var",*) 'dim_type is not supported: ', trim(dimtype)
        call prc_abort
     end if
  
     if ( present(nsteps) ) then
        write_buf_amount(fid) = write_buf_amount(fid) + file_cartesc_dims(dimid)%size * elm_size * nsteps
     else
        write_buf_amount(fid) = write_buf_amount(fid) + file_cartesc_dims(dimid)%size * elm_size
     end if
  
     ndims = file_cartesc_dims(dimid)%ndims
  
     if ( present(standard_name) ) then
        standard_name_ = standard_name
     else
        standard_name_ = ""
     end if
  
     if ( present(timeintv) ) then  ! 3D/4D variable with time dimension
       call file_def_variable( fid, varname, desc, unit, standard_name_,             & ! [IN]
                               ndims, file_cartesc_dims(dimid)%dims(1:ndims), dtype, & ! [IN]
                               vid,                                                  & ! [OUT]
                               time_int=timeintv                                     ) ! [IN]
     else
       call file_def_variable( fid, varname, desc, unit, standard_name_,             & ! [IN]
                               ndims, file_cartesc_dims(dimid)%dims(1:ndims), dtype, & ! [IN]
                               vid                                                   ) ! [OUT]
     endif
  
     if ( present(cell_measures) ) then
        cell_measures_ = cell_measures
        select case ( cell_measures )
        case ( "area" )
           if ( file_cartesc_dims(dimid)%area == "" ) then
              log_error("FILE_CARTESC_def_var",*) 'area is not supported for ', trim(dimtype), ' as cell_measures'
              call prc_abort
           end if
        case ( "area_z" )
           if ( file_cartesc_dims(dimid)%area == "" ) then
              log_error("FILE_CARTESC_def_var",*) 'area_z is not supported for ', trim(dimtype), ' as cell_measures'
              call prc_abort
           end if
        case ( "area_x" )
           if ( file_cartesc_dims(dimid)%area_x == "" ) then
              log_error("FILE_CARTESC_def_var",*) 'area_x is not supported for ', trim(dimtype), ' as cell_measures'
              call prc_abort
           end if
        case ( "area_y" )
           if ( file_cartesc_dims(dimid)%area_y == "" ) then
              log_error("FILE_CARTESC_def_var",*) 'area_y is not supported for ', trim(dimtype), ' as cell_measures'
              call prc_abort
           end if
        case ( "volume" )
           if ( file_cartesc_dims(dimid)%volume == "" ) then
              log_error("FILE_CARTESC_def_var",*) 'volume is not supported for ', trim(dimtype), ' as cell_measures'
              call prc_abort
           end if
        case default
           log_error("FILE_CARTESC_def_var",*) 'cell_measures must be "area" or "volume"'
           call prc_abort
        end select
     else if ( ndims == 2 ) then
        cell_measures_ = "area"
     else if ( ndims == 3 ) then
        cell_measures_ = "volume"
     else
        cell_measures_ = ""
     end if
  
     select case( cell_measures_ )
     case ( "area", "area_z" )
        call file_set_attribute( fid, varname, "cell_measures", "area: "//trim(file_cartesc_dims(dimid)%area) )
     case ( "area_x" )
        call file_set_attribute( fid, varname, "cell_measures", "area: "//trim(file_cartesc_dims(dimid)%area_x) )
     case ( "area_y" )
        call file_set_attribute( fid, varname, "cell_measures", "area: "//trim(file_cartesc_dims(dimid)%area_y) )
     case ( "volume" )
        call file_set_attribute( fid, varname, "cell_measures", "volume: "//trim(file_cartesc_dims(dimid)%volume) )
     end select
  
     ! mapping
     if ( file_cartesc_dims(dimid)%mapping .and. mapprojection_mappinginfo%mapping_name /= "" ) then
        call file_set_attribute( fid, varname, "grid_mapping", mapprojection_mappinginfo%mapping_name )
     end if
  
     ! SGRID
     if ( file_cartesc_dims(dimid)%location /= "" ) then
        call file_set_attribute( fid, varname, "grid",     file_cartesc_dims(dimid)%grid     )
        call file_set_attribute( fid, varname, "location", file_cartesc_dims(dimid)%location )
     end if
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

References scale_file::file_allnodes(), scale_file::file_def_variable(), scale_file::file_opened(), scale_file_h::file_real4, scale_file_h::file_real8, scale_mapprojection::mapprojection_mappinginfo, scale_prc::prc_abort(), scale_prc_cartesc::prc_twod, scale_prof::prof_rapend(), scale_prof::prof_rapstart(), and scale_precision::rp.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_write_var_1d()

subroutine scale_file_cartesc::file_cartesc_write_var_1d	(	integer, intent(in)	fid,
		integer, intent(in)	vid,
		real(rp), dimension(:), intent(in)	var,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type
	)

Write 1D data to file.

Parameters

[in]	fid	file ID
[in]	vid	netCDF variable ID
[in]	var	value of the variable
[in]	varname	name of the variable
[in]	dim_type	axis type (Z/X/Y)

Definition at line 3553 of file scale_file_cartesC.F90.

     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_write
     use scale_prc, only: &
        prc_myrank,  &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_2drank
     use scale_time, only: &
        nowdaysec => time_nowdaysec
     implicit none
  
     integer,          intent(in) :: fid
     integer,          intent(in) :: vid
     real(RP),         intent(in) :: var(:)
     character(len=*), intent(in) :: varname
     character(len=*), intent(in) :: dim_type
  
     integer :: dim1_S, dim1_E
     integer :: rankidx(2)
     integer :: start(1)         ! used only when AGGREGATE is .true.
     logical :: exec
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     rankidx(1) = prc_2drank(prc_myrank,1)
     rankidx(2) = prc_2drank(prc_myrank,2)
  
     if    ( dim_type == 'Z' ) then
        dim1_s   = ks
        dim1_e   = ke
        start(1) = 1
        if( file_get_aggregate(fid) .AND. prc_myrank > 0 ) then
           exec = .false.  ! only rank 0 writes
        else
           exec = .true.
        end if
     elseif( dim_type == 'X' ) then
        if ( file_get_aggregate(fid) ) then
           exec = ( rankidx(2) == 0 ) ! only south most row processes write
           dim1_s   = isb2
           dim1_e   = ieb2
        else
           exec = .true.
           dim1_s   = isb
           dim1_e   = ieb
        end if
        start(1) = isga
     elseif( dim_type == 'Y' ) then
        if ( file_get_aggregate(fid) ) then
           exec = ( rankidx(1) == 0 ) ! only west most column processes write
           dim1_s   = jsb2
           dim1_e   = jeb2
        else
           exec = .true.
           dim1_s   = jsb
           dim1_e   = jeb
        end if
        start(1) = jsga
     else
        log_error("FILE_CARTESC_write_var_1D",*) 'unsupported dimenstion type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
        call prc_abort
     endif
  
     if( exec ) call file_write( vid, var(dim1_s:dim1_e),          & ! [IN]
                                 nowdaysec, nowdaysec, start=start ) ! [IN]
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_write_1d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_write_var_2d()

subroutine scale_file_cartesc::file_cartesc_write_var_2d	(	integer, intent(in)	fid,
		integer, intent(in)	vid,
		real(rp), dimension(:,:), intent(in)	var,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		logical, intent(in), optional	fill_halo
	)

Write 2D data to file.

Parameters

[in]	fid	file ID
[in]	vid	netCDF variable ID
[in]	var	value of the variable
[in]	varname	name of the variable
[in]	dim_type	axis type (Z/X/Y)
[in]	fill_halo	switch whether include halo data or not (default=false)

Definition at line 3639 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        rmiss => file_rmiss
     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_write
     use scale_prc, only: &
        prc_myrank,     &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_2drank, &
        prc_num_x, &
        prc_num_y
     use scale_time, only: &
        nowdaysec  => time_nowdaysec
     implicit none
  
     integer,          intent(in)  :: fid
     integer,          intent(in)  :: vid
     real(RP),         intent(in)  :: var(:,:)
     character(len=*), intent(in)  :: varname
     character(len=*), intent(in)  :: dim_type
     logical,          intent(in), optional :: fill_halo
  
     real(RP), allocatable :: buf(:,:)
  
     integer               :: dim1_S, dim1_E
     integer               :: dim2_S, dim2_E
  
     integer :: i, j
     logical :: fill_halo_
     integer :: rankidx(2)
     integer :: start(2)         ! used only when AGGREGATE is .true.
     logical :: exec
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     rankidx(1) = prc_2drank(prc_myrank,1)
     rankidx(2) = prc_2drank(prc_myrank,2)
  
     start(1) = isga
     start(2) = jsga
  
     fill_halo_ = .false.
     if( present(fill_halo) ) fill_halo_ = fill_halo
  
     if (      dim_type == 'XY' &
          .OR. dim_type == 'UY' &
          .OR. dim_type == 'XV' &
          .OR. dim_type == 'UV' ) then
        if ( file_get_aggregate(fid) ) then
           dim1_s   = isb2
           dim1_e   = ieb2
           dim2_s   = jsb2
           dim2_e   = jeb2
        else
           dim1_s   = isb
           dim1_e   = ieb
           dim2_s   = jsb
           dim2_e   = jeb
        endif
        exec = .true.
     elseif( dim_type == 'ZX' ) then
        dim1_s   = ks
        dim1_e   = ke
        start(2) = start(1)
        start(1) = 1
        if ( file_get_aggregate(fid) ) then
           exec = ( rankidx(2) == 0 )  ! only south most row processes write
           dim2_s = isb2
           dim2_e = ieb2
        else
           exec = .true.
           dim2_s = isb
           dim2_e = ieb
        endif
     else
        log_error("FILE_CARTESC_write_var_2D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
        call prc_abort
     endif
  
     if ( exec ) then
  
        !$acc update host(var) if(acc_is_present(var))
  
        allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e) )
  
        if ( fill_halo_ ) then ! fill halo cells with RMISS
           do j = js, je
           do i = is, ie
              buf(i,j) = var(i,j)
           end do
           end do
  
           ! W halo
           do j = dim2_s, dim2_e
           do i = dim1_s, is-1
              buf(i,j) = rmiss
           enddo
           enddo
           ! E halo
           do j = dim2_s, dim2_e
           do i = ie+1,   dim1_e
              buf(i,j) = rmiss
           enddo
           enddo
           ! S halo
           do j = dim2_s, js-1
           do i = dim1_s, dim1_e
              buf(i,j) = rmiss
           enddo
           enddo
           ! N halo
           do j = je+1,   dim2_e
           do i = dim1_s, dim1_e
              buf(i,j) = rmiss
           enddo
           enddo
        else
           do j = dim2_s, dim2_e
           do i = dim1_s, dim1_e
              buf(i,j) = var(i,j)
           end do
           end do
        end if
  
        call file_write( vid, buf(:,:), nowdaysec, nowdaysec, start ) ! [IN]
        call file_cartesc_flush( fid )
  
        deallocate( buf )
  
     endif
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_write_1d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_write_var_3d()

subroutine scale_file_cartesc::file_cartesc_write_var_3d	(	integer, intent(in)	fid,
		integer, intent(in)	vid,
		real(rp), dimension(:,:,:), intent(in)	var,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		logical, intent(in), optional	fill_halo
	)

Write 3D data to file.

Parameters

[in]	fid	file ID
[in]	vid	netCDF variable ID
[in]	var	value of the variable
[in]	varname	name of the variable
[in]	dim_type	dimension type (Z/X/Y)
[in]	fill_halo	include halo data?

Definition at line 3790 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        rmiss => file_rmiss
     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_write
     use scale_prc, only: &
        prc_myrank,  &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_2drank, &
        prc_num_x,  &
        prc_num_y
     use scale_time, only: &
        nowdaysec  => time_nowdaysec
     implicit none
  
     integer,          intent(in) :: fid
     integer,          intent(in) :: vid
     real(RP),         intent(in) :: var(:,:,:)
     character(len=*), intent(in) :: varname
     character(len=*), intent(in) :: dim_type
  
     logical,          intent(in), optional :: fill_halo
  
     real(RP), allocatable :: buf(:,:,:)
  
     integer  :: dim1_S, dim1_E
     integer  :: dim2_S, dim2_E
     integer  :: dim3_S, dim3_E
  
     integer  :: i, j, k
     logical  :: fill_halo_
     integer  :: rankidx(2)
     integer  :: start(3) ! used only when AGGREGATE is .true.
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     fill_halo_ = .false.
     if( present(fill_halo) ) fill_halo_ = fill_halo
  
     rankidx(1) = prc_2drank(prc_myrank,1)
     rankidx(2) = prc_2drank(prc_myrank,2)
  
     start(1) = 1
     start(2) = isga
     start(3) = jsga
  
     if (      dim_type == 'ZXY'   &
          .OR. dim_type == 'ZXHY'  &
          .OR. dim_type == 'ZXYH'  &
          .OR. dim_type == 'ZXHYH' ) then
        dim1_s   = ks
        dim1_e   = ke
     elseif (  dim_type == 'ZHXY'  &
          .OR. dim_type == 'ZHXHY' &
          .OR. dim_type == 'ZHXYH' ) then
        dim1_s   = ks-1
        dim1_e   = ke
     elseif( dim_type == 'OXY' ) then
        dim1_s   = oks
        dim1_e   = oke
     elseif( dim_type == 'LXY' ) then
        dim1_s   = lks
        dim1_e   = lke
     elseif( dim_type == 'UXY' ) then
        dim1_s   = uks
        dim1_e   = uke
     else
        log_error("FILE_CARTESC_write_var_3D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
        call prc_abort
     endif
  
     if ( file_get_aggregate(fid) ) then
        dim2_s   = isb2
        dim2_e   = ieb2
        dim3_s   = jsb2
        dim3_e   = jeb2
     else
        dim2_s   = isb
        dim2_e   = ieb
        dim3_s   = jsb
        dim3_e   = jeb
     endif
  
     !$acc update host(var) if(acc_is_present(var))
  
     allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e,dim3_s:dim3_e) )
  
     if ( fill_halo_ ) then
  
        !$omp parallel do
        do j = js, je
        do i = is, ie
        do k = dim1_s, dim1_e
           buf(k,i,j) = var(k,i,j)
        enddo
        enddo
        enddo
  
        ! W halo
        do j = dim3_s, dim3_e
        do i = dim2_s, is-1
        do k = dim1_s, dim1_e
           buf(k,i,j) = rmiss
        enddo
        enddo
        enddo
        ! E halo
        do j = dim3_s, dim3_e
        do i = ie+1,   dim2_e
        do k = dim1_s, dim1_e
           buf(k,i,j) = rmiss
        enddo
        enddo
        enddo
        ! S halo
        do j = dim3_s, js-1
        do i = dim2_s, dim2_e
        do k = dim1_s, dim1_e
           buf(k,i,j) = rmiss
        enddo
        enddo
        enddo
        ! N halo
        do j = je+1,   dim3_e
        do i = dim2_s, dim2_e
        do k = dim1_s, dim1_e
           buf(k,i,j) = rmiss
        enddo
        enddo
        enddo
  
     else
  
        do j = dim3_s, dim3_e
        do i = dim2_s, dim2_e
        do k = dim1_s, dim1_e
           buf(k,i,j) = var(k,i,j)
        enddo
        enddo
        enddo
  
     end if
  
     call file_write( vid, buf(:,:,:), nowdaysec, nowdaysec, start ) ! [IN]
     call file_cartesc_flush( fid )
  
     deallocate( buf )
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_write_1d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_write_var_3d_t()

subroutine scale_file_cartesc::file_cartesc_write_var_3d_t	(	integer, intent(in)	fid,
		integer, intent(in)	vid,
		real(rp), dimension(:,:,:), intent(in)	var,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		real(dp), intent(in)	timeintv,
		integer, intent(in), optional	timetarg,
		real(dp), intent(in), optional	timeofs,
		logical, intent(in), optional	fill_halo
	)

Write 3D data with time dimension to file.

Parameters

[in]	fid	file ID
[in]	vid	netCDF variable ID
[in]	var	value of the variable
[in]	varname	name of the variable
[in]	dim_type	dimension type (X/Y/Time)
[in]	timeintv	time interval [sec]
[in]	timetarg	target timestep (optional)
[in]	timeofs	offset time (optional)
[in]	fill_halo	include halo data?

Definition at line 3961 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        rmiss => file_rmiss
     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_write
     use scale_prc, only: &
        prc_myrank,     &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_2drank, &
        prc_num_x, &
        prc_num_y
     implicit none
  
     integer,          intent(in) :: fid
     integer,          intent(in) :: vid
     real(RP),         intent(in) :: var(:,:,:)
     character(len=*), intent(in) :: varname
     character(len=*), intent(in) :: dim_type
     real(DP),         intent(in) :: timeintv
  
     integer,          intent(in), optional :: timetarg
     real(DP),         intent(in), optional :: timeofs
     logical,          intent(in), optional :: fill_halo
  
     real(RP), allocatable :: buf(:,:)
  
     integer  :: dim1_S, dim1_E
     integer  :: dim2_S, dim2_E
  
     real(DP) :: time_interval, nowtime
  
     integer  :: step
     integer  :: i, j, n
     logical  :: fill_halo_
     real(DP) :: timeofs_
     integer  :: rankidx(2)
     integer  :: start(2) ! used only when AGGREGATE is .true.
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     fill_halo_ = .false.
     if( present(fill_halo) ) fill_halo_ = fill_halo
  
     timeofs_ = 0.0_dp
     if( present(timeofs) ) timeofs_ = timeofs
  
     time_interval = timeintv
     step = size(var(isb,jsb,:))
  
     rankidx(1) = prc_2drank(prc_myrank,1)
     rankidx(2) = prc_2drank(prc_myrank,2)
  
     if ( dim_type == 'XYT' ) then
        if ( file_get_aggregate(fid) ) then
           dim1_s   = isb2
           dim1_e   = ieb2
           dim2_s   = jsb2
           dim2_e   = jeb2
        else
           dim1_s   = isb
           dim1_e   = ieb
           dim2_s   = jsb
           dim2_e   = jeb
        end if
     else
        log_error("FILE_CARTESC_write_var_3D_t",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
        call prc_abort
     endif
  
     start(1) = isga
     start(2) = jsga
     ! start(3) time dimension will be set in file_write_data()
  
     allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e) )
  
     if ( present(timetarg) ) then
        nowtime = timeofs_ + (timetarg-1) * time_interval
  
        !$acc update host(var) if(acc_is_present(var))
  
        if ( fill_halo_ ) then
  
           do j = js, je
           do i = is, ie
              buf(i,j) = var(i,j,timetarg)
           end do
           end do
  
           ! W halo
           do j = dim2_s, dim2_e
           do i = dim1_s, is-1
              buf(i,j) = rmiss
           enddo
           enddo
           ! E halo
           do j = dim2_s, dim2_e
           do i = ie+1,   dim1_e
              buf(i,j) = rmiss
           enddo
           enddo
           ! S halo
           do j = dim2_s, js-1
           do i = dim1_s, dim1_e
              buf(i,j) = rmiss
           enddo
           enddo
           ! N halo
           do j = je+1,   dim2_e
           do i = dim1_s, dim1_e
              buf(i,j) = rmiss
           enddo
           enddo
  
        else
  
           do j = dim2_s, dim2_e
           do i = dim1_s, dim1_e
              buf(i,j) = var(i,j,timetarg)
           enddo
           enddo
  
        end if
  
        call file_write( vid, buf(:,:), nowtime, nowtime, start ) ! [IN]
        call file_cartesc_flush( fid )
  
     else
        nowtime = timeofs_
  
        !$acc update host(var) if(acc_is_present(var))
  
        do n = 1, step
           if ( fill_halo_ ) then
  
              do j = js, je
              do i = is, ie
                 buf(i,j) = var(i,j,n)
              end do
              end do
  
              ! W halo
              do j = dim2_s, dim2_e
              do i = dim1_s, is-1
                 buf(i,j) = rmiss
              enddo
              enddo
              ! E halo
              do j = dim2_s, dim2_e
              do i = ie+1,   dim1_e
                 buf(i,j) = rmiss
              enddo
              enddo
              ! S halo
              do j = dim2_s, js-1
              do i = dim1_s, dim1_e
                 buf(i,j) = rmiss
              enddo
              enddo
              ! N halo
              do j = je+1,   dim2_e
              do i = dim1_s, dim1_e
                 buf(i,j) = rmiss
              enddo
              enddo
  
           else
  
              do j = dim2_s, dim2_e
              do i = dim1_s, dim1_e
                 buf(i,j) = var(i,j,n)
              enddo
              enddo
  
           end if
  
           call file_write( vid, buf(:,:), nowtime, nowtime, start ) ! [IN]
           call file_cartesc_flush( fid )
  
           nowtime = nowtime + time_interval
        enddo
     endif
  
     deallocate( buf )
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_write_1d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_cartesc_write_var_4d()

subroutine scale_file_cartesc::file_cartesc_write_var_4d	(	integer, intent(in)	fid,
		integer, intent(in)	vid,
		real(rp), dimension(:,:,:,:), intent(in)	var,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	dim_type,
		real(dp), intent(in)	timeintv,
		integer, intent(in), optional	timetarg,
		real(dp), intent(in), optional	timeofs,
		logical, intent(in), optional	fill_halo
	)

Write 4D data to file.

Parameters

[in]	fid	file ID
[in]	vid	netCDF variable ID
[in]	var	value of the variable
[in]	varname	name of the variable
[in]	dim_type	dimension type (Z/X/Y/Time)
[in]	timeintv	time interval [sec]
[in]	timetarg	target timestep (optional)
[in]	timeofs	offset time (optional)
[in]	fill_halo	include halo data?

Definition at line 4168 of file scale_file_cartesC.F90.

     use scale_file_h, only: &
        rmiss => file_rmiss
     use scale_file, only: &
        file_get_aggregate, &
        file_opened, &
        file_allnodes, &
        file_write
     use scale_prc, only: &
        prc_myrank,     &
        prc_abort
     use scale_prc_cartesc, only: &
        prc_2drank, &
        prc_num_x, &
        prc_num_y
     implicit none
  
     integer,          intent(in) :: fid
     integer,          intent(in) :: vid
     real(RP),         intent(in) :: var(:,:,:,:)
     character(len=*), intent(in) :: varname
     character(len=*), intent(in) :: dim_type
     real(DP),         intent(in) :: timeintv
  
     integer,          intent(in), optional :: timetarg
     real(DP),         intent(in), optional :: timeofs
     logical,          intent(in), optional :: fill_halo
  
     real(RP), allocatable :: buf(:,:,:)
  
     integer  :: dim1_S, dim1_E
     integer  :: dim2_S, dim2_E
     integer  :: dim3_S, dim3_E
  
     real(DP) :: time_interval, nowtime
  
     integer  :: step
     integer  :: i, j, k, n
     logical  :: fill_halo_
     real(DP) :: timeofs_
     integer  :: rankidx(2)
     integer  :: start(3) ! used only when AGGREGATE is .true.
     !---------------------------------------------------------------------------
  
     if ( .not. file_opened(fid) ) return
  
     call prof_rapstart('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     fill_halo_ = .false.
     if( present(fill_halo) ) fill_halo_ = fill_halo
  
     timeofs_ = 0.0_dp
     if( present(timeofs) ) timeofs_ = timeofs
  
     rankidx(1) = prc_2drank(prc_myrank,1)
     rankidx(2) = prc_2drank(prc_myrank,2)
  
     start(1) = 1
     start(2) = isga
     start(3) = jsga
     ! start(4) time dimension will be set in file_write_data()
  
     time_interval = timeintv
     step = size(var,4)
  
     if ( file_get_aggregate(fid) ) then
        dim2_s   = isb2
        dim2_e   = ieb2
        dim3_s   = jsb2
        dim3_e   = jeb2
     else
        dim2_s   = isb
        dim2_e   = ieb
        dim3_s   = jsb
        dim3_e   = jeb
     endif
  
     if (      dim_type == 'ZXYT'  &
          .OR. dim_type == 'ZXHYT' &
          .OR. dim_type == 'ZXYHT' ) then
        dim1_s   = ks
        dim1_e   = ke
     elseif ( dim_type == 'ZHXYT' ) then
        dim1_s   = ks-1
        dim1_e   = ke
     elseif( dim_type == 'OXYT' ) then
        dim1_s   = oks
        dim1_e   = oke
     elseif( dim_type == 'OHXYT' ) then
        dim1_s   = oks-1
        dim1_e   = oke
     elseif( dim_type == 'LXYT' ) then
        dim1_s   = lks
        dim1_e   = lke
     elseif( dim_type == 'LHXYT' ) then
        dim1_s   = lks-1
        dim1_e   = lke
     elseif( dim_type == 'UXYT' ) then
        dim1_s   = uks
        dim1_e   = uke
     elseif( dim_type == 'UHXYT' ) then
        dim1_s   = uks-1
        dim1_e   = uke
     else
        log_error("FILE_CARTESC_write_var_4D",*) 'unsupported dimension type. Check! dim_type:', trim(dim_type), ', item:',trim(varname)
        call prc_abort
     endif
  
     allocate( buf(dim1_s:dim1_e,dim2_s:dim2_e,dim3_s:dim3_e) )
  
     !$acc update host(var) if(acc_is_present(var))
  
     if ( present(timetarg) ) then
        nowtime = timeofs_ + (timetarg-1) * time_interval
  
        if ( fill_halo_ ) then
  
           do j = js, je
           do i = is, ie
           do k = dim1_s, dim1_e
              buf(k,i,j) = var(k,i,j,timetarg)
           end do
           end do
           end do
  
           ! W halo
           do j = dim3_s, dim3_e
           do i = dim2_s, is-1
           do k = dim1_s, dim1_e
              buf(k,i,j) = rmiss
           enddo
           enddo
           enddo
           ! E halo
           do j = dim3_s, dim3_e
           do i = ie+1,   dim2_e
           do k = dim1_s, dim1_e
              buf(k,i,j) = rmiss
           enddo
           enddo
           enddo
           ! S halo
           do j = dim3_s, js-1
           do i = dim2_s, dim2_e
           do k = dim1_s, dim1_e
              buf(k,i,j) = rmiss
           enddo
           enddo
           enddo
           ! N halo
           do j = je+1,   dim3_e
           do i = dim2_s, dim2_e
           do k = dim1_s, dim1_e
              buf(k,i,j) = rmiss
           enddo
           enddo
           enddo
  
        else
  
           do j = dim3_s, dim3_e
           do i = dim2_s, dim2_e
           do k = dim1_s, dim1_e
              buf(k,i,j) = var(k,i,j,timetarg)
           enddo
           enddo
           enddo
  
        end if
  
        call file_write( vid, buf(:,:,:), nowtime, nowtime, start ) ! [IN]
        call file_cartesc_flush( fid )
  
     else
        nowtime = timeofs_
        do n = 1, step
           if ( fill_halo_ ) then
  
              do j = js, je
              do i = is, ie
              do k = dim1_s, dim1_e
                 buf(k,i,j) = var(k,i,j,n)
              end do
              end do
              end do
  
              ! W halo
              do j = dim3_s, dim3_e
              do i = dim2_s, is-1
              do k = dim1_s, dim1_e
                 buf(k,i,j) = rmiss
              enddo
              enddo
              enddo
              ! E halo
              do j = dim3_s, dim3_e
              do i = ie+1,   dim2_e
              do k = dim1_s, dim1_e
                 buf(k,i,j) = rmiss
              enddo
              enddo
              enddo
              ! S halo
              do j = dim3_s, js-1
              do i = dim2_s, dim2_e
              do k = dim1_s, dim1_e
                 buf(k,i,j) = rmiss
              enddo
              enddo
              enddo
              ! N halo
              do j = je+1,   dim3_e
              do i = dim2_s, dim2_e
              do k = dim1_s, dim1_e
                 buf(k,i,j) = rmiss
              enddo
              enddo
              enddo
  
           else
  
              do j = dim3_s, dim3_e
              do i = dim2_s, dim2_e
              do k = dim1_s, dim1_e
                 buf(k,i,j) = var(k,i,j,n)
              enddo
              enddo
              enddo
  
           end if
  
           call file_write( vid, buf(:,:,:), nowtime, nowtime, start ) ! [IN]
           call file_cartesc_flush( fid )
  
           nowtime = nowtime + time_interval
  
        enddo
     endif
  
     deallocate( buf )
  
     call prof_rapend('FILE_Write', 2, disable_barrier = .not. file_allnodes(fid) )
  
     return

Referenced by file_cartesc_write_1d().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_dimension_informations()

subroutine scale_file_cartesc::set_dimension_informations

Definition at line 4600 of file scale_file_cartesC.F90.

     use scale_prc_cartesc, only: &
        prc_periodic_x, &
        prc_periodic_y, &
        prc_num_x,      &
        prc_num_y,      &
        prc_has_w,      &
        prc_has_e,      &
        prc_has_s,      &
        prc_has_n
     implicit none
     !---------------------------------------------------------------------------
  
     ! Dimension Information
  
     ! 1D variable
     call set_dimension( 'Z', 1, 'z', ka )
     call set_dimension( 'X', 1, 'x', ia )
     call set_dimension( 'Y', 1, 'y', ja )
  
     ! 2D variable
     call set_dimension( 'XY', 2, (/ 'x' , 'y'  /), ia*ja, .true., area='cell_area',    location='face'  )
     call set_dimension( 'UY', 2, (/ 'xh', 'y ' /), ia*ja, .true., area='cell_area_uy', location='edge1' )
     call set_dimension( 'XV', 2, (/ 'x ', 'yh' /), ia*ja, .true., area='cell_area_xv', location='edge2' )
     call set_dimension( 'UV', 2, (/ 'xh', 'yh' /), ia*ja, .true.,                      location='node'  )
  
     call set_dimension( 'ZX', 2, (/ 'z', 'x' /), ka*ia )
     call set_dimension( 'ZY', 2, (/ 'z', 'y' /), ka*ja )
  
     ! 3D variable
     call set_dimension( 'ZXY',   3, (/ 'z',  'x',  'y'  /), ka*ia*ja,     .true.,                &
                         area='cell_area',    area_x='cell_area_zxy_x', area_y='cell_area_zxy_y', &
                         volume='cell_volume',     location='face'                                )
     call set_dimension( 'ZHXY',  3, (/ 'zh', 'x ', 'y ' /), (ka+1)*ia*ja, .true.,                &
                         area='cell_area',    area_x='cell_area_wxy_x', area_y='cell_area_wxy_y', &
                         volume='cell_volume_wxy', location='face'                                )
     call set_dimension( 'ZXHY',  3, (/ 'z ', 'xh', 'y ' /), ka*ia*ja,     .true.,                &
                         area='cell_area_uy', area_x='cell_area_zuy_x',                           &
                         volume='cell_volume_zuy', location='edge1'                               )
     call set_dimension( 'ZXYH',  3, (/ 'z ', 'x ', 'yh' /), ka*ia*ja,     .true.,                &
                         area='cell_area_xv',                           area_y='cell_area_zxv_y', &
                         volume='cell_volume_zxv', location='edge2'                               )
     call set_dimension( 'ZXHYH', 3, (/ 'z ', 'xh', 'yh' /), ka*ia*ja,     .true., &
                                              area_x='cell_area_zuv_x', area_y='cell_area_zuv_y', &
                                                   location='node'                                )
     call set_dimension( 'ZHXHY', 3, (/ 'zh', 'xh', 'y ' /), (ka+1)*ia*ja, .true., &
                                              area_x='cell_area_wuy_x',                           &
                                                   location='edge1'                               )
     call set_dimension( 'ZHXYH', 3, (/ 'zh', 'x ', 'yh' /), (ka+1)*ia*ja, .true., &
                                                                        area_y='cell_area_wxv_y', &
                                                   location='edge2'                               )
  
     if ( okmax > 0 ) then
        call set_dimension( 'OXY',  3, (/ 'oz',  'x ',  'y '  /), okmax*ia*ja,     .true., area='cell_area', volume='cell_volume_oxy', location='face', grid='ocean' )
        call set_dimension( 'OHXY', 3, (/ 'ozh', 'x  ', 'y  ' /), (okmax+1)*ia*ja, .true., area='cell_area', volume='cell_volume_oxy', location='face', grid='ocean' )
     end if
     if ( lkmax > 0 ) then
        call set_dimension( 'LXY',  3, (/ 'lz',  'x ',  'y '  /), lkmax*ia*ja,     .true., area='cell_area', volume='cell_volume_lxy', location='face', grid='land'  )
        call set_dimension( 'LHXY', 3, (/ 'lzh', 'x  ', 'y  ' /), (lkmax+1)*ia*ja, .true., area='cell_area', volume='cell_volume_lxy', location='face', grid='land'  )
     end if
     if ( ukmax > 0 ) then
        call set_dimension( 'UXY',  3, (/ 'uz',  'x ',  'y '  /), ukmax*ia*ja,     .true., area='cell_area', volume='cell_volume_uxy', location='face', grid='urban' )
        call set_dimension( 'UHXY', 3, (/ 'uzh', 'x  ', 'y  ' /), (ukmax+1)*ia*ja, .true., area='cell_area', volume='cell_volume_uxy', location='face', grid='urban' )
     end if
  
  
     ! Axis information
  
     if ( prc_periodic_x ) then
        file_cartesc_axis_info(1)%periodic = .true.
        file_cartesc_axis_info(2)%periodic = .true.
     else
        file_cartesc_axis_info(1)%periodic = .false.
        file_cartesc_axis_info(2)%periodic = .false.
     endif
  
     if ( prc_periodic_y ) then
        file_cartesc_axis_info(3)%periodic = .true.
        file_cartesc_axis_info(4)%periodic = .true.
     else
        file_cartesc_axis_info(3)%periodic = .false.
        file_cartesc_axis_info(4)%periodic = .false.
     endif
  
  
     ! for x
     if ( prc_periodic_x ) then
        file_cartesc_axis_info(1)%size_global (1) = imax * prc_num_x
        file_cartesc_axis_info(1)%start_global(1) = is_ing - ihalo
        file_cartesc_axis_info(1)%halo_global (1) = 0     ! west side
        file_cartesc_axis_info(1)%halo_global (2) = 0     ! east side
        file_cartesc_axis_info(1)%halo_local  (1) = 0     ! west side
        file_cartesc_axis_info(1)%halo_local  (2) = 0     ! east side
     else
        file_cartesc_axis_info(1)%size_global (1) = iag
        file_cartesc_axis_info(1)%start_global(1) = isga
        file_cartesc_axis_info(1)%halo_global (1) = ihalo ! west side
        file_cartesc_axis_info(1)%halo_global (2) = ihalo ! east side
        file_cartesc_axis_info(1)%halo_local  (1) = ihalo ! west side
        file_cartesc_axis_info(1)%halo_local  (2) = ihalo ! east side
        if( prc_has_w ) file_cartesc_axis_info(1)%halo_local(1) = 0
        if( prc_has_e ) file_cartesc_axis_info(1)%halo_local(2) = 0
     endif
     ! for xh
     file_cartesc_axis_info(2) = file_cartesc_axis_info(1)
  
     ! for y
     if ( prc_periodic_y ) then
        file_cartesc_axis_info(3)%size_global (1) = jmax * prc_num_y
        file_cartesc_axis_info(3)%start_global(1) = js_ing - jhalo
        file_cartesc_axis_info(3)%halo_global (1) = 0     ! south side
        file_cartesc_axis_info(3)%halo_global (2) = 0     ! north side
        file_cartesc_axis_info(3)%halo_local  (1) = 0     ! south side
        file_cartesc_axis_info(3)%halo_local  (2) = 0     ! north side
     else
        file_cartesc_axis_info(3)%size_global (1) = jag
        file_cartesc_axis_info(3)%start_global(1) = jsga
        file_cartesc_axis_info(3)%halo_global (1) = jhalo ! south side
        file_cartesc_axis_info(3)%halo_global (2) = jhalo ! north side
        file_cartesc_axis_info(3)%halo_local  (1) = jhalo ! south side
        file_cartesc_axis_info(3)%halo_local  (2) = jhalo ! north side
        if( prc_has_s ) file_cartesc_axis_info(3)%halo_local(1) = 0
        if( prc_has_n ) file_cartesc_axis_info(3)%halo_local(2) = 0
     endif
     ! for yh
     file_cartesc_axis_info(4) = file_cartesc_axis_info(3)
  
  
     return

Referenced by file_cartesc_def_axes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_dimension()

subroutine scale_file_cartesc::set_dimension	(	character(len=*), intent(in)	name,
		integer, intent(in)	ndims,
		character(len=*), dimension(ndims), intent(in)	dims,
		integer, intent(in)	size,
		logical, intent(in), optional	mapping,
		character(len=*), intent(in), optional	area,
		character(len=*), intent(in), optional	area_x,
		character(len=*), intent(in), optional	area_y,
		character(len=*), intent(in), optional	volume,
		character(len=*), intent(in), optional	location,
		character(len=*), intent(in), optional	grid
	)

Definition at line 4731 of file scale_file_cartesC.F90.

     use scale_prc, only: &
        prc_abort
     character(len=*), intent(in) :: name
     integer,          intent(in) :: ndims
     character(len=*), intent(in) :: dims(ndims)
     integer,          intent(in) :: size
     logical,          intent(in), optional :: mapping
     character(len=*), intent(in), optional :: area
     character(len=*), intent(in), optional :: area_x
     character(len=*), intent(in), optional :: area_y
     character(len=*), intent(in), optional :: volume
     character(len=*), intent(in), optional :: location
     character(len=*), intent(in), optional :: grid
  
     integer, save :: dimid = 0
  
     integer :: n
  
     do n = 1, 2
        dimid = dimid + 1
        if ( dimid > file_cartesc_ndims ) then
           log_error("set_dimension",*) 'number of dimensions exceeds the limit', dimid, file_cartesc_ndims
           call prc_abort
        end if
  
        if ( n==1 ) then
           file_cartesc_dims(dimid)%name = name
        else
           file_cartesc_dims(dimid)%name = trim(name)//"T"
        end if
        file_cartesc_dims(dimid)%ndims         = ndims
        file_cartesc_dims(dimid)%dims(1:ndims) = dims(:)
        file_cartesc_dims(dimid)%size          = size
  
        if ( present(mapping) ) then
           file_cartesc_dims(dimid)%mapping  = mapping
        else
           file_cartesc_dims(dimid)%mapping  = .false.
        end if
  
        if ( present(area) ) then
           file_cartesc_dims(dimid)%area     = area
        else
           file_cartesc_dims(dimid)%area     = ''
        end if
        if ( present(area_x) ) then
           file_cartesc_dims(dimid)%area     = area_x
        else
           file_cartesc_dims(dimid)%area     = ''
        end if
        if ( present(area_y) ) then
           file_cartesc_dims(dimid)%area     = area_y
        else
           file_cartesc_dims(dimid)%area     = ''
        end if
  
        if ( present(volume) ) then
           file_cartesc_dims(dimid)%volume   = volume
        else
           file_cartesc_dims(dimid)%volume   = ''
        end if
  
        if ( present(location) ) then
           file_cartesc_dims(dimid)%location = location
           if ( present(grid) ) then
              file_cartesc_dims(dimid)%grid = 'grid_'//trim(grid)
           else
              file_cartesc_dims(dimid)%grid = 'grid'
           end if
        else
           file_cartesc_dims(dimid)%location = ''
           file_cartesc_dims(dimid)%grid     = ''
        end if
  
     end do
  
     return

References scale_prc::prc_abort().

Referenced by set_dimension_informations().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ construct_derived_datatype()

subroutine scale_file_cartesc::construct_derived_datatype

construct MPI derived datatypes for read buffers

Definition at line 4813 of file scale_file_cartesC.F90.

     use mpi
     use scale_prc_cartesc, only: &
        prc_num_x,  &
        prc_num_y
     implicit none
  
     integer :: err, order
     integer :: sizes(3), subsizes(3), sub_off(3)
     !---------------------------------------------------------------------------
  
     order           = mpi_order_fortran
  
     centertypexy    = mpi_datatype_null
     centertypezx    = mpi_datatype_null
     centertypezxy   = mpi_datatype_null
     centertypezhxy  = mpi_datatype_null
     centertypeocean = mpi_datatype_null
     centertypeland  = mpi_datatype_null
     centertypeurban = mpi_datatype_null
  
     etype           = mpi_float
  
     if( rp == 8 ) etype = mpi_double
  
     ! for dim_type == 'XY'
     startxy(1)    = is_ing - ihalo
     startxy(2)    = js_ing - jhalo
     countxy(1)    = ia
     countxy(2)    = ja
     ! for dim_type == 'ZXY'
     startzxy(1)    = 1
     startzxy(2:3)  = startxy(1:2)
     countzxy(1)    = kmax
     countzxy(2:3)  = countxy(1:2)
     ! construct MPI subarray data type
     sizes(1)      = ka
     sizes(2)      = ia
     sizes(3)      = ja
     subsizes(1)   = kmax
     subsizes(2)   = ia
     subsizes(3)   = ja
     sub_off(1)    = ks - 1 ! MPI start index starts with 0
     sub_off(2)    = 0
     sub_off(3)    = 0
     call mpi_type_create_subarray(3, sizes, subsizes, sub_off, order, etype, centertypezxy, err)
     call mpi_type_commit(centertypezxy, err)
  
     ! for dim_type == 'ZHXY'
     startzhxy(1)   = 1
     startzhxy(2:3) = startxy(1:2)
     countzhxy(1)   = kmax+1
     countzhxy(2:3) = countxy(1:2)
     ! construct MPI subarray data type
     sizes(1)      = ka
     sizes(2)      = ia
     sizes(3)      = ja
     subsizes(1)   = kmax+1
     subsizes(2)   = ia
     subsizes(3)   = ja
     sub_off(1)    = ks - 2 ! MPI start index starts with 0
     sub_off(2)    = 0
     sub_off(3)    = 0
     call mpi_type_create_subarray(3, sizes, subsizes, sub_off, order, etype, centertypezhxy, err)
     call mpi_type_commit(centertypezhxy, err)
  
     if ( okmax > 0 ) then
        ! for dim_type == 'OXY'
        startocean(1)   = 1
        startocean(2:3) = startxy(1:2)
        countocean(1)   = okmax
        countocean(2:3) = countxy(1:2)
        ! construct MPI subarray data type
        sizes(1)       = okmax
        subsizes(1)    = okmax
        sub_off(1)     = oks - 1 ! MPI start index starts with 0
        call mpi_type_create_subarray(3, sizes, subsizes, sub_off, order, etype, centertypeocean, err)
        call mpi_type_commit(centertypeocean, err)
     end if
  
     if ( lkmax > 0 ) then
        ! for dim_type == 'LXY'
        startland(1)   = 1
        startland(2:3) = startxy(1:2)
        countland(1)   = lkmax
        countland(2:3) = countxy(1:2)
        ! construct MPI subarray data type
        sizes(1)       = lkmax
        subsizes(1)    = lkmax
        sub_off(1)     = lks - 1 ! MPI start index starts with 0
        call mpi_type_create_subarray(3, sizes, subsizes, sub_off, order, etype, centertypeland, err)
        call mpi_type_commit(centertypeland, err)
     end if
  
     if ( ukmax > 0 ) then
        ! for dim_type == 'UXY'
        starturban(1)   = 1
        starturban(2:3) = startxy(1:2)
        counturban(1)   = ukmax
        counturban(2:3) = countxy(1:2)
        ! construct MPI subarray data type
        sizes(1)        = ukmax
        subsizes(1)     = ukmax
        sub_off(1)      = uks - 1 ! MPI start index starts with 0
        call mpi_type_create_subarray(3, sizes, subsizes, sub_off, order, etype, centertypeurban, err)
        call mpi_type_commit(centertypeurban, err)
     end if
  
     ! for dim_type == 'ZX'
     startzx(1)  = khalo+1
     startzx(2)  = is_ing - ihalo
     countzx(1)  = kmax
     countzx(2)  = ia
     ! construct MPI subarray data type
     sizes(1)    = ka
     sizes(2)    = ia
     subsizes(1) = kmax
     subsizes(2) = imaxb
     sub_off(1)  = khalo   ! MPI start index starts with 0
     sub_off(2)  = isb - 1 ! MPI start index starts with 0
     call mpi_type_create_subarray(2, sizes, subsizes, sub_off, order, etype, centertypezx, err)
     call mpi_type_commit(centertypezx, err)
  
     return

Referenced by file_cartesc_setup().

Here is the caller graph for this function:

◆ free_derived_datatype()

subroutine scale_file_cartesc::free_derived_datatype

free MPI derived datatypes

Definition at line 4941 of file scale_file_cartesC.F90.

     use mpi
     implicit none
  
     integer :: err
     !---------------------------------------------------------------------------
  
     if( centertypexy    /= mpi_datatype_null ) call mpi_type_free(centertypexy,    err)
     if( centertypezx    /= mpi_datatype_null ) call mpi_type_free(centertypezx,    err)
     if( centertypezxy   /= mpi_datatype_null ) call mpi_type_free(centertypezxy,   err)
     if( centertypezhxy  /= mpi_datatype_null ) call mpi_type_free(centertypezhxy,  err)
     if( centertypeocean /= mpi_datatype_null ) call mpi_type_free(centertypeocean, err)
     if( centertypeland  /= mpi_datatype_null ) call mpi_type_free(centertypeland,  err)
     if( centertypeurban /= mpi_datatype_null ) call mpi_type_free(centertypeurban, err)
  
     return

Referenced by file_cartesc_finalize().

Here is the caller graph for this function:

Data Types

Functions/Subroutines

Detailed Description

Function/Subroutine Documentation

◆ file_cartesc_setup()

◆ file_cartesc_finalize()

◆ file_cartesc_get_size_id()

◆ file_cartesc_set_coordinates_atmos()

◆ file_cartesc_set_areavol_atmos()

◆ file_cartesc_set_coordinates_ocean()

◆ file_cartesc_set_coordinates_land()

◆ file_cartesc_set_coordinates_urban()

◆ file_cartesc_open()

◆ file_cartesc_create()

◆ file_cartesc_enddef()

◆ file_cartesc_flush()

◆ file_cartesc_close()

◆ file_cartesc_read_1d()

◆ file_cartesc_read_var_2d()

◆ file_cartesc_read_var_3d()

◆ file_cartesc_read_var_4d()

◆ file_cartesc_read_auto_2d()

◆ file_cartesc_read_auto_3d()

◆ file_cartesc_write_1d()

◆ file_cartesc_put_globalattributes()

◆ file_cartesc_def_axes()

◆ file_cartesc_write_axes()

◆ file_cartesc_def_var()

◆ file_cartesc_write_var_1d()

◆ file_cartesc_write_var_2d()

◆ file_cartesc_write_var_3d()

◆ file_cartesc_write_var_3d_t()

◆ file_cartesc_write_var_4d()

◆ set_dimension_informations()

◆ set_dimension()

◆ construct_derived_datatype()

◆ free_derived_datatype()