kidreader_mod Module Reference

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 378 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 535 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 304 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 191 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 358 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 203 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 54 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 174 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 244 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 45 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 131 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 482 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 503 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 451 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 521 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 404 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 106 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.

  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.

  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.

  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.

  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.

  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.