The arithmetic operator which allows the user to define arithmetic formulas based on fields and constants which are then executed BDMAS style. This works by parsing the text forumula into an execution tree which is walked in order to perform the final result. Building the tree is the potentially expensive aspect of this, so built trees are cached as it is likely that the equation will be run many times. Currently this is expressed in terms of scalars, and it will operate on all elements of the data. More...

Data Types
type	arithmetic_cache_item

type	arithmetic_execution_node

Functions/Subroutines
subroutine, public	initialise_arithmetic_operator ()
	Initialises this operator. More...

subroutine, public	finalise_arithmetic_operator ()
	Finalises this opertor. More...

subroutine, public	perform_arithmetic_operator (io_configuration, field_values, action_attributes, source_monc_location, source_monc, operator_result_values)
	Executes this arithmetic operator by attempting to retrieved the cached equation (and creates one if not found.) If there is no execution tree it then parses the equation into an execution tree and stores it. The stored execution tree is then executed and the real result returned. More...

integer function	get_size_of_data_being_operated_on (cached_equation, field_values)
	Retrieves the number of data elements that this will operate on. It will produce a log error if any variable lengths are inconsistent. More...

recursive real(kind=default_precision) function, dimension(n)	execute_equation_tree (equation_tree, field_values, n)
	Executes an equation tree by doing a post order traversal of the tree. If a node is a terminal then either the variable is looked up for its value or the constant is returned. If a node is a non terminal then the operator is performed on the result value of its left and right subtrees and the value returned. More...

recursive type(arithmetic_execution_node) function, pointer	build_equation_tree (io_configuration, equation)
	Builds the equation tree, this searches for the least significant operator and then splits the equation based upon that. Each sub equation is then passed to recursive calls of this function which return subtrees for these aspects. Some string manipulation is done to remove braces which would otherwise be included in the terminal characters. More...

subroutine	remove_character (raw_string, c)
	Removes all occurances of a character from a string in situ by replacing it with whitespace. More...

integer function	get_location_of_least_significant_operator (equation)
	Given an equation this will retrieve the location of the least significant operator in that equation or 0 if no operator is found (i.e. the string is a terminal.) This takes account of parenthesis. More...

integer function	get_operator_representation (op_char)
	Given a character representation of an operator this returns the internal numeric type representation of it. More...

type(list_type) function, public	arithmetic_operator_get_required_fields (action_attributes)
	Retrieves the list of fields needed by this operator for a specific configuration. More...

type(list_type) function	process_equation_to_get_required_fields (equation)
	Performs text processing on an equation to extract out all the required variable (fields) needed in order to run this equation and get the result. Note this ignores all values which are constants (reals or integers) More...

type(arithmetic_cache_item) function, pointer	find_or_add_equation (equation)
	Locates an existing equation in the cache based upon the textual equation representation or creates a new entry and returns this one. More...

type(arithmetic_cache_item) function, pointer	find_equation (equation, dolock)
	Finds an equation in the cache based upon its textual equation representation or returns null if none is found. More...

Variables
integer, parameter	terminal_op =0

integer, parameter	add_op =1

integer, parameter	minus_op =2

integer, parameter	mul_op =3

integer, parameter	div_op =4

integer, parameter	mod_op =5
	A specific node in the execution tree. More...

type(hashmap_type), volatile	equation_cache

integer, volatile	equation_cache_rwlock

Detailed Description

The arithmetic operator which allows the user to define arithmetic formulas based on fields and constants which are then executed BDMAS style. This works by parsing the text forumula into an execution tree which is walked in order to perform the final result. Building the tree is the potentially expensive aspect of this, so built trees are cached as it is likely that the equation will be run many times. Currently this is expressed in terms of scalars, and it will operate on all elements of the data.

Function/Subroutine Documentation

◆ arithmetic_operator_get_required_fields()

type(list_type) function, public arithmetic_operator_mod::arithmetic_operator_get_required_fields ( type(map_type), intent(inout) action_attributes )

Retrieves the list of fields needed by this operator for a specific configuration.

Parameters

action_attributes The attributes which configure the operator

Returns: A list of required fields before the operator can run

Definition at line 281 of file arithmetic-operator.F90.

     type(map_type), intent(inout) :: action_attributes
 
     character(len=STRING_LENGTH) :: equation
     type(arithmetic_cache_item), pointer :: cached_equation
 
     equation=get_action_attribute_string(action_attributes, "equation")
     cached_equation=>find_or_add_equation(equation)
     if (c_is_empty(cached_equation%required_fields)) then
       cached_equation%required_fields=process_equation_to_get_required_fields(equation)
     end if
     arithmetic_operator_get_required_fields=cached_equation%required_fields

Here is the call graph for this function:

◆ build_equation_tree()

recursive type(arithmetic_execution_node) function, pointer arithmetic_operator_mod::build_equation_tree	(	type(io_configuration_type), intent(inout)	io_configuration,
		character(len=*), intent(in)	equation
	)

private

Builds the equation tree, this searches for the least significant operator and then splits the equation based upon that. Each sub equation is then passed to recursive calls of this function which return subtrees for these aspects. Some string manipulation is done to remove braces which would otherwise be included in the terminal characters.

Parameters

io_configuration	Configuration of the IO server
equation	The equation to represent as a tree

Returns: The equation tree which represents the provided equation

Definition at line 182 of file arithmetic-operator.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     character(len=*), intent(in) :: equation
     type(arithmetic_execution_node), pointer :: equation_tree
 
     integer :: split_point
 
     allocate(equation_tree)
     split_point=get_location_of_least_significant_operator(equation)
     if (split_point .gt. 0) then
       equation_tree%operator=get_operator_representation(equation(split_point:split_point))
       equation_tree%left=>build_equation_tree(io_configuration, equation(:split_point-1))
       equation_tree%right=>build_equation_tree(io_configuration, equation(split_point+1:))
     else
       equation_tree%operator=terminal_op
       equation_tree%variable=equation
       call remove_character(equation_tree%variable, "(")
       call remove_character(equation_tree%variable, ")")
       equation_tree%variable=trim(adjustl(equation_tree%variable))      
       if (equation_tree%variable(1:1) .eq. "{" .and. &
            equation_tree%variable(len_trim(equation_tree%variable):len_trim(equation_tree%variable)) .eq. "}") then
         equation_tree%variable=conv_to_string(options_get_real(&
              io_configuration%options_database, equation_tree%variable(2:len_trim(equation_tree%variable)-1)))    
       end if
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_equation_tree()

recursive real(kind=default_precision) function, dimension(n) arithmetic_operator_mod::execute_equation_tree	(	type(arithmetic_execution_node), intent(inout), pointer	equation_tree,
		type(hashmap_type), intent(inout)	field_values,
		integer, intent(in)	n
	)

private

Executes an equation tree by doing a post order traversal of the tree. If a node is a terminal then either the variable is looked up for its value or the constant is returned. If a node is a non terminal then the operator is performed on the result value of its left and right subtrees and the value returned.

Parameters

equation_tree	The equation tree to traverse
field_values	The variable value key value pair

Returns: A real result from traversing this equation tree

Definition at line 132 of file arithmetic-operator.F90.

     type(arithmetic_execution_node), pointer, intent(inout) :: equation_tree
     type(hashmap_type), intent(inout) :: field_values
     integer, intent(in) :: n
     real(kind=DEFAULT_PRECISION), dimension(n) :: result_value
 
     real(kind=DEFAULT_PRECISION), dimension(n) :: left_value, right_value
     type(data_values_type), pointer :: variable_data
     integer :: i
 
     if (equation_tree%operator==terminal_op) then
       if (conv_is_real(equation_tree%variable)) then
         result_value=conv_to_real(equation_tree%variable)
       else if (conv_is_integer(equation_tree%variable)) then
         result_value=conv_to_real(conv_to_integer(equation_tree%variable))
       else
         variable_data=>get_data_value_by_field_name(field_values, equation_tree%variable)
         if (size(variable_data%values) .lt. n) then
           do i=1, n, size(variable_data%values)
             result_value(i:i+size(variable_data%values)-1)=variable_data%values
           end do
         else
           result_value=variable_data%values
         end if        
       end if
     else
       left_value=execute_equation_tree(equation_tree%left, field_values, n)
       right_value=execute_equation_tree(equation_tree%right, field_values, n)
       if (equation_tree%operator == add_op) then
         result_value(:)=left_value(:)+right_value(:)
       else if (equation_tree%operator == minus_op) then
         result_value(:)=left_value(:)-right_value(:)
       else if (equation_tree%operator == mul_op) then
         result_value(:)=left_value(:)*right_value(:)
       else if (equation_tree%operator == div_op) then
         result_value(:)=left_value(:)/right_value(:)
       else if (equation_tree%operator == mod_op) then
         do i=1, n
           result_value(i)=mod(left_value(i), right_value(i))
         end do
       end if
     end if    

Here is the caller graph for this function:

◆ finalise_arithmetic_operator()

subroutine, public arithmetic_operator_mod::finalise_arithmetic_operator ( )

Finalises this opertor.

Definition at line 54 of file arithmetic-operator.F90.

54 call check_thread_status(forthread_rwlock_destroy(equation_cache_rwlock))

Here is the call graph for this function:

◆ find_equation()

type(arithmetic_cache_item) function, pointer arithmetic_operator_mod::find_equation	(	character(len=*), intent(in)	equation,
		logical, intent(in)	dolock
	)

private

Finds an equation in the cache based upon its textual equation representation or returns null if none is found.

Parameters

equation	Textual equation that we are looking up
dolock	Whether to issue a read lock which accessing the collection

Returns: Cached entry for the equation or null if none is found

Definition at line 357 of file arithmetic-operator.F90.

     character(len=*), intent(in) :: equation
     type(arithmetic_cache_item), pointer :: find_equation
     logical, intent(in) :: dolock
 
     class(*), pointer :: generic
 
     if (dolock) call check_thread_status(forthread_rwlock_rdlock(equation_cache_rwlock))
     generic=>c_get_generic(equation_cache, equation)
     if (dolock) call check_thread_status(forthread_rwlock_unlock(equation_cache_rwlock))
     if (associated(generic)) then
       select type(generic)
         type is (arithmetic_cache_item)
           find_equation=>generic
       end select
     else
       find_equation=>null()
     end if

Here is the caller graph for this function:

◆ find_or_add_equation()

type(arithmetic_cache_item) function, pointer arithmetic_operator_mod::find_or_add_equation ( character(len=*), intent(in) equation )

private

Locates an existing equation in the cache based upon the textual equation representation or creates a new entry and returns this one.

Parameters

equation Textual equation that we are looking up

Returns: Cached entry for the equation

Definition at line 333 of file arithmetic-operator.F90.

     character(len=*), intent(in) :: equation
     type(arithmetic_cache_item), pointer :: find_or_add_equation
 
     class(*), pointer :: generic
 
     find_or_add_equation=>find_equation(equation, .true.)
     if (.not. associated(find_or_add_equation)) then
       call check_thread_status(forthread_rwlock_wrlock(equation_cache_rwlock))
       find_or_add_equation=>find_equation(equation, .false.)
       if (.not. associated(find_or_add_equation)) then
         allocate(find_or_add_equation)
         find_or_add_equation%execution_tree=>null()
         generic=>find_or_add_equation
         call c_put_generic(equation_cache, equation, generic, .false.)
       end if
       call check_thread_status(forthread_rwlock_unlock(equation_cache_rwlock))
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_location_of_least_significant_operator()

integer function arithmetic_operator_mod::get_location_of_least_significant_operator ( character(len=*), intent(in) equation )

private

Given an equation this will retrieve the location of the least significant operator in that equation or 0 if no operator is found (i.e. the string is a terminal.) This takes account of parenthesis.

Definition at line 227 of file arithmetic-operator.F90.

     character(len=*), intent(in) :: equation
 
     integer :: i, eq_len, location_value, op, op_val, brace_level
 
     get_location_of_least_significant_operator=0
     location_value=999999
     brace_level=0
     eq_len=len(trim(equation))
 
     do i=eq_len, 1, -1
       if (equation(i:i) == "(") brace_level=brace_level-1
       if (equation(i:i) == ")") brace_level=brace_level+1
       op=get_operator_representation(equation(i:i))
       if (op .gt. -1) then
         op_val=0
         if (op == div_op) op_val=4
         if (op == mod_op) op_val=4
         if (op == mul_op) op_val=3
         if (op == add_op) op_val=2
         if (op == minus_op) op_val=1
         op_val=op_val + (brace_level*10)
         if (op_val .lt. location_value) then
           location_value=op_val
           get_location_of_least_significant_operator=i
         end if        
       end if      
     end do

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_operator_representation()

integer function arithmetic_operator_mod::get_operator_representation ( character, intent(in) op_char )

private

Given a character representation of an operator this returns the internal numeric type representation of it.

Parameters

op_char The character operator representation

Returns: The numeric internal type of this operator or -1 if none can be found

Definition at line 260 of file arithmetic-operator.F90.

     character, intent(in) :: op_char
 
     if (op_char .eq. "/") then 
       get_operator_representation=div_op
     else if (op_char .eq. "*") then
       get_operator_representation=mul_op
     else if (op_char .eq. "-") then
       get_operator_representation=minus_op
     else if (op_char .eq. "+") then
       get_operator_representation=add_op
     else if (op_char .eq. "%") then
       get_operator_representation=mod_op
     else
       get_operator_representation=-1
     end if

Here is the caller graph for this function:

◆ get_size_of_data_being_operated_on()

integer function arithmetic_operator_mod::get_size_of_data_being_operated_on	(	type(arithmetic_cache_item), intent(inout)	cached_equation,
		type(hashmap_type), intent(inout)	field_values
	)

private

Retrieves the number of data elements that this will operate on. It will produce a log error if any variable lengths are inconsistent.

Parameters

cached_equation	The cached equation information
field_values	The variable value key value pair

Returns: The number of data elements being operated on

Definition at line 92 of file arithmetic-operator.F90.

     type(arithmetic_cache_item), intent(inout) :: cached_equation
     type(hashmap_type), intent(inout) :: field_values
 
     type(data_values_type), pointer :: variable_data
     type(iterator_type) :: iterator
     integer :: temp_size, prev_size
 
     get_size_of_data_being_operated_on=-1
     if (.not. c_is_empty(cached_equation%required_fields)) then
       iterator=c_get_iterator(cached_equation%required_fields)
       do while (c_has_next(iterator))
         variable_data=>get_data_value_by_field_name(field_values, c_next_string(iterator))
 
         if (get_size_of_data_being_operated_on == -1) then
           get_size_of_data_being_operated_on=size(variable_data%values)
         else
           temp_size=size(variable_data%values)
           if (get_size_of_data_being_operated_on .ne. temp_size) then
             if (temp_size .gt. get_size_of_data_being_operated_on) then
               prev_size=get_size_of_data_being_operated_on
               get_size_of_data_being_operated_on=temp_size
               temp_size=prev_size
             end if            
             if (mod(get_size_of_data_being_operated_on, temp_size) .ne. 0) then
               call log_log(log_error, &
                    "Can only perform arithmetic on variables with the same array sizes or sizes that divide evenly")
             end if
           end if
         end if
       end do
     end if

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialise_arithmetic_operator()

subroutine, public arithmetic_operator_mod::initialise_arithmetic_operator ( )

Initialises this operator.

Definition at line 49 of file arithmetic-operator.F90.

49 call check_thread_status(forthread_rwlock_init(equation_cache_rwlock, -1))

Here is the call graph for this function:

◆ perform_arithmetic_operator()

subroutine, public arithmetic_operator_mod::perform_arithmetic_operator	(	type(io_configuration_type), intent(inout)	io_configuration,
		type(hashmap_type), intent(inout)	field_values,
		type(map_type), intent(inout)	action_attributes,
		integer, intent(in)	source_monc_location,
		integer, intent(in)	source_monc,
		real(kind=default_precision), dimension(:), intent(inout), allocatable	operator_result_values
	)

Executes this arithmetic operator by attempting to retrieved the cached equation (and creates one if not found.) If there is no execution tree it then parses the equation into an execution tree and stores it. The stored execution tree is then executed and the real result returned.

Parameters

io_configuration	Configuration of the IO server
field_values	The field values
action_attributes	Attributes associated with the running of this operator

Returns: The resulting value

Definition at line 66 of file arithmetic-operator.F90.

     type(io_configuration_type), intent(inout) :: io_configuration
     type(hashmap_type), intent(inout) :: field_values
     type(map_type), intent(inout) :: action_attributes
     integer, intent(in) :: source_monc_location, source_monc
     real(kind=DEFAULT_PRECISION), dimension(:), allocatable, intent(inout) :: operator_result_values
 
     character(len=STRING_LENGTH) :: equation
     type(arithmetic_cache_item), pointer :: cached_equation
     integer :: data_size
 
     equation=get_action_attribute_string(action_attributes, "equation")
     cached_equation=>find_or_add_equation(equation)
     if (.not. associated(cached_equation%execution_tree)) then
       cached_equation%execution_tree=>build_equation_tree(io_configuration, equation)
     end if
     data_size=get_size_of_data_being_operated_on(cached_equation, field_values)
     allocate(operator_result_values(data_size))
     operator_result_values=execute_equation_tree(cached_equation%execution_tree, field_values, data_size)

Here is the call graph for this function:

◆ process_equation_to_get_required_fields()

type(list_type) function arithmetic_operator_mod::process_equation_to_get_required_fields ( character(len=*), intent(in) equation )

private

Performs text processing on an equation to extract out all the required variable (fields) needed in order to run this equation and get the result. Note this ignores all values which are constants (reals or integers)

Parameters

equation Text equation to extract list of required fields (variables) from

Returns: A list of variables needed by this equation

Definition at line 299 of file arithmetic-operator.F90.

     character(len=*), intent(in) :: equation
 
     character(len=STRING_LENGTH) :: str_to_write
     character :: c
     integer :: i, eq_length, starting_len
 
     eq_length=len(trim(equation))
 
     starting_len=1
     do i=1, eq_length
       c=equation(i:i)
       if (c .eq. "/" .or. c .eq. "*" .or. c .eq. "-" .or. c .eq. "+" .or. c .eq. "(" .or. c .eq. ")" .or. c .eq. "%") then
         if (starting_len .lt. i) then
           str_to_write=equation(starting_len: i-1)
           if (.not. (conv_is_real(str_to_write) .or. conv_is_integer(str_to_write) .or. str_to_write(1:1) .eq. "{")) then
             call c_add_string(process_equation_to_get_required_fields, str_to_write)
           end if
         end if
         starting_len=i+1
       end if      
     end do
     if (starting_len .le. eq_length) then
       str_to_write=equation(starting_len: i-1)
       if (.not. (conv_is_real(str_to_write) .or. conv_is_integer(str_to_write))) then
         call c_add_string(process_equation_to_get_required_fields, str_to_write)
       end if
     end if

Here is the caller graph for this function:

◆ remove_character()

subroutine arithmetic_operator_mod::remove_character	(	character(len=*), intent(inout)	raw_string,
		character, intent(in)	c
	)

private

Removes all occurances of a character from a string in situ by replacing it with whitespace.

Parameters

raw_string	The string to process and remove characters from in place
c	The character to search for and remove (replace by whitespace)

Definition at line 212 of file arithmetic-operator.F90.

     character(len=*), intent(inout) :: raw_string
     character, intent(in) :: c
 
     integer :: brace_index
 
     brace_index=index(raw_string, c)
     do while (brace_index .gt. 0)
       raw_string(brace_index:brace_index)=" "
       brace_index=index(raw_string, c)
     end do

Here is the caller graph for this function:

Variable Documentation

◆ add_op

integer, parameter arithmetic_operator_mod::add_op =1

private

Definition at line 25 of file arithmetic-operator.F90.

◆ div_op

integer, parameter arithmetic_operator_mod::div_op =4

private

Definition at line 25 of file arithmetic-operator.F90.

◆ equation_cache

type(hashmap_type), volatile arithmetic_operator_mod::equation_cache

private

Definition at line 40 of file arithmetic-operator.F90.

40 type(hashmap_type), volatile :: equation_cache

◆ equation_cache_rwlock

integer, volatile arithmetic_operator_mod::equation_cache_rwlock

private

Definition at line 41 of file arithmetic-operator.F90.

41 integer, volatile :: equation_cache_rwlock

◆ minus_op

integer, parameter arithmetic_operator_mod::minus_op =2

private

Definition at line 25 of file arithmetic-operator.F90.

◆ mod_op

integer, parameter arithmetic_operator_mod::mod_op =5

private

A specific node in the execution tree.

Definition at line 25 of file arithmetic-operator.F90.

◆ mul_op

integer, parameter arithmetic_operator_mod::mul_op =3

private

Definition at line 25 of file arithmetic-operator.F90.

◆ terminal_op

integer, parameter arithmetic_operator_mod::terminal_op =0

private

Definition at line 25 of file arithmetic-operator.F90.

25 integer, parameter :: terminal_op=0, add_op=1, minus_op=2, mul_op=3, div_op=4, mod_op=5

Data Types

Functions/Subroutines

Variables

Detailed Description

Function/Subroutine Documentation

◆ arithmetic_operator_get_required_fields()

◆ build_equation_tree()

◆ execute_equation_tree()

◆ finalise_arithmetic_operator()

◆ find_equation()

◆ find_or_add_equation()

◆ get_location_of_least_significant_operator()

◆ get_operator_representation()

◆ get_size_of_data_being_operated_on()

◆ initialise_arithmetic_operator()

◆ perform_arithmetic_operator()

◆ process_equation_to_get_required_fields()

◆ remove_character()

Variable Documentation

◆ add_op

◆ div_op

◆ equation_cache

◆ equation_cache_rwlock

◆ minus_op

◆ mod_op

◆ mul_op

◆ terminal_op