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

Data Types
type	time_averaged_completed_type
	The completed time averaged values. More...

Functions/Subroutines
subroutine, public	init_time_averaged_manipulation ()
	Initialises the reduction action. More...

subroutine, public	finalise_time_averaged_manipulation ()
	Finalises the reduction action, waiting for all outstanding requests and then freeing data. More...

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

type(data_values_type) function, public	perform_timeaveraged_time_manipulation (instant_values, output_frequency, field_name, timestep, time)
	Performs the time averaged manipulation and only returns values if these are to be stored (i.e. past an output frequency) More...

subroutine	time_average (timeaveraged_value, instant_values, time)
	Does the time averaging itself. More...

integer(kind=8) function, public	prepare_to_serialise_time_averaged_state ()
	Prepares to serialise the time averaged state values. Both determines the storage size required and also issue locks. More...

subroutine, public	serialise_time_averaged_state (byte_data)
	Serialises the state of this manipulator so that it can be restarted later on. Releases any locks issue during preparation. More...

subroutine, public	unserialise_time_averaged_state (byte_data)
	Unserialises some byte data to initialise the state from some previous version. More...

integer(kind=8) function	prepare_to_serialise_time_averaged_completed_value (time_av_value)
	Prepares to serialise a time averaged completed value, both determines the storage size and also issue any locks. More...

subroutine	serialise_time_averaged_completed_value (time_av_value, byte_data, current_data_point)
	Serialises a specific time averaged completed value, releases any locks issued during preparation. More...

type(time_averaged_completed_type) function, pointer	unserialise_time_averaged_completed_value (byte_data)
	Will create a specific time averaged completed value based upon the provided serialised data. More...

type(time_averaged_completed_type) function, pointer	find_or_add_timeaveraged_value (timestep, field_name)
	Retrieves or creates (and retrieves) a time averaged value based upon the information provided. More...

type(time_averaged_completed_type) function, pointer	find_timeaveraged_value (field_name, issue_read_lock)
	Finds a time averaged value based upon its field name. More...

Variables
type(hashmap_type), volatile	timeaveraged_values

integer, volatile	timeaveraged_value_rw_lock

Detailed Description

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

Function/Subroutine Documentation

◆ finalise_time_averaged_manipulation()

subroutine, public timeaveraged_time_manipulation_mod::finalise_time_averaged_manipulation ( )

Finalises the reduction action, waiting for all outstanding requests and then freeing data.

Parameters

io_configuration Configuration state of the IO server

Definition at line 46 of file timeaveraged_manipulation.F90.

46 call check_thread_status(forthread_rwlock_destroy(timeaveraged_value_rw_lock))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_or_add_timeaveraged_value()

type(time_averaged_completed_type) function, pointer timeaveraged_time_manipulation_mod::find_or_add_timeaveraged_value	(	integer, intent(in)	timestep,
		character(len=*), intent(in)	field_name
	)

private

Retrieves or creates (and retrieves) a time averaged value based upon the information provided.

Parameters

timestep	The corresponding timestep
field_name	The corresponding field name

Returns: A matching or new time averaged value

Definition at line 281 of file timeaveraged_manipulation.F90.

     integer, intent(in) :: timestep
     character(len=*), intent(in) :: field_name
     type(time_averaged_completed_type), pointer :: find_or_add_timeaveraged_value
     
     class(*), pointer :: generic
     type(time_averaged_completed_type), pointer :: new_entry
 
     find_or_add_timeaveraged_value=>find_timeaveraged_value(field_name)
     if (.not. associated(find_or_add_timeaveraged_value)) then
       call check_thread_status(forthread_rwlock_wrlock(timeaveraged_value_rw_lock))
       find_or_add_timeaveraged_value=>find_timeaveraged_value(field_name, .false.)
       if (.not. associated(find_or_add_timeaveraged_value)) then
         allocate(new_entry)
         new_entry%field_name=field_name
         new_entry%start_time=0.0_default_precision
         new_entry%previous_time=0.0_default_precision
         new_entry%empty_values=.true.
         new_entry%previous_output_time=0.0_default_precision
         call check_thread_status(forthread_mutex_init(new_entry%mutex, -1))
         generic=>new_entry
         call c_put_generic(timeaveraged_values, field_name, generic, .false.)
         find_or_add_timeaveraged_value=>new_entry
       end if
       call check_thread_status(forthread_rwlock_unlock(timeaveraged_value_rw_lock))
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_timeaveraged_value()

type(time_averaged_completed_type) function, pointer timeaveraged_time_manipulation_mod::find_timeaveraged_value	(	character(len=*), intent(in)	field_name,
		logical, intent(in), optional	issue_read_lock
	)

private

Finds a time averaged value based upon its field name.

Parameters

field_name	The corresponding field name
issue_read_lock	Optional flag whether we should issue a read lock during this operation, if omitted then issues lock

Returns: The matching time averaged value or null if none is found

Definition at line 313 of file timeaveraged_manipulation.F90.

     character(len=*), intent(in) :: field_name
     type(time_averaged_completed_type), pointer :: find_timeaveraged_value
     logical, intent(in), optional :: issue_read_lock
 
     class(*), pointer :: generic
     logical :: do_read_lock
 
     if (present(issue_read_lock)) then
       do_read_lock=issue_read_lock      
     else
       do_read_lock=.true.
     end if        
 
     if (do_read_lock) call check_thread_status(forthread_rwlock_rdlock(timeaveraged_value_rw_lock))
     generic=>c_get_generic(timeaveraged_values, field_name)    
     if (do_read_lock) call check_thread_status(forthread_rwlock_unlock(timeaveraged_value_rw_lock))
     if (associated(generic)) then
       select type(generic)
       type is (time_averaged_completed_type)      
         find_timeaveraged_value=>generic
       end select
     else
       find_timeaveraged_value=>null()
     end if

Here is the caller graph for this function:

◆ init_time_averaged_manipulation()

subroutine, public timeaveraged_time_manipulation_mod::init_time_averaged_manipulation ( )

Initialises the reduction action.

Definition at line 40 of file timeaveraged_manipulation.F90.

40 call check_thread_status(forthread_rwlock_init(timeaveraged_value_rw_lock, -1))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_time_averaged_time_manipulation_ready_to_write()

logical function, public timeaveraged_time_manipulation_mod::is_time_averaged_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 51 of file timeaveraged_manipulation.F90.

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

◆ perform_timeaveraged_time_manipulation()

type(data_values_type) function, public timeaveraged_time_manipulation_mod::perform_timeaveraged_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 time averaged manipulation and only returns values if these are to be stored (i.e. past an output frequency)

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 66 of file timeaveraged_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
 
     type(time_averaged_completed_type), pointer :: timeaveraged_value
 
     timeaveraged_value=>find_or_add_timeaveraged_value(timestep, field_name)
 
     call check_thread_status(forthread_mutex_lock(timeaveraged_value%mutex))
     call time_average(timeaveraged_value, instant_values, time)
 
     if ((aint(time*10000000.0)-aint(timeaveraged_value%previous_output_time*10000000.0))/10000000.0 .ge. output_frequency) then
       timeaveraged_value%previous_output_time=time
       allocate(perform_timeaveraged_time_manipulation%values(size(timeaveraged_value%time_averaged_values)))
       perform_timeaveraged_time_manipulation%values=timeaveraged_value%time_averaged_values
       timeaveraged_value%time_averaged_values=0.0_default_precision
       timeaveraged_value%start_time=time
       timeaveraged_value%previous_time=time
       timeaveraged_value%empty_values=.true.
     end if
     call check_thread_status(forthread_mutex_unlock(timeaveraged_value%mutex))

Here is the call graph for this function:

◆ prepare_to_serialise_time_averaged_completed_value()

integer(kind=8) function timeaveraged_time_manipulation_mod::prepare_to_serialise_time_averaged_completed_value ( type(time_averaged_completed_type), intent(inout) time_av_value )

private

Prepares to serialise a time averaged completed value, both determines the storage size and also issue any locks.

Parameters

time_av_value The time averaged completed value to prepare for serialisation

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

Definition at line 214 of file timeaveraged_manipulation.F90.

     type(time_averaged_completed_type), intent(inout) :: time_av_value
 
     call check_thread_status(forthread_mutex_lock(time_av_value%mutex))
 
     prepare_to_serialise_time_averaged_completed_value=(kind(time_av_value%start_time) * 3) + kind(time_av_value%empty_values) + &
          (size(time_av_value%time_averaged_values) * kind(time_av_value%time_averaged_values)) + &
          (kind(prepare_to_serialise_time_averaged_completed_value) * 2) + len(time_av_value%field_name)

Here is the caller graph for this function:

◆ prepare_to_serialise_time_averaged_state()

integer(kind=8) function, public timeaveraged_time_manipulation_mod::prepare_to_serialise_time_averaged_state ( )

Prepares to serialise the time averaged state values. Both determines the storage size required and also issue locks.

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

Definition at line 128 of file timeaveraged_manipulation.F90.

     type(mapentry_type) :: map_entry
     type(iterator_type) :: iterator
     class(*), pointer :: generic
     
     call check_thread_status(forthread_rwlock_rdlock(timeaveraged_value_rw_lock))
     
     prepare_to_serialise_time_averaged_state=kind(prepare_to_serialise_time_averaged_state)
     iterator=c_get_iterator(timeaveraged_values)
     do while (c_has_next(iterator))
        map_entry=c_next_mapentry(iterator)
        generic=>c_get_generic(map_entry)
       if (associated(generic)) then
         select type(generic)
         type is (time_averaged_completed_type)
           prepare_to_serialise_time_averaged_state=prepare_to_serialise_time_averaged_state+&
                prepare_to_serialise_time_averaged_completed_value(generic)+&
                (kind(prepare_to_serialise_time_averaged_state)*2)+len(trim(map_entry%key))
         end select
       end if      
     end do

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serialise_time_averaged_completed_value()

subroutine timeaveraged_time_manipulation_mod::serialise_time_averaged_completed_value	(	type(time_averaged_completed_type), intent(inout)	time_av_value,
		character, dimension(:), intent(inout), allocatable	byte_data,
		integer, intent(inout)	current_data_point
	)

private

Serialises a specific time averaged completed value, releases any locks issued during preparation.

Parameters

time_av_value	The time averaged completed value to serialise
byte_data	Resulting byte data that holds a representation of this
current_data_point	The current write point in the byte data, is updated during call so represents next point on return

Definition at line 228 of file timeaveraged_manipulation.F90.

     type(time_averaged_completed_type), intent(inout) :: time_av_value
     character, dimension(:), allocatable, intent(inout) :: byte_data
     integer, intent(inout) :: current_data_point
 
     integer :: i
 
     current_data_point=pack_scalar_field(byte_data, current_data_point, double_real_value=time_av_value%start_time)
     current_data_point=pack_scalar_field(byte_data, current_data_point, double_real_value=time_av_value%previous_time)
     current_data_point=pack_scalar_field(byte_data, current_data_point, double_real_value=time_av_value%previous_output_time)
     current_data_point=pack_scalar_field(byte_data, current_data_point, logical_value=time_av_value%empty_values)
     current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(time_av_value%field_name)))
     byte_data(current_data_point:current_data_point+len(trim(time_av_value%field_name))-1) = transfer(&
          trim(time_av_value%field_name), byte_data(current_data_point:current_data_point+len(trim(time_av_value%field_name))-1))
     current_data_point=current_data_point+len(trim(time_av_value%field_name))
     current_data_point=pack_scalar_field(byte_data, current_data_point, size(time_av_value%time_averaged_values))
     current_data_point=pack_array_field(byte_data, current_data_point, real_array_1d=time_av_value%time_averaged_values)
     call check_thread_status(forthread_mutex_unlock(time_av_value%mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serialise_time_averaged_state()

subroutine, public timeaveraged_time_manipulation_mod::serialise_time_averaged_state ( character, dimension(:), intent(inout), allocatable byte_data )

Serialises the state of this manipulator so that it can be restarted later on. Releases any locks issue during preparation.

Parameters

byte_data The byte data that represents the serialised state

Definition at line 153 of file timeaveraged_manipulation.F90.

     character, dimension(:), allocatable, intent(inout) :: byte_data
 
     integer :: current_data_point, prev_pt
     type(mapentry_type) :: map_entry
     type(iterator_type) :: iterator
     class(*), pointer :: generic
     
     current_data_point=1
     current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(timeaveraged_values))
 
     iterator=c_get_iterator(timeaveraged_values)
     do while (c_has_next(iterator))
        map_entry=c_next_mapentry(iterator)
        generic=>c_get_generic(map_entry)
       if (associated(generic)) then
         select type(generic)
         type is (time_averaged_completed_type)
           current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(map_entry%key)))
           byte_data(current_data_point:current_data_point+len(trim(map_entry%key))-1) = transfer(trim(map_entry%key), &
                byte_data(current_data_point:current_data_point+len(trim(map_entry%key))-1))
           current_data_point=current_data_point+len(trim(map_entry%key))
 
           prev_pt=current_data_point
           current_data_point=current_data_point+kind(current_data_point)
           call serialise_time_averaged_completed_value(generic, byte_data, current_data_point)          
           prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-kind(current_data_point)) - prev_pt)
         end select
       end if      
     end do
     call check_thread_status(forthread_rwlock_unlock(timeaveraged_value_rw_lock))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ time_average()

subroutine timeaveraged_time_manipulation_mod::time_average	(	type(time_averaged_completed_type), intent(inout)	timeaveraged_value,
		real(kind=default_precision), dimension(:), intent(in)	instant_values,
		real(kind=default_precision), intent(in)	time
	)

private

Does the time averaging itself.

Parameters

timeaveraged_value	The time averaged value to update
instant_values	The instant values to integrate in
time	The model time

Definition at line 96 of file timeaveraged_manipulation.F90.

     type(time_averaged_completed_type), intent(inout) :: timeaveraged_value
     real(kind=DEFAULT_PRECISION), dimension(:), intent(in) :: instant_values
     real(kind=DEFAULT_PRECISION), intent(in) :: time
 
     integer :: i
     real(kind=DEFAULT_PRECISION) :: timeav, timedg, combined_add    
 
     timeav=time-timeaveraged_value%start_time
     timedg=time-timeaveraged_value%previous_time
     combined_add=timeav+timedg
 
     if (.not. allocated(timeaveraged_value%time_averaged_values)) then
       allocate(timeaveraged_value%time_averaged_values(size(instant_values)))
       timeaveraged_value%time_averaged_values=0.0_default_precision
     end if
     
     if (timeaveraged_value%empty_values) then
       timeaveraged_value%empty_values=.false.
       timeaveraged_value%time_averaged_values=instant_values
     else
       do i=1, size(instant_values)
         timeaveraged_value%time_averaged_values(i)=(timeav*timeaveraged_value%time_averaged_values(i)+&
              timedg*instant_values(i)) / combined_add
       end do
     end if
     
     timeaveraged_value%previous_time=time

Here is the caller graph for this function:

◆ unserialise_time_averaged_completed_value()

type(time_averaged_completed_type) function, pointer timeaveraged_time_manipulation_mod::unserialise_time_averaged_completed_value ( character, dimension(:), intent(in) byte_data )

private

Will create a specific time averaged completed value based upon the provided serialised data.

Parameters

byte_data The serialised byte data to read and initialise from

Definition at line 250 of file timeaveraged_manipulation.F90.

     character, dimension(:), intent(in) :: byte_data
     type(time_averaged_completed_type), pointer :: unserialise_time_averaged_completed_value
 
     integer :: current_data_point, i, values_size, byte_size, str_size
 
     allocate(unserialise_time_averaged_completed_value)
     current_data_point=1
     unserialise_time_averaged_completed_value%start_time=unpack_scalar_dp_real_from_bytedata(byte_data, current_data_point)
     unserialise_time_averaged_completed_value%previous_time=unpack_scalar_dp_real_from_bytedata(byte_data, current_data_point)
     unserialise_time_averaged_completed_value%previous_output_time=&
          unpack_scalar_dp_real_from_bytedata(byte_data, current_data_point)
     unserialise_time_averaged_completed_value%empty_values=unpack_scalar_logical_from_bytedata(byte_data, current_data_point)
     str_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
     unserialise_time_averaged_completed_value%field_name=&
          transfer(byte_data(current_data_point:current_data_point+str_size-1), &
          unserialise_time_averaged_completed_value%field_name)
     unserialise_time_averaged_completed_value%field_name(str_size+1:)=" "
     current_data_point=current_data_point+str_size
     values_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
     allocate(unserialise_time_averaged_completed_value%time_averaged_values(values_size))
     byte_size=values_size*kind(unserialise_time_averaged_completed_value%time_averaged_values)
     unserialise_time_averaged_completed_value%time_averaged_values=transfer(byte_data(current_data_point:&
          current_data_point+byte_size-1), unserialise_time_averaged_completed_value%time_averaged_values)
     call check_thread_status(forthread_mutex_init(unserialise_time_averaged_completed_value%mutex, -1))

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unserialise_time_averaged_state()

subroutine, public timeaveraged_time_manipulation_mod::unserialise_time_averaged_state ( character, dimension(:), intent(in) byte_data )

Unserialises some byte data to initialise the state from some previous version.

Parameters

byte_data The byte data to read from and initialise from

Definition at line 188 of file timeaveraged_manipulation.F90.

     character, dimension(:), intent(in) :: byte_data
 
     integer :: current_data_point, number_entries, i, key_size, byte_size
     character(len=STRING_LENGTH) :: value_key
     class(*), pointer :: generic
 
     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
         key_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
         value_key=transfer(byte_data(current_data_point:current_data_point+key_size-1), value_key)
         value_key(key_size+1:)=" "
         current_data_point=current_data_point+key_size
         byte_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
         generic=>unserialise_time_averaged_completed_value(byte_data(current_data_point:current_data_point+byte_size-1))
         call c_put_generic(timeaveraged_values, value_key, generic, .false.)
         current_data_point=current_data_point+byte_size
       end do
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ timeaveraged_value_rw_lock

integer, volatile timeaveraged_time_manipulation_mod::timeaveraged_value_rw_lock

private

Definition at line 31 of file timeaveraged_manipulation.F90.

31 integer, volatile :: timeaveraged_value_rw_lock

◆ timeaveraged_values

type(hashmap_type), volatile timeaveraged_time_manipulation_mod::timeaveraged_values

private

Definition at line 30 of file timeaveraged_manipulation.F90.

30 type(hashmap_type), volatile :: timeaveraged_values

Data Types

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ finalise_time_averaged_manipulation()

◆ find_or_add_timeaveraged_value()

◆ find_timeaveraged_value()

◆ init_time_averaged_manipulation()

◆ is_time_averaged_time_manipulation_ready_to_write()

◆ perform_timeaveraged_time_manipulation()

◆ prepare_to_serialise_time_averaged_completed_value()

◆ prepare_to_serialise_time_averaged_state()

◆ serialise_time_averaged_completed_value()

◆ serialise_time_averaged_state()

◆ time_average()

◆ unserialise_time_averaged_completed_value()

◆ unserialise_time_averaged_state()

Variable Documentation

◆ timeaveraged_value_rw_lock

◆ timeaveraged_values