Performs instantaneous time manipulation and only returns a value if the output frequency determines one should be. More...

Functions/Subroutines
subroutine, public	init_instantaneous_manipulation ()
	Initialises the instantaneous time manipulation. More...

subroutine, public	finalise_instantaneous_manipulation ()
	Finalises the instantaneous time manipulation. More...

logical function, public	is_instantaneous_time_manipulation_ready_to_write (latest_time, output_frequency, write_time, latest_timestep, write_timestep)

type(data_values_type) function, public	perform_instantaneous_time_manipulation (instant_values, output_frequency, field_name, timestep, time)
	Performs the instantaneous time manipulation and returns data only if this is to be written to the storage. Internally a state is maintained which tracks when the write was last done to allow for flexibility in the time criteria. More...

logical function	deduce_whether_to_issue_values (field_name, output_frequency, time)
	Determines whether to issue values for write or not. This depends on the time and output frequency. More...

integer(kind=8) function, public	prepare_to_serialise_instantaneous_state ()
	Prepares to serialise the instantaneous state, both determines the byte storage size and issues any locks. More...

subroutine, public	serialise_instantaneous_state (byte_data)
	Will serialise the state of this manipulator so that it can be later restarted. Any locks issued during preparation are released here. More...

subroutine, public	unserialise_instantaneous_state (byte_data)
	Unpacks some serialised byte data to initialise this manipulator to some previous state. More...

Variables
integer, volatile	existing_instantaneous_writes_mutex

type(hashmap_type), volatile	existing_instantaneous_writes

Detailed Description

Performs instantaneous time manipulation and only returns a value if the output frequency determines one should be.

Function/Subroutine Documentation

◆ deduce_whether_to_issue_values()

logical function instantaneous_time_manipulation_mod::deduce_whether_to_issue_values	(	character(len=*), intent(in)	field_name,
		real, intent(in)	output_frequency,
		real(kind=default_precision), intent(in)	time
	)

private

Determines whether to issue values for write or not. This depends on the time and output frequency.

Parameters

field_name	The field name that we are manipulating
output_frequency	Configured output time frequency
time	The current model time

Returns: Whether or not one should issue the instantaneous values to write

Definition at line 74 of file instantaneous_manipulation.F90.

     character(len=*), intent(in) :: field_name
     real, intent(in) :: output_frequency
     real(kind=DEFAULT_PRECISION), intent(in) :: time
 
     real(kind=DEFAULT_PRECISION) :: previous_time_write, time_difference
 
     call check_thread_status(forthread_mutex_lock(existing_instantaneous_writes_mutex))
     if (c_contains(existing_instantaneous_writes, field_name)) then
       previous_time_write=c_get_real(existing_instantaneous_writes, field_name)
       time_difference=(aint(time*10000000.0)-aint(previous_time_write*10000000.0))/10000000.0
     else
       ! Rethink this as only works if started at time=0
       time_difference=time
     end if
     if (time_difference .ge. output_frequency) then
       deduce_whether_to_issue_values=.true.
       call c_put_real(existing_instantaneous_writes, field_name, time)
     else
       deduce_whether_to_issue_values=.false.
     end if
     call check_thread_status(forthread_mutex_unlock(existing_instantaneous_writes_mutex))

Here is the caller graph for this function:

◆ finalise_instantaneous_manipulation()

subroutine, public instantaneous_time_manipulation_mod::finalise_instantaneous_manipulation ( )

Finalises the instantaneous time manipulation.

Definition at line 34 of file instantaneous_manipulation.F90.

34 call check_thread_status(forthread_mutex_destroy(existing_instantaneous_writes_mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_instantaneous_manipulation()

subroutine, public instantaneous_time_manipulation_mod::init_instantaneous_manipulation ( )

Initialises the instantaneous time manipulation.

Definition at line 29 of file instantaneous_manipulation.F90.

29 call check_thread_status(forthread_mutex_init(existing_instantaneous_writes_mutex, -1))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_instantaneous_time_manipulation_ready_to_write()

logical function, public instantaneous_time_manipulation_mod::is_instantaneous_time_manipulation_ready_to_write	(	real, intent(in)	latest_time,
		real, intent(in)	output_frequency,
		real, intent(in)	write_time,
		integer, intent(in)	latest_timestep,
		integer, intent(in)	write_timestep
	)

Definition at line 39 of file instantaneous_manipulation.F90.

     real, intent(in) :: latest_time, output_frequency, write_time
     integer, intent(in) :: latest_timestep, write_timestep
 
     is_instantaneous_time_manipulation_ready_to_write=latest_time + output_frequency .gt. write_time

◆ perform_instantaneous_time_manipulation()

type(data_values_type) function, public instantaneous_time_manipulation_mod::perform_instantaneous_time_manipulation	(	real(kind=default_precision), dimension(:), intent(in)	instant_values,
		real, intent(in)	output_frequency,
		character(len=*), intent(in)	field_name,
		integer, intent(in)	timestep,
		real(kind=default_precision), intent(in)	time
	)

Performs the instantaneous time manipulation and returns data only if this is to be written to the storage. Internally a state is maintained which tracks when the write was last done to allow for flexibility in the time criteria.

Parameters

instant_values	The instantaneous values to work with
output_frequency	The output frequency configuration option
field_name	The field name
timestep	The timestep
time	The model time

Returns: An allocated array of reals if data is to be stored, otherwise this is unallocated

Definition at line 56 of file instantaneous_manipulation.F90.

     real(kind=DEFAULT_PRECISION), dimension(:), intent(in) :: instant_values
     real, intent(in) :: output_frequency
     real(kind=DEFAULT_PRECISION), intent(in) :: time
     character(len=*), intent(in) :: field_name
     integer, intent(in) :: timestep
 
     if (deduce_whether_to_issue_values(field_name, output_frequency, time)) then
       allocate(perform_instantaneous_time_manipulation%values(size(instant_values)))
       perform_instantaneous_time_manipulation%values=instant_values
     end if    

Here is the call graph for this function:

◆ prepare_to_serialise_instantaneous_state()

integer(kind=8) function, public instantaneous_time_manipulation_mod::prepare_to_serialise_instantaneous_state ( )

Prepares to serialise the instantaneous state, both determines the byte storage size and issues any locks.

Returns: The number of bytes needed to store the serialised state

Definition at line 100 of file instantaneous_manipulation.F90.

     real(kind=DEFAULT_PRECISION) :: a
     
     call check_thread_status(forthread_mutex_lock(existing_instantaneous_writes_mutex))
     prepare_to_serialise_instantaneous_state=kind(prepare_to_serialise_instantaneous_state) + &
          ((string_length + kind(a)) * c_size(existing_instantaneous_writes))

Here is the caller graph for this function:

◆ serialise_instantaneous_state()

subroutine, public instantaneous_time_manipulation_mod::serialise_instantaneous_state ( character, dimension(:), intent(inout), allocatable byte_data )

Will serialise the state of this manipulator so that it can be later restarted. Any locks issued during preparation are released here.

Parameters

byte_data The state of this manipulator is written into here

Definition at line 111 of file instantaneous_manipulation.F90.

     character, dimension(:), allocatable, intent(inout) :: byte_data
 
     integer :: current_data_point
     type(mapentry_type) :: map_entry
     type(iterator_type) :: iterator
     
     current_data_point=1
     current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(existing_instantaneous_writes))
     iterator=c_get_iterator(existing_instantaneous_writes)
     do while (c_has_next(iterator))
       map_entry=c_next_mapentry(iterator)
       current_data_point=pack_scalar_field(byte_data, current_data_point, string_value=map_entry%key)
       current_data_point=pack_scalar_field(byte_data, current_data_point, double_real_value=c_get_real(map_entry))
     end do
     call check_thread_status(forthread_mutex_unlock(existing_instantaneous_writes_mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unserialise_instantaneous_state()

subroutine, public instantaneous_time_manipulation_mod::unserialise_instantaneous_state ( character, dimension(:), intent(in), allocatable byte_data )

Unpacks some serialised byte data to initialise this manipulator to some previous state.

Parameters

byte_data The byte data to unpack and reinitialise from

Definition at line 131 of file instantaneous_manipulation.F90.

     character, dimension(:), allocatable, intent(in) :: byte_data
 
     integer :: current_data_point, number_entries, i
 
     current_data_point=1
     number_entries=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
     if (number_entries .gt. 0) then
       do i=1, number_entries
         call c_put_real(existing_instantaneous_writes, unpack_scalar_string_from_bytedata(byte_data, current_data_point), &
              unpack_scalar_dp_real_from_bytedata(byte_data, current_data_point))        
       end do
     end if    