MONC component registry. More...

Data Types
type	group_descriptor_type
	Descriptor of a group. More...

type	pointer_wrapper_type
	Private helper type which wraps a procedure pointer. This is needed for storage in our collections_mod and allows us to associate additional information, such as number of times called, performance etc in future if we wanted to. More...

Functions/Subroutines
subroutine, public	init_registry (options_database)
	Initialises the registry with the provided configuration file. More...

subroutine, public	free_registry ()
	Will deregister all components and free up the registry data structures. This can either be called at the end of execution to clean memory up or used to clear the registry. More...

subroutine, public	register_component (options_database, descriptor)
	Will register a component and install the nescesary callback hooks. More...

logical function, public	is_component_field_available (name)
	Determines whether a specific published field is available or not. More...

type(component_field_value_type) function, public	get_component_field_value (current_state, name)
	Retrieves the value wrapper of a components published field. More...

type(component_field_information_type) function, public	get_component_field_information (current_state, name)
	Retrieves information about a components published field which includes its type and size. More...

type(list_type) function, public	get_all_component_published_fields ()
	Retrieves all of the published field information. More...

subroutine	load_published_fields (descriptor)
	Loads the published fields information for an entire component into the registry's definition list. More...

subroutine, public	deregister_component (name)
	Will deregister a component, remove all callback hooks and free registry specific memory allocated to the component. More...

type(component_descriptor_type) function, pointer, public	get_component_info (name)
	Retrieves detailed information about a specific component. More...

type(map_type) function, public	get_all_registered_components ()
	Returns a brief summary of all registered components. More...

subroutine, public	execute_initialisation_callbacks (current_state)
	Calls all initialisation callbacks with the specified state. More...

subroutine, public	execute_timestep_callbacks (current_state, group_id)
	Calls all timestep callbacks with the specified state. More...

subroutine, public	execute_finalisation_callbacks (current_state)
	Calls all finalisation callbacks with the specified state. More...

subroutine, public	order_all_callbacks ()
	Orders all callbacks in the prospective stages based upon the priorities of each descriptor. More...

type(map_type) function	order_grouped_timstep_callbacks (group_id)

logical function, public	is_component_enabled (options_database, component_name)
	Determines whether or not a specific component is registered and enabled. More...

subroutine, public	display_callbacks_in_order_at_each_stage ()
	Displays the registered callbacks of each stage in the order that they will be called. More...

subroutine, public	get_ordered_groups (ordered_groups)
	Orders all the groups (in the order that they will be called in) and returns an array with these in order. This is useful for prefetching the groups in order so that per timestep we can just iterate through the array which is O(n) More...

integer function	get_group_id (group_name)
	Given a group name this returns the id (i.e. order) of that group. More...

type(group_descriptor_type) function	get_group_descriptor_from_name (group_name)
	Given a group name this returns the group descriptor corresponding to that or an error if none is found. More...

type(group_descriptor_type) function	get_group_descriptor_from_id (group_id)
	Given the id of a group this will return the corresponding descriptor. More...

subroutine	display_callbacks_in_order (stage_callbacks, stagetitle)
	Displays the registered callbacks of a specific stage in the order that they will be called. More...

subroutine	read_initialisation_and_finalisation_orders (options_database)

subroutine	read_specific_orders (options_database, key, data_structure)

subroutine	read_group_configurations (options_database)

subroutine	remove_descriptor (descriptor)
	Will remove a specific descriptor from the registry table and uninstall the corresponding callback hooks for each state. More...

subroutine	unload_callback_hooks (descriptor, group_name)
	Will unload the callback hooks that have been installed for each state. More...

subroutine	load_callback_hooks (descriptor, group_name)
	Will install the callback hooks for each state. More...

subroutine	rebalance_callbacks (callbacks, priorities, stage_name)

integer function	get_highest_callback_priority (callbacks, priorities)

subroutine	execute_callbacks (callback_map, current_state)
	Will execute the appropriate callbacks in a specific map_type given the current state. More...

subroutine	add_callback (callback_map, name, procedure_pointer)
	Will install a specific callback hook into the specified map_type of existing hooks. More...

Variables
integer, parameter, public	group_type_whole =0
	Execute the callbacks in this group once per timestep. More...

integer, parameter, public	group_type_column =1
	Execute the callbacks in this group for each column per timestep. More...

type(list_type), save	field_information

integer, dimension(:), allocatable	group_types
	Group types. More...

character(len=string_length), dimension(:), allocatable	enabled_component_input_keys
	Temporary read array of component enable names. More...

character(len=string_length), dimension(:), allocatable	group_locations
	Provides an id to each group. More...

type(map_type), save	init_callbacks
	Callback hooks for the initialisation stage. More...

type(map_type), save	finalisation_callbacks
	Callback hooks for the finalisation stage. More...

type(map_type), save	component_descriptions
	Copies of component descriptors. More...

type(map_type), save	group_descriptors
	Group descriptors for each group, name->descriptor. More...

type(map_type), save	component_groups

type(map_type), save	init_orderings

type(map_type), save	finalisation_orderings

type(hashmap_type), save	field_procedure_retrievals

type(hashmap_type), save	field_procedure_sizings

type(map_type), dimension(:), allocatable	timestep_callbacks
	Callback hooks for the timestep stage. More...

Detailed Description

MONC component registry.

Supports management of components. Each stage is called via the registry which will execute the installed callback hooks for that stage in order.

Function/Subroutine Documentation

◆ add_callback()

subroutine registry_mod::add_callback	(	type(map_type), intent(inout)	callback_map,
		character(len=*), intent(in)	name,
		procedure(), pointer	procedure_pointer
	)

private

Will install a specific callback hook into the specified map_type of existing hooks.

Parameters

callbackmap_type	The map_type of existing callbacks which we are going to install this one into
name	The name of the callback that we are installing
procedurePointer	Pointer to the procedure which implements the callback

Definition at line 647 of file registry.F90.

     type(map_type), intent(inout) :: callback_map
     procedure(), pointer :: procedure_pointer
     character(len=*), intent(in) :: name
 
     type(pointer_wrapper_type), pointer :: wrapper
     class(*), pointer :: genericwrapper
 
     allocate(wrapper) ! We allocate our own copy of the descriptor here to ensure the consistency of registry information
     wrapper%ptr => procedure_pointer
     genericwrapper=>wrapper
     call c_put_generic(callback_map, name, genericwrapper, .false.)

Here is the caller graph for this function:

◆ deregister_component()

subroutine, public registry_mod::deregister_component ( character(len=*), intent(in) name )

Will deregister a component, remove all callback hooks and free registry specific memory allocated to the component.

Parameters

name	The name of the component to de-register

Definition at line 226 of file registry.F90.

     character(len=*), intent(in) :: name
     class(*), pointer :: description_data
 
     description_data=>c_get_generic(component_descriptions, name)
     select type(description_data)
       type is (component_descriptor_type)
         call remove_descriptor(description_data)
     end select
     deallocate(description_data)  ! Is added as a clone of the original so free the memory

Here is the call graph for this function:

Here is the caller graph for this function:

◆ display_callbacks_in_order()

subroutine registry_mod::display_callbacks_in_order	(	type(map_type), intent(inout)	stage_callbacks,
		character(len=*), intent(in)	stagetitle
	)

private

Displays the registered callbacks of a specific stage in the order that they will be called.

Parameters

stageCallbacks	The registered callbacks for a stage
stagetitle	The title of the stage - used for printing out information

Definition at line 436 of file registry.F90.

     type(map_type), intent(inout) :: stage_callbacks
     character(len=*), intent(in) :: stagetitle
 
     integer :: i, entries
 
     entries = c_size(stage_callbacks)
     do i=1,entries
       call log_master_log(log_info, "Stage: "//stagetitle//" at: "//trim(conv_to_string(i))//"  "//c_key_at(stage_callbacks, i))
     end do

Here is the caller graph for this function:

◆ display_callbacks_in_order_at_each_stage()

subroutine, public registry_mod::display_callbacks_in_order_at_each_stage ( )

Displays the registered callbacks of each stage in the order that they will be called.

Definition at line 348 of file registry.F90.

     integer :: i
     type(group_descriptor_type) :: group_descriptor
 
     call display_callbacks_in_order(init_callbacks, "init")
     do i=1,size(timestep_callbacks)
       group_descriptor=get_group_descriptor_from_id(i)
       call display_callbacks_in_order(timestep_callbacks(i), "timestep group '"//trim(group_descriptor%name)//"'")
     end do    
     call display_callbacks_in_order(finalisation_callbacks, "finalisation")

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_callbacks()

subroutine registry_mod::execute_callbacks	(	type(map_type), intent(inout)	callback_map,
		type(model_state_type), intent(inout)	current_state
	)

private

Will execute the appropriate callbacks in a specific map_type given the current state.

Parameters

callbackmap_type	The map_type of callback hooks to execute
currentState	The model state which may be (and likely is) modified in callbacks

Definition at line 626 of file registry.F90.

     type(map_type), intent(inout) :: callback_map
     type(model_state_type), intent(inout) :: current_state
 
     class(*), pointer :: data
     type(iterator_type) :: iterator
 
     iterator=c_get_iterator(callback_map)
     do while (c_has_next(iterator))
       data=>c_get_generic(c_next_mapentry(iterator))
       select type(data)
         type is (pointer_wrapper_type)
         call data%ptr(current_state)
       end select
     end do

Here is the caller graph for this function:

◆ execute_finalisation_callbacks()

subroutine, public registry_mod::execute_finalisation_callbacks ( type(model_state_type), intent(inout) current_state )

Calls all finalisation callbacks with the specified state.

Parameters

currentState The current model state which may (and often is) modified

Definition at line 294 of file registry.F90.

     type(model_state_type), intent(inout) :: current_state
 
     call execute_callbacks(finalisation_callbacks, current_state)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_initialisation_callbacks()

subroutine, public registry_mod::execute_initialisation_callbacks ( type(model_state_type), intent(inout) current_state )

Calls all initialisation callbacks with the specified state.

Parameters

currentState The current model state which may (and often is) modified

Definition at line 275 of file registry.F90.

     type(model_state_type), intent(inout) :: current_state
 
     call execute_callbacks(init_callbacks, current_state)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_timestep_callbacks()

subroutine, public registry_mod::execute_timestep_callbacks	(	type(model_state_type), intent(inout)	current_state,
		integer	group_id
	)

Calls all timestep callbacks with the specified state.

Parameters

currentState The current model state which may (and often is) modified

Definition at line 283 of file registry.F90.

     type(model_state_type), intent(inout) :: current_state
     integer :: group_id
 
     if (.not. c_is_empty(timestep_callbacks(group_id))) then
       call execute_callbacks(timestep_callbacks(group_id), current_state)
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_registry()

subroutine, public registry_mod::free_registry ( )

Will deregister all components and free up the registry data structures. This can either be called at the end of execution to clean memory up or used to clear the registry.

Definition at line 77 of file registry.F90.

     integer :: i, entries
    
     entries = c_size(component_descriptions)
     do i=1, entries
       ! Key de registering key at element one as each deregister removes elements from map_type
       call deregister_component(c_key_at(component_descriptions, 1))
     end do
 
     call c_free(init_callbacks)
     do i=1,size(timestep_callbacks)
       call c_free(timestep_callbacks(i))
     end do
     deallocate(timestep_callbacks)
     call c_free(finalisation_callbacks)
     call c_free(component_descriptions)
     call c_free(component_groups)
     call c_free(init_orderings)
     call c_free(finalisation_orderings)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_all_component_published_fields()

type(list_type) function, public registry_mod::get_all_component_published_fields ( )

Retrieves all of the published field information.

Returns: The list of published fields

Definition at line 185 of file registry.F90.

     type(list_type) :: get_all_component_published_fields
 
     get_all_component_published_fields=field_information

◆ get_all_registered_components()

type(map_type) function, public registry_mod::get_all_registered_components ( )

Returns a brief summary of all registered components.

Returns: A map_type where the keys are the component names and value the corresponding version number

Definition at line 258 of file registry.F90.

     integer :: i, number_of_components
     class(*), pointer :: description_data
     type(iterator_type) :: iterator
 
     iterator=c_get_iterator(component_descriptions)
     do while (c_has_next(iterator))
       description_data=>c_get_generic(c_next_mapentry(iterator))
       select type(description_data)
         type is(component_descriptor_type)
           call c_put_real(get_all_registered_components, description_data%name, description_data%version)
       end select
     end do    

Here is the caller graph for this function:

◆ get_component_field_information()

type(component_field_information_type) function, public registry_mod::get_component_field_information	(	type(model_state_type), intent(inout), target	current_state,
		character(len=*), intent(in)	name
	)

Retrieves information about a components published field which includes its type and size.

Parameters

name	The name of the field to look up

Returns: The value wrapper that is associated with this field

Definition at line 165 of file registry.F90.

     type(model_state_type), target, intent(inout) :: current_state
     character(len=*), intent(in) :: name
     type(component_field_information_type) :: get_component_field_information
 
     class(*), pointer :: data
 
     if (c_contains(field_procedure_retrievals, name)) then
       data=>c_get_generic(field_procedure_sizings, name)
       select type(data)
       type is (pointer_wrapper_type)
         call data%ptr(current_state, name, get_component_field_information)
       end select
     else
       call log_master_log(log_error, "Published field '"//trim(name)//"' is not found in any enabled components")
     end if

Here is the call graph for this function:

◆ get_component_field_value()

type(component_field_value_type) function, public registry_mod::get_component_field_value	(	type(model_state_type), intent(inout), target	current_state,
		character(len=*), intent(in)	name
	)

Retrieves the value wrapper of a components published field.

Parameters

name	The name of the field to look up

Returns: The value wrapper that is associated with this field

Definition at line 144 of file registry.F90.

     type(model_state_type), target, intent(inout) :: current_state
     character(len=*), intent(in) :: name
     type(component_field_value_type) :: get_component_field_value
 
     class(*), pointer :: data
 
     if (c_contains(field_procedure_retrievals, name)) then
       data=>c_get_generic(field_procedure_retrievals, name)
       select type(data)
       type is (pointer_wrapper_type)
         call data%ptr(current_state, name, get_component_field_value)
       end select
     else
       call log_master_log(log_error, "Published field '"//trim(name)//"' is not found in any enabled components")
     end if

Here is the call graph for this function:

◆ get_component_info()

type(component_descriptor_type) function, pointer, public registry_mod::get_component_info ( character(len=*), intent(in) name )

Retrieves detailed information about a specific component.

Parameters

name	The name of the component to retrieve information for

Returns: The registry's copy of the component descriptor or null if it does not exist

Definition at line 241 of file registry.F90.

     character(len=*), intent(in) :: name
     type(component_descriptor_type), pointer :: get_component_info
     class(*), pointer :: description_data
 
     get_component_info => null()
     description_data => c_get_generic(component_descriptions, name)
     if (associated(description_data)) then
       select type(description_data)
         type is (component_descriptor_type)
         get_component_info => description_data
       end select
     end if

Here is the caller graph for this function:

◆ get_group_descriptor_from_id()

type(group_descriptor_type) function registry_mod::get_group_descriptor_from_id ( integer, intent(in) group_id )

private

Given the id of a group this will return the corresponding descriptor.

Parameters

group_id Id of the group to find

Returns: The descriptor that has the correct id number

Definition at line 412 of file registry.F90.

     integer, intent(in) :: group_id
 
     type(iterator_type) :: iterator
     class(*), pointer :: generic
 
     iterator=c_get_iterator(group_descriptors)
     do while (c_has_next(iterator))
       generic=>c_get_generic(c_next_mapentry(iterator))
        if (associated(generic)) then
         select type(generic)
         type is(group_descriptor_type)
           if (generic%id == group_id) then
             get_group_descriptor_from_id=generic
             return
           end if
         end select
       end if
     end do     

Here is the caller graph for this function:

◆ get_group_descriptor_from_name()

type(group_descriptor_type) function registry_mod::get_group_descriptor_from_name ( character(len=*), intent(in) group_name )

private

Given a group name this returns the group descriptor corresponding to that or an error if none is found.

Parameters

group_name Name of the group to look up

Returns: Descriptor of the corresponding group

Definition at line 393 of file registry.F90.

     character(len=*), intent(in) :: group_name
 
     class(*), pointer :: generic       
 
     generic=>c_get_generic(group_descriptors, group_name)
     if (associated(generic)) then
       select type(generic)
         type is(group_descriptor_type)
           get_group_descriptor_from_name=generic
       end select      
     else
       call log_master_log(log_error, "No configuration specified for group "//group_name)
     end if    

Here is the caller graph for this function:

◆ get_group_id()

integer function registry_mod::get_group_id ( character(len=*), intent(in) group_name )

private

Given a group name this returns the id (i.e. order) of that group.

Parameters

group_name The group name to look up

Returns: The id (also order) of the group

Definition at line 381 of file registry.F90.

     character(len=*), intent(in) :: group_name
 
     type(group_descriptor_type) :: descriptor
 
     descriptor=get_group_descriptor_from_name(group_name)
     get_group_id=descriptor%id

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_highest_callback_priority()

integer function registry_mod::get_highest_callback_priority	(	type(map_type), intent(inout)	callbacks,
		type(map_type), intent(inout)	priorities
	)

private

Definition at line 600 of file registry.F90.

     type(map_type), intent(inout) :: callbacks, priorities
 
     integer :: i, entries_in_list, min_priority, min_location, priority
     character(len=STRING_LENGTH) :: key
 
     min_location=0
     min_priority=1000
 
     entries_in_list=c_size(callbacks)
     do i=1, entries_in_list
       key=c_key_at(callbacks, i)
       if (c_contains(priorities, key)) then
         priority=c_get_integer(priorities, key)
         if (priority .lt. min_priority) then
           min_priority=priority
           min_location=i
         end if      
       end if
     end do
     get_highest_callback_priority=min_location

Here is the caller graph for this function:

◆ get_ordered_groups()

subroutine, public registry_mod::get_ordered_groups ( type(group_descriptor_type), dimension(:), allocatable ordered_groups )

Orders all the groups (in the order that they will be called in) and returns an array with these in order. This is useful for prefetching the groups in order so that per timestep we can just iterate through the array which is O(n)

Returns: An array of groups in the order that they will be executed in

Definition at line 363 of file registry.F90.

     type(group_descriptor_type), dimension(:), allocatable :: ordered_groups
 
     integer :: i
 
     allocate(ordered_groups(c_size(group_descriptors)))
     do i=1,c_size(group_descriptors)
       ordered_groups(i)=get_group_descriptor_from_id(i)
     end do    

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_registry()

subroutine, public registry_mod::init_registry ( type(hashmap_type), intent(inout) options_database )

Initialises the registry with the provided configuration file.

Parameters

configurationFileName The filename of the configuration file to parse

Definition at line 67 of file registry.F90.

     type(hashmap_type), intent(inout) :: options_database
 
     call read_group_configurations(options_database)
     call read_initialisation_and_finalisation_orders(options_database)
     allocate(timestep_callbacks(c_size(group_descriptors)))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_component_enabled()

logical function, public registry_mod::is_component_enabled	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	component_name
	)

Determines whether or not a specific component is registered and enabled.

Parameters

component_name The name of the component to check for

Definition at line 334 of file registry.F90.

     type(hashmap_type), intent(inout) :: options_database
     character(len=*), intent(in) :: component_name
     
     if (c_contains(component_descriptions, component_name)) then
       if (options_has_key(options_database, trim(component_name)//"_enabled")) then
         is_component_enabled=options_get_logical(options_database, trim(component_name)//"_enabled")
         return
       end if
     end if
     is_component_enabled=.false.

◆ is_component_field_available()

logical function, public registry_mod::is_component_field_available ( character(len=*), intent(in) name )

Determines whether a specific published field is available or not.

Parameters

name	The name of the field to search for

Returns: Whether this field is found

Definition at line 135 of file registry.F90.

     character(len=*), intent(in) :: name
 
     is_component_field_available=c_contains(field_procedure_retrievals, name)

◆ load_callback_hooks()

subroutine registry_mod::load_callback_hooks	(	type(component_descriptor_type), intent(in)	descriptor,
		character(len=*), intent(in), optional	group_name
	)

private

Will install the callback hooks for each state.

Parameters

descriptor The component descriptor which is to be installed

Definition at line 556 of file registry.F90.

     type(component_descriptor_type), intent(in) :: descriptor
     character(len=*), intent(in), optional :: group_name
 
     if (associated(descriptor%initialisation)) call add_callback(init_callbacks, descriptor%name, descriptor%initialisation)
     if (associated(descriptor%timestep)) then
       if (present(group_name)) then
         call add_callback(timestep_callbacks(get_group_id(group_name)), descriptor%name, descriptor%timestep)
       else
         call log_master_log(log_error, "In the configuration you must provide a group for component "&
              //trim(descriptor%name)//" which has a timestep callback")
       end if
     end if
     if (associated(descriptor%finalisation)) call add_callback(finalisation_callbacks, descriptor%name, descriptor%finalisation)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_published_fields()

subroutine registry_mod::load_published_fields ( type(component_descriptor_type), intent(in) descriptor )

private

Loads the published fields information for an entire component into the registry's definition list.

Parameters

descriptor The field descriptor to load in

Definition at line 193 of file registry.F90.

     type(component_descriptor_type), intent(in) :: descriptor
 
     integer :: i
     class(*), pointer :: field_generic_description
     type(pointer_wrapper_type), pointer :: wrapper
     class(*), pointer :: genericwrapper
 
     if (associated(descriptor%published_fields) .and. associated(descriptor%field_value_retrieval) .and. &
          associated(descriptor%field_information_retrieval)) then
       do i=1, size(descriptor%published_fields)
         field_generic_description=>descriptor%published_fields(i)
         call c_add_generic(field_information, field_generic_description, .false.)
         allocate(wrapper) ! We allocate our own copy of the descriptor here to ensure the consistency of registry information
         wrapper%ptr => descriptor%field_value_retrieval
         genericwrapper=>wrapper
         call c_put_generic(field_procedure_retrievals, descriptor%published_fields(i), genericwrapper, .false.)
         allocate(wrapper)
         wrapper%ptr => descriptor%field_information_retrieval
         genericwrapper=>wrapper
         call c_put_generic(field_procedure_sizings, descriptor%published_fields(i), genericwrapper, .false.)
       end do
 
       else if (associated(descriptor%published_fields) .or. associated(descriptor%field_value_retrieval) .or. &
          associated(descriptor%field_information_retrieval)) then
         call log_master_log(log_warn, "Component "//trim(descriptor%name)//&
              " has provided incomplete configuration for published fields, therefore ignoring these")
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ order_all_callbacks()

subroutine, public registry_mod::order_all_callbacks ( )

Orders all callbacks in the prospective stages based upon the priorities of each descriptor.

Note that this is an expensive operation as it involves multiple searches of the component list_types so should be called sparingly. When two priorities are equal then the order depends upon which one was registered first.

Definition at line 305 of file registry.F90.

     integer :: i
     type(map_type) :: specific_ts
 
     call rebalance_callbacks(init_callbacks, init_orderings, "initialisation")
     do i=1,size(timestep_callbacks)
       specific_ts=order_grouped_timstep_callbacks(i)
       call rebalance_callbacks(timestep_callbacks(i), specific_ts, "time stepping")
       call c_free(specific_ts)
     end do    
     call rebalance_callbacks(finalisation_callbacks, finalisation_orderings, "finalisation")

Here is the call graph for this function:

Here is the caller graph for this function:

◆ order_grouped_timstep_callbacks()

type(map_type) function registry_mod::order_grouped_timstep_callbacks ( integer, intent(in) group_id )

private

Definition at line 318 of file registry.F90.

     integer, intent(in) :: group_id
     
     integer :: group_size, i
 
     type(group_descriptor_type) :: descriptor
 
     descriptor=get_group_descriptor_from_id(group_id)
     group_size=descriptor%number_of_members
     do i=1, group_size
       call c_put_integer(order_grouped_timstep_callbacks, trim(descriptor%group_members(i)), i)
     end do    

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_group_configurations()

subroutine registry_mod::read_group_configurations ( type(hashmap_type), intent(inout) options_database )

private

Definition at line 470 of file registry.F90.

     type(hashmap_type), intent(inout) :: options_database
 
     integer :: group_elements, i, j
     class(*), pointer :: generic_to_add
     type(group_descriptor_type) :: group_description
     character(len=STRING_LENGTH) :: group_type
 
     group_elements=options_get_array_size(options_database, "group_names")
     if (group_elements .lt. 1) call log_master_log(log_error, "You must provide some group definitions")
     do i=1, group_elements
       group_description%name=trim(options_get_string(options_database, "group_names", i))
       if (options_has_key(options_database, trim(group_description%name)//"_group_type")) then
         group_type=trim(options_get_string(options_database, trim(group_description%name)//"_group_type"))
         if (trim(group_type) .eq. "entire") then
           group_description%type=0
         else if (trim(group_type) .eq. "column") then
           group_description%type=1
         else if (trim(group_type) .eq. "slice") then
           group_description%type=2
         else
           call log_master_log(log_error, "Group type "//trim(group_type)//" for group "&
                //trim(group_description%name)//" not understood")
         end if
       else
         call log_master_log(log_error, "No group type for group "//trim(group_description%name))
       end if
       group_description%id=i
       if (.not. options_has_key(options_database, trim(group_description%name)//"_group_contents")) then
         call log_master_log(log_error, "No component contents specified for group "//trim(group_description%name))
       end if
       group_description%number_of_members=options_get_array_size(options_database, &
            trim(group_description%name)//"_group_contents")    
       if (group_description%number_of_members == 0 .or. .not. options_has_key(options_database, &
            trim(group_description%name)//"_group_contentsa_size")) then
         if (options_has_key(options_database, trim(group_description%name)//"_group_contents")) then
           group_description%number_of_members=1
           group_description%group_members(1)=trim(options_get_string(options_database, &
                  trim(group_description%name)//"_group_contents"))
           call c_put_string(component_groups, trim(group_description%group_members(1)), group_description%name)
         else
           call log_master_log(log_error, "No contents specified for group "//trim(group_description%name))
         end if
       else
         do j=1, group_description%number_of_members
           group_description%group_members(j)=trim(options_get_string(options_database, &
                trim(group_description%name)//"_group_contents", j))
           call c_put_string(component_groups, trim(group_description%group_members(j)), group_description%name)
         end do
       end if
       allocate(generic_to_add, source=group_description)
       call c_put_generic(group_descriptors, group_description%name, generic_to_add, .false.)
     end do    

Here is the caller graph for this function:

◆ read_initialisation_and_finalisation_orders()

subroutine registry_mod::read_initialisation_and_finalisation_orders ( type(hashmap_type), intent(inout) options_database )

private

Definition at line 448 of file registry.F90.

     type(hashmap_type), intent(inout) :: options_database
 
     call read_specific_orders(options_database, "initialisation_stage_ordering", init_orderings)
     call read_specific_orders(options_database, "finalisation_stage_ordering", finalisation_orderings)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_specific_orders()

subroutine registry_mod::read_specific_orders	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*)	key,
		type(map_type), intent(inout)	data_structure
	)

private

Definition at line 455 of file registry.F90.

     type(hashmap_type), intent(inout) :: options_database
     type(map_type), intent(inout) :: data_structure
     character(len=*) :: key
 
     integer :: number_of_elements, i
     character(len=STRING_LENGTH) :: component_name
 
     number_of_elements=options_get_array_size(options_database, key)
     do i=1, number_of_elements
       component_name=options_get_string(options_database, key, i)
       call c_put_integer(data_structure, trim(component_name), i)
     end do

Here is the caller graph for this function:

◆ rebalance_callbacks()

subroutine registry_mod::rebalance_callbacks	(	type(map_type), intent(inout)	callbacks,
		type(map_type), intent(inout)	priorities,
		character(len=*), intent(in)	stage_name
	)

private

Definition at line 572 of file registry.F90.

     type(map_type), intent(inout) :: callbacks, priorities
     character(len=*), intent(in) :: stage_name
 
     type(map_type) :: ordered_callbacks
     integer :: i, entries_in_list, current_item
     class(*), pointer :: generic
     
     entries_in_list=c_size(callbacks)
     do i=1, entries_in_list
       current_item=get_highest_callback_priority(callbacks, priorities)
       if (current_item .ge. 1) then
         generic=>c_generic_at(callbacks, current_item)
         call c_put_generic(ordered_callbacks, c_key_at(callbacks, current_item), generic, .false.)
         call c_remove(callbacks, c_key_at(callbacks, current_item))
       end if
     end do
 
     entries_in_list=c_size(callbacks)
     do i=1, entries_in_list
       generic=>c_generic_at(callbacks, i)
       call c_put_generic(ordered_callbacks, c_key_at(callbacks, i), generic, .false.)
       call log_master_log(log_warn, "Run order callback for component "//trim(c_key_at(callbacks, i))//&
            " at stage "//stage_name//" not specified")
     end do
     callbacks=ordered_callbacks

Here is the call graph for this function:

Here is the caller graph for this function:

◆ register_component()

subroutine, public registry_mod::register_component	(	type(hashmap_type), intent(inout)	options_database,
		type(component_descriptor_type), intent(in)	descriptor
	)

Will register a component and install the nescesary callback hooks.

Parameters

descriptor The component descriptor and a separate copy of this it stored as reference

Definition at line 100 of file registry.F90.

     type(hashmap_type), intent(inout) :: options_database
     type(component_descriptor_type), intent(in) :: descriptor
 
     type(component_descriptor_type), pointer :: registry_descriptor
     class(*), pointer :: description_data
     character(len=STRING_LENGTH) :: group_name
     logical :: component_enabled
 
     allocate(registry_descriptor, source=descriptor) ! Make copy of the descriptor (which registry might modify)
 
     if (options_has_key(options_database, trim(descriptor%name)//"_enabled")) then
       component_enabled=options_get_logical(options_database, trim(descriptor%name)//"_enabled")
     else
       component_enabled=.false.
       call log_master_log(log_warn, "No enabled configuration for component "//trim(descriptor%name)//" therefore disabling this")
     end if
 
     if (component_enabled) then
       if (c_contains(component_groups, trim(descriptor%name))) then
         group_name=c_get_string(component_groups, trim(descriptor%name))
         call load_callback_hooks(registry_descriptor, group_name)
       else
         call load_callback_hooks(registry_descriptor)
       end if
       call load_published_fields(descriptor)
     end if    
 
     description_data => registry_descriptor
     call c_put_generic(component_descriptions, descriptor%name, description_data, .false.)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_descriptor()

subroutine registry_mod::remove_descriptor ( type(component_descriptor_type), intent(inout) descriptor )

private

Will remove a specific descriptor from the registry table and uninstall the corresponding callback hooks for each state.

Parameters

descriptor The component descriptor which is to be removed

Definition at line 528 of file registry.F90.

     type(component_descriptor_type), intent(inout) :: descriptor
 
     character(len=STRING_LENGTH) :: group_name
 
     if (c_contains(component_groups, trim(descriptor%name))) then
       group_name=c_get_string(component_groups, trim(descriptor%name))
       call unload_callback_hooks(descriptor, group_name)
     else
       call unload_callback_hooks(descriptor)
     end if
     call c_remove(component_descriptions, descriptor%name)

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload_callback_hooks()

subroutine registry_mod::unload_callback_hooks	(	type(component_descriptor_type), intent(in)	descriptor,
		character(len=*), intent(in), optional	group_name
	)

private

Will unload the callback hooks that have been installed for each state.

Parameters

descriptor The component descriptor which is to be unloaded

Definition at line 544 of file registry.F90.

     type(component_descriptor_type), intent(in) :: descriptor
     character(len=*), intent(in), optional :: group_name
 
     if (associated(descriptor%initialisation)) call c_remove(init_callbacks, descriptor%name)
     if (associated(descriptor%timestep) .and. present(group_name)) &
          call c_remove(timestep_callbacks(get_group_id(group_name)), descriptor%name)    
     if (associated(descriptor%finalisation)) call c_remove(finalisation_callbacks, descriptor%name)

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ component_descriptions

type(map_type), save registry_mod::component_descriptions

private

Copies of component descriptors.

Definition at line 47 of file registry.F90.

◆ component_groups

type(map_type), save registry_mod::component_groups

private

Definition at line 47 of file registry.F90.

◆ enabled_component_input_keys

character(len=string_length), dimension(:), allocatable registry_mod::enabled_component_input_keys

private

Temporary read array of component enable names.

Definition at line 28 of file registry.F90.

28 character(len=STRING_LENGTH), dimension(:), allocatable :: enabled_component_input_keys,& !< Temporary read array of component enable names

29 group_locations

◆ field_information

type(list_type), save registry_mod::field_information

private

Definition at line 25 of file registry.F90.

25 type(list_type), save :: field_information

◆ field_procedure_retrievals

type(hashmap_type), save registry_mod::field_procedure_retrievals

private

Definition at line 52 of file registry.F90.

52 type(hashmap_type), save :: field_procedure_retrievals, field_procedure_sizings

◆ field_procedure_sizings

type(hashmap_type), save registry_mod::field_procedure_sizings

private

Definition at line 52 of file registry.F90.

◆ finalisation_callbacks

type(map_type), save registry_mod::finalisation_callbacks

private

Callback hooks for the finalisation stage.

Definition at line 47 of file registry.F90.

◆ finalisation_orderings

type(map_type), save registry_mod::finalisation_orderings

private

Definition at line 47 of file registry.F90.

◆ group_descriptors

type(map_type), save registry_mod::group_descriptors

private

Group descriptors for each group, name->descriptor.

Definition at line 47 of file registry.F90.

◆ group_locations

character(len=string_length), dimension(:), allocatable registry_mod::group_locations

private

Provides an id to each group.

Definition at line 28 of file registry.F90.

◆ group_type_column

integer, parameter, public registry_mod::group_type_column =1

Execute the callbacks in this group for each column per timestep.

Definition at line 22 of file registry.F90.

◆ group_type_whole

integer, parameter, public registry_mod::group_type_whole =0

Execute the callbacks in this group once per timestep.

Definition at line 22 of file registry.F90.

22 integer, parameter :: group_type_whole=0, & !< Execute the callbacks in this group once per timestep

23 group_type_column=1

◆ group_types

integer, dimension(:), allocatable registry_mod::group_types

private

Group types.

Definition at line 27 of file registry.F90.

27 integer, dimension(:), allocatable :: group_types

◆ init_callbacks

type(map_type), save registry_mod::init_callbacks

private

Callback hooks for the initialisation stage.

Definition at line 47 of file registry.F90.

   type(map_type), save :: init_callbacks,&     !< Callback hooks for the initialisation stage       
                     finalisation_callbacks,&   !< Callback hooks for the finalisation stage
                     component_descriptions,&   !< Copies of component descriptors
                     group_descriptors,&        !< Group descriptors for each group, name->descriptor     
                     component_groups, init_orderings, finalisation_orderings

◆ init_orderings

type(map_type), save registry_mod::init_orderings

private

Definition at line 47 of file registry.F90.

◆ timestep_callbacks

type(map_type), dimension(:), allocatable registry_mod::timestep_callbacks

private

Callback hooks for the timestep stage.

Definition at line 54 of file registry.F90.

54 type(map_type), dimension(:), allocatable :: timestep_callbacks

Data Types

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ add_callback()

◆ deregister_component()

◆ display_callbacks_in_order()

◆ display_callbacks_in_order_at_each_stage()

◆ execute_callbacks()

◆ execute_finalisation_callbacks()

◆ execute_initialisation_callbacks()

◆ execute_timestep_callbacks()

◆ free_registry()

◆ get_all_component_published_fields()

◆ get_all_registered_components()

◆ get_component_field_information()

◆ get_component_field_value()

◆ get_component_info()

◆ get_group_descriptor_from_id()

◆ get_group_descriptor_from_name()

◆ get_group_id()

◆ get_highest_callback_priority()

◆ get_ordered_groups()

◆ init_registry()

◆ is_component_enabled()

◆ is_component_field_available()

◆ load_callback_hooks()

◆ load_published_fields()

◆ order_all_callbacks()

◆ order_grouped_timstep_callbacks()

◆ read_group_configurations()

◆ read_initialisation_and_finalisation_orders()

◆ read_specific_orders()

◆ rebalance_callbacks()

◆ register_component()

◆ remove_descriptor()

◆ unload_callback_hooks()

Variable Documentation

◆ component_descriptions

◆ component_groups

◆ enabled_component_input_keys

◆ field_information

◆ field_procedure_retrievals

◆ field_procedure_sizings

◆ finalisation_callbacks

◆ finalisation_orderings

◆ group_descriptors

◆ group_locations

◆ group_type_column

◆ group_type_whole

◆ group_types

◆ init_callbacks

◆ init_orderings

◆ timestep_callbacks