Contains functionality for managing and extracting data from the raw data dumps that the IO server receives from a MONC process during model dumping. More...

Functions/Subroutines
integer function, public	unpack_scalar_integer_from_bytedata (data, start_point)
	Unpacks a scalar integer from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point. More...

logical function, public	unpack_scalar_logical_from_bytedata (data, start_point)
	Unpacks a scalar logical from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point. More...

character(len=string_length) function, public	unpack_scalar_string_from_bytedata (data, start_point)
	Unpacks a string from some byte data with default length, this is a very simple unpack routine wrapping the transfer and updating the current point. More...

real function, public	unpack_scalar_real_from_bytedata (data, start_point)
	Unpacks a scalar real from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point. More...

real(kind=double_precision) function, public	unpack_scalar_dp_real_from_bytedata (data, start_point)
	Unpacks a double precision scalar real from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point. More...

character(len=string_length) function, public	get_action_attribute_string (action_attributes, field_name)
	Retrieves the name of a field from the attributes specified in the configuration. More...

integer function, public	get_action_attribute_integer (action_attributes, field_name)
	Retrieves the name of a field from the attributes specified in the configuration. More...

logical function, public	get_action_attribute_logical (action_attributes, field_name)
	Retrieves a logical value from the attribute which corresponds to a specific key. More...

logical function, public	is_field_present (io_configuration, source, data_id, key)

integer function, public	get_field_size (field_starts, field_ends, key, data_type)
	Retrieves the size of a field from the data definition. More...

type(map_type) function, public	get_map (field_starts, field_ends, data_dump, key)
	Retrieves a map data structure with key->value pairs, each of which are strings. More...

type(map_type) function, public	get_map_from_monc (io_configuration, source, data_id, data_dump, key)
	Retrieves a map data structure with key->value pairs, each of which are strings. More...

character(len=string_length) function, public	get_string (field_starts, field_ends, data_dump, key)
	Retrieves a string from the data dump. More...

character(len=string_length) function, public	get_string_from_monc (io_configuration, source, data_id, data_dump, key)
	Retrieves a string from the data dump. More...

logical function, public	get_scalar_logical (field_starts, field_ends, data_dump, key)
	Retrieves a single logical element (scalar) from the data dump. More...

logical function, public	get_scalar_logical_from_monc (io_configuration, source, data_id, data_dump, key)
	Retrieves a single logical element (scalar) from the data dump. More...

integer function, public	get_scalar_integer (field_starts, field_ends, data_dump, key)
	Retrieves a single integer element (scalar) from the data dump. More...

integer function, public	get_scalar_integer_from_monc (io_configuration, source, data_id, data_dump, key)
	Retrieves a single integer element (scalar) from the data dump. More...

real(kind=double_precision) function, public	get_scalar_real (field_starts, field_ends, data_dump, key)
	Retreives a scalar real with a corresponding key from the raw data dump. More...

real(kind=double_precision) function, public	get_scalar_real_from_monc (io_configuration, source, data_id, data_dump, key)
	Retreives a scalar real with a corresponding key from the raw data dump. More...

real(kind=double_precision) function, dimension(:), allocatable, public	get_array_double (field_starts, field_ends, data_dump, key)
	Retreives an array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

real(kind=double_precision) function, dimension(:), allocatable, public	get_array_double_from_monc (io_configuration, source, data_id, data_dump, key)
	Retreives an array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

integer function, dimension(:), allocatable, public	get_array_integer (field_starts, field_ends, data_dump, key)
	Retreives an array of integers with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

integer function, dimension(:), allocatable, public	get_array_integer_from_monc (io_configuration, source, data_id, data_dump, key)
	Retreives an array of integers with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

subroutine, public	get_2darray_double_from_monc (io_configuration, source, data_id, data_dump, key, target_data, size1, size2)
	Retreives a 2D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

subroutine, public	get_2darray_double (field_starts, field_ends, data_dump, key, target_data, size1, size2)
	Retreives a 2D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

subroutine, public	get_3darray_double (field_starts, field_ends, data_dump, key, target_data, size1, size2, size3)
	Retreives a 3D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

subroutine, public	get_3darray_double_from_monc (io_configuration, source, data_id, data_dump, key, target_data, size1, size2, size3)
	Retreives a 3D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

subroutine, public	get_4darray_double (field_starts, field_ends, data_dump, key, target_data, size1, size2, size3, size4)
	Retreives a 4D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

subroutine, public	get_4darray_double_from_monc (io_configuration, source, data_id, data_dump, key, target_data, size1, size2, size3, size4)
	Retreives a 4D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field. More...

Variables
integer, parameter	array_step_threshold =204800

Detailed Description

Contains functionality for managing and extracting data from the raw data dumps that the IO server receives from a MONC process during model dumping.

Function/Subroutine Documentation

◆ get_2darray_double()

subroutine, public data_utils_mod::get_2darray_double	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key,
		real(kind=double_precision), dimension(:,:), intent(inout), pointer, contiguous	target_data,
		integer, intent(in)	size1,
		integer, intent(in)	size2
	)

Retreives a 2D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Note that this replies in the F2008 contiguous keyword, but it is supported by the target compilers so we use it

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve
target_data	The data that we are writing into
size1	Size in first dimension
size2	Size in second dimension

Definition at line 584 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     integer, intent(in) ::  size1, size2
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:,:), pointer, contiguous, intent(inout) :: target_data
 
     integer :: start_index, end_index, element_size
     real(kind=DOUBLE_PRECISION), dimension(:), pointer :: temp_data
 
     ! Pointer bounds remapping as transfer needs 1D array but for performance don't want to allocate another array and copy using reshape
     temp_data(1:size1*size2)=>target_data
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     element_size=(end_index-start_index) / kind(target_data)
 
     temp_data=transfer(data_dump(start_index:end_index), temp_data)

Here is the caller graph for this function:

◆ get_2darray_double_from_monc()

subroutine, public data_utils_mod::get_2darray_double_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key,
		real(kind=double_precision), dimension(:,:), intent(inout), pointer, contiguous	target_data,
		integer, intent(in)	size1,
		integer, intent(in)	size2
	)

Retreives a 2D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Note that this replies in the F2008 contiguous keyword, but it is supported by the target compilers so we use it

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve
target_data	The data that we are writing into
size1	Size in first dimension
size2	Size in second dimension

Definition at line 557 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id, size1, size2
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:,:), pointer, contiguous, intent(inout) :: target_data
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     call get_2darray_double(io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key, target_data, &
          size1, size2)    

Here is the call graph for this function:

◆ get_3darray_double()

subroutine, public data_utils_mod::get_3darray_double	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key,
		real(kind=double_precision), dimension(:,:,:), intent(inout), pointer, contiguous	target_data,
		integer, intent(in)	size1,
		integer, intent(in)	size2,
		integer, intent(in)	size3
	)

Retreives a 3D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Note that this replies in the F2008 contiguous keyword, but it is supported by the target compilers so we use it

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve
target_data	The data that we are writing into
size1	Size in first dimension
size2	Size in second dimension
size3	Size in third dimension

Definition at line 620 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     integer, intent(in) ::  size1, size2, size3
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:,:,:), pointer, contiguous, intent(inout) :: target_data
     
     integer :: start_index, end_index, element_size
     real(kind=DOUBLE_PRECISION), dimension(:), pointer :: temp_data
 
     ! Pointer bounds remapping as transfer needs 1D array but for performance don't want to allocate another array and copy using reshape
     temp_data(1:size1*size2*size3)=>target_data
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     element_size=(end_index-start_index) / kind(target_data)
     
     temp_data=transfer(data_dump(start_index:end_index), temp_data)

Here is the caller graph for this function:

◆ get_3darray_double_from_monc()

subroutine, public data_utils_mod::get_3darray_double_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key,
		real(kind=double_precision), dimension(:,:,:), intent(inout), pointer, contiguous	target_data,
		integer, intent(in)	size1,
		integer, intent(in)	size2,
		integer, intent(in)	size3
	)

Retreives a 3D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Note that this replies in the F2008 contiguous keyword, but it is supported by the target compilers so we use it

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve
target_data	The data that we are writing into
size1	Size in first dimension
size2	Size in second dimension
size3	Size in third dimension

Definition at line 657 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id, size1, size2, size3
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:,:,:), pointer, contiguous, intent(inout) :: target_data
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     call get_3darray_double(io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key, target_data, &
          size1, size2, size3)    

Here is the call graph for this function:

◆ get_4darray_double()

subroutine, public data_utils_mod::get_4darray_double	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key,
		real(kind=double_precision), dimension(:,:,:,:), intent(inout), pointer, contiguous	target_data,
		integer, intent(in)	size1,
		integer, intent(in)	size2,
		integer, intent(in)	size3,
		integer, intent(in)	size4
	)

Retreives a 4D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Note that this replies in the F2008 contiguous keyword, but it is supported by the target compilers so we use it

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve
target_data	The data that we are writing into
size1	Size in first dimension
size2	Size in second dimension
size3	Size in third dimension
size4	Size in fourth dimension

Definition at line 686 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     integer, intent(in) :: size1, size2, size3, size4
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:,:,:,:), pointer, contiguous, intent(inout) :: target_data
 
     integer :: start_index, end_index, element_size
     real(kind=DOUBLE_PRECISION), dimension(:), pointer :: temp_data
     
     ! Pointer bounds remapping as transfer needs 1D array but for performance don't want to allocate another array and copy using reshape
     temp_data(1:size1*size2*size3*size4)=>target_data     
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     element_size=(end_index-start_index) / kind(target_data)
     
     temp_data=transfer(data_dump(start_index:end_index), temp_data)

Here is the caller graph for this function:

◆ get_4darray_double_from_monc()

subroutine, public data_utils_mod::get_4darray_double_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key,
		real(kind=double_precision), dimension(:,:,:,:), intent(inout), pointer, contiguous	target_data,
		integer, intent(in)	size1,
		integer, intent(in)	size2,
		integer, intent(in)	size3,
		integer, intent(in)	size4
	)

Retreives a 4D array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Note that this replies in the F2008 contiguous keyword, but it is supported by the target compilers so we use it

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve
target_data	The data that we are writing into
size1	Size in first dimension
size2	Size in second dimension
size3	Size in third dimension
size4	Size in fourth dimension

Definition at line 725 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id, size1, size2, size3, size4
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:,:,:,:), pointer, contiguous, intent(inout) :: target_data
 
     integer :: monc_location
     
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     call get_4darray_double(io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key, target_data, &
          size1, size2, size3, size4)    

Here is the call graph for this function:

◆ get_action_attribute_integer()

integer function, public data_utils_mod::get_action_attribute_integer	(	type(map_type), intent(inout)	action_attributes,
		character(len=*), intent(in)	field_name
	)

Retrieves the name of a field from the attributes specified in the configuration.

Parameters

action_attributes	Action attributes from the IO server configuration
Name	of the field to perform the collective operation over

Definition at line 114 of file datautils.F90.

     type(map_type), intent(inout) :: action_attributes
     character(len=*), intent(in) :: field_name
 
     character(len=STRING_LENGTH) :: str_val
 
     str_val=get_action_attribute_string(action_attributes, field_name)
     if (.not. conv_is_integer(str_val)) call log_log(log_error, "Can not convert string '"//trim(str_val)//"' to an integer")
     get_action_attribute_integer=conv_to_integer(str_val)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_action_attribute_logical()

logical function, public data_utils_mod::get_action_attribute_logical	(	type(map_type), intent(inout)	action_attributes,
		character(len=*), intent(in)	field_name
	)

Retrieves a logical value from the attribute which corresponds to a specific key.

Parameters

action_attributes	The attributes provided to the action
name	The name of the attribute to look up

Definition at line 128 of file datautils.F90.

     type(map_type), intent(inout) :: action_attributes
     character(len=*), intent(in) :: field_name
 
     if (c_contains(action_attributes, field_name)) then
       get_action_attribute_logical=trim(c_get_string(action_attributes, field_name)) .eq. "true"
     else
       get_action_attribute_logical=.false.
     end if

◆ get_action_attribute_string()

character(len=string_length) function, public data_utils_mod::get_action_attribute_string	(	type(map_type), intent(inout)	action_attributes,
		character(len=*), intent(in)	field_name
	)

Retrieves the name of a field from the attributes specified in the configuration.

Parameters

action_attributes	Action attributes from the IO server configuration
Name	of the field to perform the collective operation over

Definition at line 101 of file datautils.F90.

     type(map_type), intent(inout) :: action_attributes
     character(len=*), intent(in) :: field_name
 
     if (.not. c_contains(action_attributes, field_name)) call log_log(log_error, &
          "You must provide the field name in the collective operation configuration")
 
     get_action_attribute_string=c_get_string(action_attributes, field_name)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_array_double()

real(kind=double_precision) function, dimension(:), allocatable, public data_utils_mod::get_array_double	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retreives an array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Double array values of the corresponding field

Definition at line 438 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:), allocatable :: get_array_double
 
     integer :: start_index, end_index, elements, start_e, end_e, current_start_index, current_end_index
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     elements = ceiling((end_index - start_index) / real(kind(get_array_double)))
 
     allocate(get_array_double(elements))
     if (elements .ge. array_step_threshold) then 
        current_start_index=start_index
        do while (current_start_index .lt. end_index)
           current_end_index=current_start_index+array_step_threshold-1
           if (current_end_index .gt. end_index) current_end_index=end_index
           start_e=((current_start_index-start_index)/kind(get_array_double))+1
           end_e=ceiling((current_end_index-start_index)/real(kind(get_array_double)))
           get_array_double(start_e:end_e)=transfer(data_dump(current_start_index:current_end_index), get_array_double)
           current_start_index=current_start_index+array_step_threshold
        end do
     else
        get_array_double=transfer(data_dump(start_index:end_index), get_array_double, elements)
     end if

Here is the caller graph for this function:

◆ get_array_double_from_monc()

real(kind=double_precision) function, dimension(:), allocatable, public data_utils_mod::get_array_double_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retreives an array of doubles with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Double array values of the corresponding field

Definition at line 478 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     real(kind=DOUBLE_PRECISION), dimension(:), allocatable :: get_array_double_from_monc
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_array_double_from_monc=get_array_double(&
          io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_array_integer()

integer function, dimension(:), allocatable, public data_utils_mod::get_array_integer	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retreives an array of integers with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Integer array values of the corresponding field

Definition at line 501 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     integer, dimension(:), allocatable :: get_array_integer
 
     integer :: start_index, end_index, elements
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     elements = (end_index - start_index) / kind(get_array_integer)
 
     allocate(get_array_integer(elements))
     get_array_integer=transfer(data_dump(start_index:end_index), get_array_integer)

Here is the caller graph for this function:

◆ get_array_integer_from_monc()

integer function, dimension(:), allocatable, public data_utils_mod::get_array_integer_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retreives an array of integers with a corresponding key from the raw data dump. The size depends on the configuration that the MONC process supplied to the IO server when it registered which informs of the size of a field.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Integer array values of the corresponding field

Definition at line 529 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     integer, dimension(:), allocatable :: get_array_integer_from_monc
 
     integer ::  monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_array_integer_from_monc=get_array_integer(&
          io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)   

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_field_size()

integer function, public data_utils_mod::get_field_size	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character(len=*), intent(in)	key,
		integer, intent(in)	data_type
	)

Retrieves the size of a field from the data definition.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
key	The key (name) of the field to check for
data_type	The data type of the field

Returns: The number of elements that this field contains (of type data_type)

Definition at line 178 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character(len=*), intent(in) :: key
     integer, intent(in) :: data_type
 
     integer :: start_index, end_index, element_size
     real(kind=DOUBLE_PRECISION) :: dreal
     real(kind=SINGLE_PRECISION) :: sreal
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     if (data_type == integer_data_type) then
       element_size=kind(start_index)
     else if (data_type == double_data_type) then
       element_size=kind(dreal)
     else if (data_type == float_data_type) then
       element_size=kind(sreal)
     else if (data_type == string_data_type) then
       element_size=string_length
     end if
     get_field_size=((end_index-start_index)+1)/element_size

◆ get_map()

type(map_type) function, public data_utils_mod::get_map	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a map data structure with key->value pairs, each of which are strings.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Corresponding map and contents

Definition at line 208 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     
     integer :: start_index, end_index, elements, i
     character(len=STRING_LENGTH) :: retrieved1, retrieved2
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     elements = (end_index+1 - start_index) / (string_length*2)
 
     do i=1, elements
       retrieved1=transfer(data_dump(start_index:start_index+string_length-1), retrieved1)
       start_index=start_index+string_length
       retrieved2=transfer(data_dump(start_index:start_index+string_length-1), retrieved2)
       start_index=start_index+string_length
       call c_put_string(get_map, retrieved1, retrieved2)
     end do    

Here is the caller graph for this function:

◆ get_map_from_monc()

type(map_type) function, public data_utils_mod::get_map_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a map data structure with key->value pairs, each of which are strings.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_dump	Raw data that MONC has sent to us
data_id	The ID of the data definition that is represented by the dump
key	Key of the field to retrieve

Returns: Corresponding map and contents

Definition at line 240 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_map_from_monc=get_map(io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_scalar_integer()

integer function, public data_utils_mod::get_scalar_integer	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a single integer element (scalar) from the data dump.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Corresponding integer

Definition at line 349 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: start_index, end_index
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     get_scalar_integer=transfer(data_dump(start_index:end_index), get_scalar_integer)

Here is the caller graph for this function:

◆ get_scalar_integer_from_monc()

integer function, public data_utils_mod::get_scalar_integer_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a single integer element (scalar) from the data dump.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_dump	Raw data that MONC has sent to us
data_id	The ID of the data definition that is represented by the dump
key	Key of the field to retrieve

Returns: Corresponding integer

Definition at line 372 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_scalar_integer_from_monc=get_scalar_integer(&
          io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_scalar_logical()

logical function, public data_utils_mod::get_scalar_logical	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a single logical element (scalar) from the data dump.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Corresponding logical

Definition at line 305 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: start_index, end_index
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     get_scalar_logical=transfer(data_dump(start_index:end_index), get_scalar_logical)

Here is the caller graph for this function:

◆ get_scalar_logical_from_monc()

logical function, public data_utils_mod::get_scalar_logical_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a single logical element (scalar) from the data dump.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_dump	Raw data that MONC has sent to us
data_id	The ID of the data definition that is represented by the dump
key	Key of the field to retrieve

Returns: Corresponding logical

Definition at line 328 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_scalar_logical_from_monc=get_scalar_logical(&
          io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_scalar_real()

real(kind=double_precision) function, public data_utils_mod::get_scalar_real	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retreives a scalar real with a corresponding key from the raw data dump.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Real value of the corresponding field

Definition at line 393 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: start_index, end_index
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     get_scalar_real=transfer(data_dump(start_index:end_index), get_scalar_real)

Here is the caller graph for this function:

◆ get_scalar_real_from_monc()

real(kind=double_precision) function, public data_utils_mod::get_scalar_real_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retreives a scalar real with a corresponding key from the raw data dump.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Real value of the corresponding field

Definition at line 416 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_scalar_real_from_monc=get_scalar_real(&
          io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_string()

character(len=string_length) function, public data_utils_mod::get_string	(	type(map_type), intent(inout)	field_starts,
		type(map_type), intent(inout)	field_ends,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a string from the data dump.

Parameters

field_starts	Field starting locations
field_ends	Field ending locations
data_dump	Raw data that MONC has sent to us
key	Key of the field to retrieve

Returns: Corresponding string

Definition at line 260 of file datautils.F90.

     type(map_type), intent(inout) :: field_starts, field_ends
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     character(len=STRING_LENGTH) :: get_string
 
     integer :: start_index, end_index
 
     if (.not. c_contains(field_starts, key) .or. .not. c_contains(field_ends, key)) &
          call log_log(log_error, "Field name `"//key//"` not found in the data definition")
 
     start_index=c_get_integer(field_starts, key)
     end_index=c_get_integer(field_ends, key)
 
     get_string=transfer(data_dump(start_index:end_index), get_string)

Here is the caller graph for this function:

◆ get_string_from_monc()

character(len=string_length) function, public data_utils_mod::get_string_from_monc	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump,
		character(len=*), intent(in)	key
	)

Retrieves a string from the data dump.

Parameters

io_configuration	Configuration of the IO server
source	PID of the MONC process
data_dump	Raw data that MONC has sent to us
data_id	The ID of the data definition that is represented by the dump
key	Key of the field to retrieve

Returns: Corresponding string

Definition at line 284 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character, dimension(:), allocatable, intent(in) :: data_dump
     character(len=*), intent(in) :: key
     character(len=STRING_LENGTH) :: get_string_from_monc
 
     integer :: monc_location
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     get_string_from_monc=get_string(io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), &
          io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), data_dump, key)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_field_present()

logical function, public data_utils_mod::is_field_present	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character(len=*), intent(in)	key
	)

Definition at line 146 of file datautils.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     integer, intent(in) :: source, data_id
     character(len=*), intent(in) :: key
 
     integer :: start_index, end_index, monc_location
     class(*), pointer :: generic
 
     monc_location=c_get_integer(io_configuration%monc_to_index, conv_to_string(source))
 
     generic=>c_get_generic(io_configuration%registered_moncs(monc_location)%field_start_locations(data_id), key)
     if (.not. associated(generic)) then
       is_field_present=.false.
       return
     end if
     start_index=conv_to_integer(generic, .false.)
     generic=>c_get_generic(io_configuration%registered_moncs(monc_location)%field_end_locations(data_id), key)
     if (.not. associated(generic)) then
       is_field_present=.false.
       return
     end if
     end_index=conv_to_integer(generic, .false.)
 
     is_field_present = end_index .gt. start_index

Here is the caller graph for this function:

◆ unpack_scalar_dp_real_from_bytedata()

real(kind=double_precision) function, public data_utils_mod::unpack_scalar_dp_real_from_bytedata	(	character, dimension(:), intent(in)	data,
		integer, intent(inout)	start_point
	)

Unpacks a double precision scalar real from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point.

Parameters

data	The byte data to read from
start_point	Starting point, which is then updated to point to the next item in the byte data

Returns: A double precision real held at the specific location

Definition at line 89 of file datautils.F90.

     character, dimension(:), intent(in) :: data
     integer, intent(inout) :: start_point
 
     unpack_scalar_dp_real_from_bytedata=transfer(data(start_point:start_point+&
          kind(unpack_scalar_dp_real_from_bytedata)-1), unpack_scalar_dp_real_from_bytedata)
     start_point=start_point+kind(unpack_scalar_dp_real_from_bytedata)

Here is the caller graph for this function:

◆ unpack_scalar_integer_from_bytedata()

integer function, public data_utils_mod::unpack_scalar_integer_from_bytedata	(	character, dimension(:), intent(in)	data,
		integer, intent(inout)	start_point
	)

Unpacks a scalar integer from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point.

Parameters

data	The byte data to read from
start_point	Starting point, which is then updated to point to the next item in the byte data

Returns: An integer held at the specific location

Definition at line 34 of file datautils.F90.

     character, dimension(:), intent(in) :: data
     integer, intent(inout) :: start_point
 
     unpack_scalar_integer_from_bytedata=transfer(data(start_point:start_point+&
          kind(unpack_scalar_integer_from_bytedata)-1), unpack_scalar_integer_from_bytedata)
     start_point=start_point+kind(unpack_scalar_integer_from_bytedata)

Here is the caller graph for this function:

◆ unpack_scalar_logical_from_bytedata()

logical function, public data_utils_mod::unpack_scalar_logical_from_bytedata	(	character, dimension(:), intent(in)	data,
		integer, intent(inout)	start_point
	)

Unpacks a scalar logical from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point.

Parameters

data	The byte data to read from
start_point	Starting point, which is then updated to point to the next item in the byte data

Returns: A logical held at the specific location

Definition at line 48 of file datautils.F90.

     character, dimension(:), intent(in) :: data
     integer, intent(inout) :: start_point
 
     unpack_scalar_logical_from_bytedata=transfer(data(start_point:start_point+&
          kind(unpack_scalar_logical_from_bytedata)-1), unpack_scalar_logical_from_bytedata)
     start_point=start_point+kind(unpack_scalar_logical_from_bytedata)

◆ unpack_scalar_real_from_bytedata()

real function, public data_utils_mod::unpack_scalar_real_from_bytedata	(	character, dimension(:), intent(in)	data,
		integer, intent(inout)	start_point
	)

Unpacks a scalar real from some byte data, this is a very simple unpack routine wrapping the transfer and updating the current point.

Parameters

data	The byte data to read from
start_point	Starting point, which is then updated to point to the next item in the byte data

Returns: A single precision real held at the specific location

Definition at line 75 of file datautils.F90.

     character, dimension(:), intent(in) :: data
     integer, intent(inout) :: start_point
 
     unpack_scalar_real_from_bytedata=transfer(data(start_point:start_point+&
          kind(unpack_scalar_real_from_bytedata)-1), unpack_scalar_real_from_bytedata)
     start_point=start_point+kind(unpack_scalar_real_from_bytedata)

◆ unpack_scalar_string_from_bytedata()

character(len=string_length) function, public data_utils_mod::unpack_scalar_string_from_bytedata	(	character, dimension(:), intent(in)	data,
		integer, intent(inout)	start_point
	)

Unpacks a string from some byte data with default length, this is a very simple unpack routine wrapping the transfer and updating the current point.

Parameters

data	The byte data to read from
start_point	Starting point, which is then updated to point to the next item in the byte data

Returns: A string held at the specific location

Definition at line 62 of file datautils.F90.

     character, dimension(:), intent(in) :: data
     integer, intent(inout) :: start_point
 
     unpack_scalar_string_from_bytedata=transfer(data(start_point:start_point+string_length-1), unpack_scalar_string_from_bytedata)
     start_point=start_point+string_length

Variable Documentation

◆ array_step_threshold

integer, parameter data_utils_mod::array_step_threshold =204800

private

Definition at line 17 of file datautils.F90.

17 integer, parameter :: array_step_threshold=204800

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ get_2darray_double()

◆ get_2darray_double_from_monc()

◆ get_3darray_double()

◆ get_3darray_double_from_monc()

◆ get_4darray_double()

◆ get_4darray_double_from_monc()

◆ get_action_attribute_integer()

◆ get_action_attribute_logical()

◆ get_action_attribute_string()

◆ get_array_double()

◆ get_array_double_from_monc()

◆ get_array_integer()

◆ get_array_integer_from_monc()

◆ get_field_size()

◆ get_map()

◆ get_map_from_monc()

◆ get_scalar_integer()

◆ get_scalar_integer_from_monc()

◆ get_scalar_logical()

◆ get_scalar_logical_from_monc()

◆ get_scalar_real()

◆ get_scalar_real_from_monc()

◆ get_string()

◆ get_string_from_monc()

◆ is_field_present()

◆ unpack_scalar_dp_real_from_bytedata()

◆ unpack_scalar_integer_from_bytedata()

◆ unpack_scalar_logical_from_bytedata()

◆ unpack_scalar_real_from_bytedata()

◆ unpack_scalar_string_from_bytedata()

Variable Documentation

◆ array_step_threshold