Component to set up the model based upon a KiD model configuration. More...

Functions/Subroutines
type(component_descriptor_type) function, public	kidreader_get_descriptor ()
	Provides the descriptor back to the caller and is used in component registration. More...

subroutine	initialise_callback (current_state)
	Initialisation hook which will parse the configuration NetCDF file and set up the model based upon this. More...

subroutine	set_up_q_fields (current_state)

subroutine	populate_q_tracer (current_state, q_field)
	Populates the Q tracer field based upon the configuration that has been read in from the simulation file. More...

subroutine	initialise_single_q_field (current_state, q_id, z_size, y_size, x_size)

subroutine	decompose_grid (current_state)
	Calls the decomposition procedure to decompose the grid and determine neighbouring processes If no decomposition procedure is specified then this results in an error. More...

subroutine	initalise_source_and_z_fields (current_state)
	Based upon the local grid this will initialise the Source, Z and SAV fields for each prognostic. More...

subroutine	initialise_velocity_field (local_grid, field, z_grid, y_grid, x_grid, data)
	Will initialise a velocity field with the loaded data. More...

subroutine	create_grid (specific_grid, z, x, z_dim, x_dim, my_rank)
	Creates a specific grid based upon the data read from the KiD model NetCDF file. More...

subroutine	define_vertical_levels (current_state, z, z_size)
	Defines the vertical levels of the grid. This is both the grid points and corresponding height for each point in metres. More...

subroutine	check_kinematics_file (ncid)
	Checks that the kinematics file that has been loaded is consistent with what we expect. More...

subroutine	read_variables (ncid, time_dim, z_dim, z_half_dim, x_dim, x_half_dim, time, x, z, x_half, z_half, u, w, v)
	Reads the variables from the NetCDF KiD model file. More...

subroutine	read_single_variable (ncid, key, data1d, data3d)
	Reads a single variable out of a NetCDF file. More...

subroutine	read_dimensions (ncid, time_dim, z_dim, z_half_dim, x_dim, x_half_dim)
	Reads the dimensions from the NetCDF file. More...

subroutine	read_global_attributes (ncid, pid)
	Will read the global attributes of the NetCDF KiD model dump and log_log them to debug. More...

character(len=:) function, allocatable, target	read_specific_global_attribute (ncid, key)
	Will read a specific global NetCDF attribute. More...

subroutine	check_status (status)
	Will check a NetCDF status and write to log_log error any decoded statuses. More...

Variables
integer, parameter	number_q_coords = 100
	Number of Q field value coords that can be specified. More...

character(len= *), parameter	time_key = "time"
	Corresponding NetCDF data time key. More...

character(len= *), parameter	z_key = "z"
	Corresponding NetCDF data z (primal grid) key. More...

character(len= *), parameter	z_half_key = "z_half"
	Corresponding NetCDF data z half (dual grid) key. More...

character(len= *), parameter	x_key = "x"
	Corresponding NetCDF data x (primal grid) key. More...

character(len= *), parameter	x_half_key = "x_half"
	Corresponding NetCDF data x half (primal grid) key. More...

character(len= *), parameter	u_key ="u"
	Corresponding NetCDF data u flow field key. More...

character(len= *), parameter	w_key ="w"
	Corresponding NetCDF data w flow field key. More...

logical	flood_q = .false.

logical	float_q = .false.

logical	clone_to_3d = .false.

logical	rotate_xy =.false.

integer	domain_multiplication =1
	The Q field coordinates configured by the user. More...

integer, dimension(number_q_coords), save	q_coordinates_x

integer, dimension(number_q_coords), save	q_coordinates_y

integer, dimension(number_q_coords), save	q_coordinates_z

integer, dimension(number_q_coords), save	q_coordinates_value

character(len=string_length)	configuration_file
	NetCDF model file to load. More...

Detailed Description

Component to set up the model based upon a KiD model configuration.

These data files are in NetCDF format

Function/Subroutine Documentation

◆ check_kinematics_file()

subroutine kidreader_mod::check_kinematics_file ( integer, intent(in) ncid )

private

Checks that the kinematics file that has been loaded is consistent with what we expect.

This checks the file against a number of limitations of the current KiD reading functionality to ensure that this component can parse it correctly

Definition at line 379 of file kidreader.F90.

     integer, intent(in) :: ncid
 
     integer :: ndims_in, nvars_in, ngatts_in, unlimdimid_in
 
     call check_status(nf90_inquire(ncid, ndims_in, nvars_in, ngatts_in, unlimdimid_in))
     if (ndims_in /= 5) call log_log(log_error, "NetCDF KiD number of model dimensions must equal 5")
     if (nvars_in /= 7) call log_log(log_error, "NetCDF KiD number of model variables must equal 5")
     if (ngatts_in .le. 0) call log_log(log_error, "NetCDF KiD global attributes must be specified")
     if (unlimdimid_in .gt. 0) call log_log(log_error, "NetCDF KiD model number of unlimited dimensions must be 0")

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_status()

subroutine kidreader_mod::check_status ( integer, intent(in) status )

private

Will check a NetCDF status and write to log_log error any decoded statuses.

Parameters

status The NetCDF status flag

Definition at line 536 of file kidreader.F90.

     integer, intent(in) :: status
 
     if (status /= nf90_noerr) then
       call log_log(log_error, "NetCDF returned error code of "//trim(nf90_strerror(status)))
     end if

Here is the caller graph for this function:

◆ create_grid()

subroutine kidreader_mod::create_grid	(	type(global_grid_type), intent(inout)	specific_grid,
		real, dimension(:), intent(in)	z,
		real, dimension(:), intent(in)	x,
		integer, intent(in)	z_dim,
		integer, intent(in)	x_dim,
		integer, intent(in)	my_rank
	)

private

Creates a specific grid based upon the data read from the KiD model NetCDF file.

Parameters

specific_grid	The grid to create
z	Array of grid points in the z dimension
x	Array of grid points in the x dimension
z_dim	The number of points in the z dimension
x_dim	The number of points in the x dimension

Definition at line 305 of file kidreader.F90.

     type(global_grid_type), intent(inout) :: specific_grid
     integer, intent(in) :: z_dim, x_dim, my_rank
     real, dimension(:), intent(in) :: z, x
 
     specific_grid%bottom(z_index) = int(z(1))
     specific_grid%bottom(merge(y_index, x_index, rotate_xy)) = int(x(1))
     if (clone_to_3d) specific_grid%bottom(y_index) = int(x(1))
 
     specific_grid%top(z_index) = int(z(z_dim))
     specific_grid%top(merge(y_index, x_index, rotate_xy)) = int(x(x_dim)) * domain_multiplication
     if (clone_to_3d) specific_grid%top(y_index) = int(x(x_dim)) * domain_multiplication
 
     specific_grid%resolution(z_index) = int(z(2) - z(1))
     specific_grid%resolution(merge(y_index, x_index, rotate_xy)) = int(x(2) - x(1))
     if (clone_to_3d) specific_grid%resolution(y_index) = specific_grid%resolution(x_index)
 
     specific_grid%size(z_index) = z_dim
     specific_grid%size(merge(y_index, x_index, rotate_xy)) = x_dim * domain_multiplication
     if (clone_to_3d) specific_grid%size(y_index) = x_dim * domain_multiplication
 
     specific_grid%active(z_index) = .true.
     specific_grid%active(merge(y_index, x_index, rotate_xy)) = .true.
     if (clone_to_3d) specific_grid%active(y_index) = .true.
 
 #ifdef U_ACTIVE
     if (.not. specific_grid%active(x_index)) call log_master_log(log_error, &
          "Model compiled with X active but inactive in configuration")
 #else
     if (specific_grid%active(x_index)) call log_master_log(log_error, &
          "Model compiled with X inactive but active in configuration")
 #endif
 #ifdef V_ACTIVE
     if (.not. specific_grid%active(y_index)) call log_master_log(log_error, &
          "Model compiled with Y active but inactive in configuration")
 #else
     if (specific_grid%active(y_index)) call log_master_log(log_error, &
          "Model compiled with Y inactive but active in configuration")
 #endif
 #ifdef W_ACTIVE
     if (.not. specific_grid%active(z_index)) call log_master_log(log_error, &
          "Model compiled with Z active but inactive in configuration")
 #else
     if (specific_grid%active(z_index)) call log_master_log(log_error, &
          "Model compiled with Z inactive but active in configuration")
 #endif
     specific_grid%dimensions = merge(3, 2, clone_to_3d)

Here is the caller graph for this function:

◆ decompose_grid()

subroutine kidreader_mod::decompose_grid ( type(model_state_type), intent(inout) current_state )

private

Calls the decomposition procedure to decompose the grid and determine neighbouring processes If no decomposition procedure is specified then this results in an error.

Parameters

current_state The current model state_mod

Definition at line 192 of file kidreader.F90.

     type(model_state_type), intent(inout) :: current_state
 
     if (associated(current_state%parallel%decomposition_procedure)) then
       call current_state%parallel%decomposition_procedure(current_state)
     else
       call log_master_log(log_error, "No decomposition specified")
     end if

Here is the caller graph for this function:

◆ define_vertical_levels()

subroutine kidreader_mod::define_vertical_levels	(	type(model_state_type), intent(inout)	current_state,
		real, dimension(:), intent(in)	z,
		integer, intent(in)	z_size
	)

private

Defines the vertical levels of the grid. This is both the grid points and corresponding height for each point in metres.

Parameters

current_state	The current model state_mod
z	Array of grid heights in metres
z_size	Number of grid points

Definition at line 359 of file kidreader.F90.

     type(model_state_type), intent(inout) :: current_state
     integer, intent(in) :: z_size
     real, dimension(:), intent(in) :: z
 
     integer :: i
 
     allocate(current_state%global_grid%configuration%vertical%kgd(z_size), &
          current_state%global_grid%configuration%vertical%hgd(z_size))
 
     do i=1,z_size
       current_state%global_grid%configuration%vertical%kgd(i) = i
       current_state%global_grid%configuration%vertical%hgd(i) = real(z(i))
     end do

Here is the caller graph for this function:

◆ initalise_source_and_z_fields()

subroutine kidreader_mod::initalise_source_and_z_fields ( type(model_state_type), intent(inout) current_state )

private

Based upon the local grid this will initialise the Source, Z and SAV fields for each prognostic.

Parameters

current_state

Definition at line 204 of file kidreader.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: x_size, y_size, z_size
 
     z_size = current_state%local_grid%size(z_index) + current_state%local_grid%halo_size(z_index) * 2
     y_size = current_state%local_grid%size(y_index) + current_state%local_grid%halo_size(y_index) * 2
     x_size = current_state%local_grid%size(x_index) + current_state%local_grid%halo_size(x_index) * 2
 
 #ifdef U_ACTIVE
     allocate(current_state%zu%data(z_size, y_size, x_size))
     allocate(current_state%su%data(z_size, y_size, x_size))
     allocate(current_state%savu%data(z_size, y_size, x_size))
     current_state%zu%data(:,:,:)= 0.0
 #endif
 #ifdef V_ACTIVE
     allocate(current_state%zv%data(z_size, y_size, x_size))
     allocate(current_state%sv%data(z_size, y_size, x_size))
     allocate(current_state%savv%data(z_size, y_size, x_size))
     current_state%zv%data(:,:,:)= 0.0
 #endif
 #ifdef W_ACTIVE
     allocate(current_state%zw%data(z_size, y_size, x_size))
     allocate(current_state%sw%data(z_size, y_size, x_size))
     allocate(current_state%savw%data(z_size, y_size, x_size))
     current_state%zw%data(:,:,:)= 0.0
 #endif
     if (current_state%th%active) then
       allocate(current_state%zth%data(z_size, y_size, x_size))
       allocate(current_state%sth%data(z_size, y_size, x_size))
       current_state%zth%data(:,:,:)= 0.0
     end if

Here is the caller graph for this function:

◆ initialise_callback()

subroutine kidreader_mod::initialise_callback ( type(model_state_type), intent(inout), target current_state )

private

Initialisation hook which will parse the configuration NetCDF file and set up the model based upon this.

Parameters

current_state The current model state_mod

Definition at line 55 of file kidreader.F90.

     type(model_state_type), target, intent(inout) :: current_state
 
     integer :: ncid, time_dim, z_dim, z_half_dim, x_dim, x_half_dim
     real, dimension(:), allocatable :: time, x, z, x_half, z_half
     real, dimension(:,:,:), allocatable :: u, w, v
 
     if (options_has_key(current_state%options_database, "restart")) then
       call log_master_log(log_debug, "Ignoring KiD reader as restart from checkpoint file selected")
       return
     end if
 
     configuration_file=options_get_string(current_state%options_database, "kid_configuration_file")
     current_state%rhobous=options_get_real(current_state%options_database, "rhobous")
     current_state%thref0=options_get_real(current_state%options_database, "thref0")
     current_state%surface_pressure=options_get_real(current_state%options_database, "surface_pressure")
     flood_q=options_get_logical(current_state%options_database, "flood_q")
     float_q=options_get_logical(current_state%options_database, "float_q")
     clone_to_3d=options_get_logical(current_state%options_database, "clone_to_3d")
     rotate_xy=options_get_logical(current_state%options_database, "rotate_xy")
     domain_multiplication=options_get_integer(current_state%options_database, "domain_multiplication")
 
     call options_get_integer_array(current_state%options_database, "q_coordinates_x", q_coordinates_x)
     call options_get_integer_array(current_state%options_database, "q_coordinates_y", q_coordinates_y)
     call options_get_integer_array(current_state%options_database, "q_coordinates_z", q_coordinates_z)
     call options_get_integer_array(current_state%options_database, "q_coordinates_value", q_coordinates_value)
 
     call check_status(nf90_open(path = trim(configuration_file), mode = nf90_nowrite, ncid = ncid))
     call check_kinematics_file(ncid)
     if (log_get_logging_level() .ge. log_debug) call read_global_attributes(ncid, current_state%parallel%my_rank)
     call read_dimensions(ncid, time_dim, z_dim, z_half_dim, x_dim, x_half_dim)
     call read_variables(ncid, time_dim, z_dim, z_half_dim, x_dim, x_half_dim, time, x, z, x_half, z_half, u, w, v)
     call check_status(nf90_close(ncid))
 
     call create_grid(current_state%global_grid, z_half, x_half, z_half_dim, x_half_dim, current_state%parallel%my_rank)
     call define_vertical_levels(current_state, z_half, z_half_dim)
 
     call decompose_grid(current_state)
 
     if (rotate_xy) then
       call initialise_velocity_field(current_state%local_grid, current_state%v, dual_grid, primal_grid, dual_grid, v)
     else
       call initialise_velocity_field(current_state%local_grid, current_state%u, dual_grid, dual_grid, primal_grid, u)
     end if
     call initialise_velocity_field(current_state%local_grid, current_state%w, primal_grid, dual_grid, dual_grid, w)
     if (clone_to_3d) call initialise_velocity_field(current_state%local_grid, current_state%v, dual_grid, primal_grid, dual_grid, v)
     call initalise_source_and_z_fields(current_state)
     call set_up_q_fields(current_state)
     current_state%initialised=.true.
     call log_master_log(log_info, "Initialised configuration from KiD model file `"//trim(configuration_file)//"`")

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialise_single_q_field()

subroutine kidreader_mod::initialise_single_q_field	(	type(model_state_type), intent(inout)	current_state,
		integer, intent(in)	q_id,
		integer, intent(in)	z_size,
		integer, intent(in)	y_size,
		integer, intent(in)	x_size
	)

private

Definition at line 175 of file kidreader.F90.

     type(model_state_type), intent(inout) :: current_state
     integer, intent(in) :: q_id, x_size, y_size, z_size
 
     allocate(current_state%q(q_id)%data(z_size, y_size, x_size), current_state%zq(q_id)%data(z_size, y_size, x_size), &
          current_state%sq(q_id)%data(z_size, y_size, x_size))
     current_state%q(q_id)%data(:,:,:) = 0.
     current_state%zq(q_id)%data(:,:,:) = 0.
     current_state%sq(q_id)%data(:,:,:) = 0.
     current_state%q(q_id)%active=.true.
     current_state%zq(q_id)%active=.true.
     current_state%sq(q_id)%active=.true.

Here is the caller graph for this function:

◆ initialise_velocity_field()

subroutine kidreader_mod::initialise_velocity_field	(	type(local_grid_type), intent(inout)	local_grid,
		type(prognostic_field_type), intent(inout)	field,
		integer, intent(in)	z_grid,
		integer, intent(in)	y_grid,
		integer, intent(in)	x_grid,
		real, dimension(:,:,:), intent(in), allocatable	data
	)

private

Will initialise a velocity field with the loaded data.

Parameters

field	The velocity field to initialise
z_dim	The size of the z dimension
y_dim	The size of the y dimension
x_dim	The size of the x dimension
grid	The applicable grid to place this field upon
data	The NetCDF KiD model data to load into the velocity field

Definition at line 245 of file kidreader.F90.

     type(local_grid_type), intent(inout) :: local_grid
     type(prognostic_field_type), intent(inout) :: field
     integer, intent(in) :: z_grid, y_grid, x_grid
     real, dimension(:,:,:), allocatable, intent(in) :: data
 
     integer :: i, j, k, premulsizey, premulsizex
 
     field%grid(z_index) = z_grid
     field%grid(y_index) = y_grid
     field%grid(x_index) = x_grid
     field%active = .true.
 
     allocate(field%data(local_grid%size(z_index) + local_grid%halo_size(z_index) * 2, local_grid%size(y_index) + &
          local_grid%halo_size(y_index) * 2, local_grid%size(x_index) + local_grid%halo_size(x_index) * 2))
     field%data=0.0
 
     ! Divisions here are for the multiplication - we just fill up the original size and then duplicate this across dimensions
     do i=ceiling(local_grid%start(x_index)/real(domain_multiplication)),&
          ceiling(local_grid%end(x_index)/real(domain_multiplication))
       do j=ceiling(local_grid%start(y_index)/real(domain_multiplication)),&
            ceiling(local_grid%end(y_index)/real(domain_multiplication))
         do k=local_grid%start(z_index),local_grid%end(z_index)          
           field%data(local_grid%halo_size(z_index)+(k-((local_grid%start(z_index)-1))), local_grid%halo_size(y_index)+&
                (j-((ceiling(local_grid%start(y_index)/ real(domain_multiplication))-1))), local_grid%halo_size(x_index)+&
                (i- ((ceiling(local_grid%start(x_index)/real(domain_multiplication))-1)))) = &
                real(data(1, k, merge(j, i, rotate_xy)), kind=default_precision)
         end do
       end do
     end do
 
     if (domain_multiplication .ge. 2) then
       ! If there is a domain multiplication then duplicate data across dimensions
       premulsizey = ceiling(local_grid%size(y_index) / real(domain_multiplication))
       premulsizex = ceiling(local_grid%size(x_index) / real(domain_multiplication))
       if (local_grid%active(y_index)) then
         do i=1,domain_multiplication-1
           field%data(:, local_grid%halo_size(y_index) + i*premulsizey +1 : local_grid%halo_size(y_index) + (i+1)*premulsizey, &
                local_grid%halo_size(x_index)+1: local_grid%halo_size(x_index)+premulsizex) = &
                field%data(:, local_grid%halo_size(y_index)+1 : local_grid%halo_size(y_index) + premulsizey, &
                local_grid%halo_size(x_index)+1 : local_grid%halo_size(x_index)+premulsizex)
         end do
       end if
       if (local_grid%active(x_index)) then
         do i=1,domain_multiplication-1
           field%data(:, local_grid%local_domain_start_index(y_index) : local_grid%local_domain_end_index(y_index), &
                local_grid%halo_size(x_index) + i*premulsizex + 1 : local_grid%halo_size(x_index) + (i+1)*premulsizex) = &
                field%data(:, local_grid%local_domain_start_index(y_index) : local_grid%local_domain_end_index(y_index), &
                local_grid%halo_size(x_index)+1 : local_grid%halo_size(x_index)+premulsizex)
         end do
       end if
     end if

Here is the caller graph for this function:

◆ kidreader_get_descriptor()

type(component_descriptor_type) function, public kidreader_mod::kidreader_get_descriptor ( )

Provides the descriptor back to the caller and is used in component registration.

Returns: The KidReader component descriptor

Definition at line 46 of file kidreader.F90.

     kidreader_get_descriptor%name="kidreader"
     kidreader_get_descriptor%version=0.1
     kidreader_get_descriptor%initialisation=>initialise_callback

Here is the call graph for this function:

◆ populate_q_tracer()

subroutine kidreader_mod::populate_q_tracer	(	type(model_state_type), intent(inout)	current_state,
		type(prognostic_field_type), intent(inout)	q_field
	)

private

Populates the Q tracer field based upon the configuration that has been read in from the simulation file.

Parameters

current_state	The current model state_mod
q_field	The qfield that we are going to fill in

Definition at line 132 of file kidreader.F90.

     type(model_state_type), intent(inout) :: current_state
     type(prognostic_field_type), intent(inout) :: q_field
 
     integer :: i, x_local, y_local
 
     do i=1,number_q_coords
       if (q_coordinates_x(i) .ne. -1 .and. q_coordinates_y(i) .ne. -1) then
         if (q_coordinates_x(i) .ne. 0 .and. .not. (q_coordinates_x(i) .ge. current_state%local_grid%start(x_index) .and. &
              q_coordinates_x(i) .le. current_state%local_grid%end(x_index))) cycle
         if (q_coordinates_y(i) .ne. 0 .and. .not. (q_coordinates_y(i) .ge. current_state%local_grid%start(y_index) .and. &
              q_coordinates_y(i) .le. current_state%local_grid%end(y_index))) cycle
         x_local=(q_coordinates_x(i) - (current_state%local_grid%start(x_index)-1)) + current_state%local_grid%halo_size(x_index)
         y_local=(q_coordinates_y(i) - (current_state%local_grid%start(y_index)-1)) + current_state%local_grid%halo_size(y_index)
         if (q_coordinates_z(i) == 0 .and. q_coordinates_y(i) == 0 .and. q_coordinates_x(i) == 0) then
           q_field%data(:,current_state%local_grid%local_domain_start_index(y_index):&
                current_state%local_grid%local_domain_end_index(y_index),current_state%local_grid%local_domain_start_index(x_index):&
                current_state%local_grid%local_domain_end_index(x_index)) = q_coordinates_value(i)
         else if (q_coordinates_z(i) == 0 .and. q_coordinates_y(i) == 0 .and. q_coordinates_x(i) .ne. 0) then
           q_field%data(:,current_state%local_grid%local_domain_start_index(y_index):&
                current_state%local_grid%local_domain_end_index(y_index),x_local) = q_coordinates_value(i)
         else if (q_coordinates_z(i) == 0 .and. q_coordinates_y(i) .ne. 0 .and. q_coordinates_x(i) == 0) then
           q_field%data(:,y_local,current_state%local_grid%local_domain_start_index(x_index):&
                current_state%local_grid%local_domain_end_index(x_index)) = q_coordinates_value(i)
         else if (q_coordinates_z(i) == 0 .and. q_coordinates_y(i) .ne. 0 .and. q_coordinates_x(i) .ne. 0) then
           q_field%data(:,y_local,x_local) = q_coordinates_value(i)
         else if (q_coordinates_z(i) .ne. 0 .and. q_coordinates_y(i) == 0 .and. q_coordinates_x(i) == 0) then
           q_field%data(q_coordinates_z(i),current_state%local_grid%local_domain_start_index(y_index):&
                current_state%local_grid%local_domain_end_index(y_index),current_state%local_grid%local_domain_start_index(x_index):&
                current_state%local_grid%local_domain_end_index(x_index)) = q_coordinates_value(i)
         else if (q_coordinates_z(i) .ne. 0 .and. q_coordinates_y(i) == 0 .and. q_coordinates_x(i) .ne. 0) then
           q_field%data(q_coordinates_z(i),current_state%local_grid%local_domain_start_index(y_index):&
                current_state%local_grid%local_domain_end_index(y_index),x_local) = q_coordinates_value(i)
         else if (q_coordinates_z(i) .ne. 0 .and. q_coordinates_y(i) .ne. 0 .and. q_coordinates_x(i) == 0) then
           q_field%data(q_coordinates_z(i),y_local,current_state%local_grid%local_domain_start_index(x_index):&
                current_state%local_grid%local_domain_end_index(x_index)) = q_coordinates_value(i)
         else if (q_coordinates_z(i) .ne. 0 .and. q_coordinates_y(i) .ne. 0 .and. q_coordinates_x(i) .ne. 0) then
           q_field%data(q_coordinates_z(i),y_local,x_local) = q_coordinates_value(i)
         end if
       end if
     end do

Here is the caller graph for this function:

◆ read_dimensions()

subroutine kidreader_mod::read_dimensions	(	integer, intent(in)	ncid,
		integer, intent(out)	time_dim,
		integer, intent(out)	z_dim,
		integer, intent(out)	z_half_dim,
		integer, intent(out)	x_dim,
		integer, intent(out)	x_half_dim
	)

private

Reads the dimensions from the NetCDF file.

Parameters

ncid	The NetCDF file id
time_dim	Number of elements in the time dimension
z_dim	Number of elements in the z dimension of the primal grid
z_half_dim	Number of elements in the z dimension of the dual grid
x_dim	Number of elements in the x dimension of the primal grid
x_half_dim	Number of elements in the x dimension of the dual grid

Definition at line 483 of file kidreader.F90.

     integer, intent(in) :: ncid
     integer, intent(out) ::  time_dim, z_dim, z_half_dim, x_dim, x_half_dim
 
     integer ::  time_dimid, z_dimid, z_half_dimid, x_dimid, x_half_dimid
 
     call check_status(nf90_inq_dimid(ncid, time_key, time_dimid))
     call check_status(nf90_inq_dimid(ncid, z_key, z_dimid))
     call check_status(nf90_inq_dimid(ncid, z_half_key, z_half_dimid))
     call check_status(nf90_inq_dimid(ncid, x_key, x_dimid))
     call check_status(nf90_inq_dimid(ncid, x_half_key, x_half_dimid))
 
     call check_status(nf90_inquire_dimension(ncid, time_dimid, len=time_dim))
     call check_status(nf90_inquire_dimension(ncid, z_dimid, len=z_dim))
     call check_status(nf90_inquire_dimension(ncid, z_half_dimid, len=z_half_dim))
     call check_status(nf90_inquire_dimension(ncid, x_dimid, len=x_dim))
     call check_status(nf90_inquire_dimension(ncid, x_half_dimid, len=x_half_dim))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_global_attributes()

subroutine kidreader_mod::read_global_attributes	(	integer, intent(in)	ncid,
		integer, intent(in)	pid
	)

private

Will read the global attributes of the NetCDF KiD model dump and log_log them to debug.

Parameters

ncid	The NetCDF file id

Definition at line 504 of file kidreader.F90.

     integer, intent(in) :: ncid, pid
 
     character(len=:), allocatable :: attributevalue
 
     attributevalue=read_specific_global_attribute(ncid, "title")
     call log_master_log(log_debug, "KiD file title: "//attributevalue)
     deallocate(attributevalue)
 
     attributevalue=read_specific_global_attribute(ncid, "creation date")
     call log_master_log(log_debug, "KiD file created: "//attributevalue)
     deallocate(attributevalue)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_single_variable()

subroutine kidreader_mod::read_single_variable	(	integer, intent(in)	ncid,
		character(len=*), intent(in)	key,
		real, dimension(:), intent(inout), optional	data1d,
		real, dimension(:,:,:), intent(inout), optional	data3d
	)

private

Reads a single variable out of a NetCDF file.

Parameters

ncid	The NetCDF file id
key	The variable key (name) to access
data1d	Optional one dimensional data to read into
data3d	Optional three dimensional data to read into

Definition at line 452 of file kidreader.F90.

     integer, intent(in) :: ncid
     character(len=*), intent(in) :: key
     real, dimension(:), intent(inout), optional :: data1d
     real, dimension(:,:,:), intent(inout), optional :: data3d
 
     integer :: variable_id
     real, dimension(:,:,:), allocatable :: sdata
 
     call check_status(nf90_inq_varid(ncid, key, variable_id))
 
     if (.not. present(data1d) .and. .not. present(data3d)) return
 
     if (present(data1d)) then
       call check_status(nf90_get_var(ncid, variable_id, data1d))
     else
       ! 3D will reshape the data to take account of the column-row major C-F transposition
       allocate(sdata(size(data3d,1),size(data3d,3), size(data3d,2)))
       call check_status(nf90_get_var(ncid, variable_id, sdata))
       data3d(:,:,:)=reshape(sdata(:,:,:),(/size(data3d,1),size(data3d,2),size(data3d,3)/))
       deallocate(sdata)
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_specific_global_attribute()

character(len=:) function, allocatable, target kidreader_mod::read_specific_global_attribute	(	integer, intent(in)	ncid,
		character(len=*), intent(in)	key
	)

private

Will read a specific global NetCDF attribute.

Parameters

ncid	The NetCDF file id
key	The name (key) of the attribute to read

Returns: String representation of the attribute value

Definition at line 522 of file kidreader.F90.

     integer, intent(in) :: ncid
     character(len=*), intent(in) :: key
 
     integer :: length
     character(len=:),allocatable,target :: read_specific_global_attribute
 
     call check_status(nf90_inquire_attribute(ncid, nf90_global, key, len = length))
     allocate(character(length) :: read_specific_global_attribute)
     call check_status(nf90_get_att(ncid, nf90_global, key, read_specific_global_attribute))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_variables()

subroutine kidreader_mod::read_variables	(	integer, intent(in)	ncid,
		integer, intent(in)	time_dim,
		integer, intent(in)	z_dim,
		integer, intent(in)	z_half_dim,
		integer, intent(in)	x_dim,
		integer, intent(in)	x_half_dim,
		real, dimension(:), intent(inout), allocatable	time,
		real, dimension(:), intent(inout), allocatable	x,
		real, dimension(:), intent(inout), allocatable	z,
		real, dimension(:), intent(inout), allocatable	x_half,
		real, dimension(:), intent(inout), allocatable	z_half,
		real, dimension(:,:,:), intent(inout), allocatable	u,
		real, dimension(:,:,:), intent(inout), allocatable	w,
		real, dimension(:,:,:), intent(inout), allocatable	v
	)

private

Reads the variables from the NetCDF KiD model file.

Parameters

ncid	The id of the NetCDF file
time_dim	The number of elements in the time dimension
z_dim	The number of elements in the z primal grid dimension
z_half_dim	The number of elements in the z dual grid dimension
x_dim	The number of elements in the x primal grid dimension
x_half_dim	The number of elements in the x dual grid dimension
time	The time data field that is to be read
x	The points on the primal grid in x dimension
z	The points on the primal grid z dimension
x_half	The points on the dual grid x dimension
z_half	The points on the dual grid z dimension
u	Velocity field in dimension x to read
w	Velocity field in dimension z to read

Definition at line 405 of file kidreader.F90.

     integer, intent(in) :: ncid, time_dim, z_dim, z_half_dim, x_dim, x_half_dim
     real, dimension(:), allocatable, intent(inout) :: time, x, z, x_half, z_half
     real, dimension(:,:,:), allocatable, intent(inout) :: u, w, v
 
     allocate(time(time_dim))
     allocate(z(z_dim))
     allocate(x(x_dim))
     allocate(z_half(z_half_dim))
     allocate(x_half(x_half_dim))
     ! Due to NetCDF being in C, need to reverse the data order for F2003
     if (rotate_xy) then
       allocate(v(time_dim, z_dim, x_half_dim))
     else
       allocate(u(time_dim, z_dim, x_half_dim))
     end if
     allocate(w(time_dim, z_half_dim, x_half_dim))
 
     call read_single_variable(ncid, time_key, data1d=time)
     call read_single_variable(ncid, z_key, data1d=z)
     call read_single_variable(ncid, z_half_key, data1d=z_half)
     call read_single_variable(ncid, x_key, data1d=x)
     call read_single_variable(ncid, x_half_key, data1d=x_half)
     if (rotate_xy) then
       call read_single_variable(ncid, u_key, data3d=v)
     else
       call read_single_variable(ncid, u_key, data3d=u)
     end if
     call read_single_variable(ncid, w_key, data3d=w)
 
     if (clone_to_3d) then
       if (.not. allocated(v)) then
         allocate(v(time_dim, z_dim, x_half_dim))
         v=u
       end if
       if (.not. allocated(u)) then
         allocate(u(time_dim, z_dim, x_half_dim))
         u=v
       end if
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_up_q_fields()

subroutine kidreader_mod::set_up_q_fields ( type(model_state_type), intent(inout) current_state )

private

Definition at line 107 of file kidreader.F90.

     type(model_state_type), intent(inout) :: current_state
 
     integer :: x_size, y_size, z_size, i
 
     z_size = current_state%local_grid%size(z_index) + current_state%local_grid%halo_size(z_index) * 2
     y_size = current_state%local_grid%size(y_index) + current_state%local_grid%halo_size(y_index) * 2
     x_size = current_state%local_grid%size(x_index) + current_state%local_grid%halo_size(x_index) * 2
 
     if (flood_q) current_state%number_q_fields=current_state%number_q_fields+1
     if (float_q) current_state%number_q_fields=current_state%number_q_fields+1
     allocate(current_state%q(current_state%number_q_fields), current_state%zq(current_state%number_q_fields), &
          current_state%sq(current_state%number_q_fields))
     do i=1,current_state%number_q_fields
       call initialise_single_q_field(current_state, i, z_size, y_size, x_size)
       if (flood_q .and. i == 1) current_state%q(i)%data(:,:,:) = 1.
       if (float_q .and. (.not. flood_q .or. i==2)) then
         call populate_q_tracer(current_state, current_state%q(i))
       end if
     end do

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ clone_to_3d

logical kidreader_mod::clone_to_3d = .false.

private

Definition at line 31 of file kidreader.F90.

◆ configuration_file

character(len=string_length) kidreader_mod::configuration_file

private

NetCDF model file to load.

Definition at line 37 of file kidreader.F90.

37 character(len=STRING_LENGTH) :: configuration_file

◆ domain_multiplication

integer kidreader_mod::domain_multiplication =1

private

The Q field coordinates configured by the user.

Definition at line 32 of file kidreader.F90.

32 integer :: domain_multiplication=1

◆ float_q

logical kidreader_mod::float_q = .false.

private

Definition at line 31 of file kidreader.F90.

◆ flood_q

logical kidreader_mod::flood_q = .false.

private

Definition at line 31 of file kidreader.F90.

31 logical :: flood_q = .false., float_q= .false., clone_to_3d = .false., rotate_xy=.false.

◆ number_q_coords

integer, parameter kidreader_mod::number_q_coords = 100

private

Number of Q field value coords that can be specified.

Definition at line 22 of file kidreader.F90.

22 integer, parameter :: number_q_coords = 100

◆ q_coordinates_value

integer, dimension(number_q_coords), save kidreader_mod::q_coordinates_value

private

Definition at line 35 of file kidreader.F90.

◆ q_coordinates_x

integer, dimension(number_q_coords), save kidreader_mod::q_coordinates_x

private

Definition at line 35 of file kidreader.F90.

35 integer, dimension(NUMBER_Q_COORDS), save :: q_coordinates_x, q_coordinates_y, q_coordinates_z, q_coordinates_value

◆ q_coordinates_y

integer, dimension(number_q_coords), save kidreader_mod::q_coordinates_y

private

Definition at line 35 of file kidreader.F90.

◆ q_coordinates_z

integer, dimension(number_q_coords), save kidreader_mod::q_coordinates_z

private

Definition at line 35 of file kidreader.F90.

◆ rotate_xy

logical kidreader_mod::rotate_xy =.false.

private

Definition at line 31 of file kidreader.F90.

◆ time_key

character(len=*), parameter kidreader_mod::time_key = "time"

private

Corresponding NetCDF data time key.

Definition at line 23 of file kidreader.F90.

   character(len=*), parameter ::  time_key = "time",&     !< Corresponding NetCDF data time key
        z_key = "z",&           
        z_half_key = "z_half",& 
        x_key = "x",&           
        x_half_key = "x_half",& 
        u_key="u",&             
        w_key="w"               

◆ u_key

character(len=*), parameter kidreader_mod::u_key ="u"

private

Corresponding NetCDF data u flow field key.

Definition at line 23 of file kidreader.F90.

◆ w_key

character(len=*), parameter kidreader_mod::w_key ="w"

private

Corresponding NetCDF data w flow field key.

Definition at line 23 of file kidreader.F90.

◆ x_half_key

character(len=*), parameter kidreader_mod::x_half_key = "x_half"

private

Corresponding NetCDF data x half (primal grid) key.

Definition at line 23 of file kidreader.F90.

◆ x_key

character(len=*), parameter kidreader_mod::x_key = "x"

private

Corresponding NetCDF data x (primal grid) key.

Definition at line 23 of file kidreader.F90.

◆ z_half_key

character(len=*), parameter kidreader_mod::z_half_key = "z_half"

private

Corresponding NetCDF data z half (dual grid) key.

Definition at line 23 of file kidreader.F90.

◆ z_key

character(len=*), parameter kidreader_mod::z_key = "z"

private

Corresponding NetCDF data z (primal grid) key.

Definition at line 23 of file kidreader.F90.

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ check_kinematics_file()

◆ check_status()

◆ create_grid()

◆ decompose_grid()

◆ define_vertical_levels()

◆ initalise_source_and_z_fields()

◆ initialise_callback()

◆ initialise_single_q_field()

◆ initialise_velocity_field()

◆ kidreader_get_descriptor()

◆ populate_q_tracer()

◆ read_dimensions()

◆ read_global_attributes()

◆ read_single_variable()

◆ read_specific_global_attribute()

◆ read_variables()

◆ set_up_q_fields()

Variable Documentation

◆ clone_to_3d

◆ configuration_file

◆ domain_multiplication

◆ float_q

◆ flood_q

◆ number_q_coords

◆ q_coordinates_value

◆ q_coordinates_x

◆ q_coordinates_y

◆ q_coordinates_z

◆ rotate_xy

◆ time_key

◆ u_key

◆ w_key

◆ x_half_key

◆ x_key

◆ z_half_key

◆ z_key