timeaveraged_time_manipulation_mod Module Reference

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 45 of file timeaveraged_manipulation.F90.

    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 280 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 312 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 39 of file timeaveraged_manipulation.F90.

    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 49 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 64 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 213 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 127 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 227 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 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 152 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 95 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 249 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 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 187 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.

  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.

  type(hashmap_type), volatile :: timeaveraged_values