base_functional.f90

Go to the documentation of this file.

 
 
module base_functional
  use design, only: design_t
  use json_module, only: json_file
  use json_utils, only: json_get
  use num_types, only: rp
  use point_zone, only: point_zone_t
  use simulation_m, only: simulation_t
  use time_state, only: time_state_t
  use vector, only: vector_t
  use utils, only: neko_error
  use vector_math, only: vector_copy, vector_add2s1
  implicit none
  private
 
  type, abstract, public :: base_functional_t
 
     real(kind=rp) :: value = 0.0_rp
     real(kind=rp) :: value_old = 0.0_rp
     type(vector_t) :: sensitivity
     type(vector_t) :: sensitivity_old
     character(len=25) :: name = ""
     logical :: has_mask = .false.
     class(point_zone_t), pointer :: mask => null()
     real(kind=rp) :: start_time = 0.0_rp
     real(kind=rp) :: end_time = huge(0.0_rp)
 
   contains
 
     ! ----------------------------------------------------------------------- !
     ! Derived class interfaces
 
     generic :: init => init_json, init_json_sim
 
     procedure, pass(this) :: init_json => functional_init_json
     procedure, pass(this) :: init_json_sim => functional_init_json_sim
     procedure(functional_free), pass(this), deferred :: free
 
     procedure(functional_update_value), pass(this), deferred :: update_value
     procedure(functional_update_sensitivity), pass(this), deferred :: &
          update_sensitivity
 
     procedure, pass(this) :: get_value => functional_get_value
     procedure, pass(this) :: get_sensitivity => functional_get_sensitivity
     procedure, pass(this) :: get_log_size => functional_get_log_size
     procedure, pass(this) :: get_log_headers => functional_get_log_headers
     procedure, pass(this) :: get_log_values => functional_get_log_values
     procedure, pass(this) :: reset_value => functional_reset_value
     procedure, pass(this) :: reset_sensitivity => functional_reset_sensitivity
     procedure, pass(this) :: accumulate_value => functional_accumulate_value
     procedure, pass(this) :: accumulate_sensitivity => &
          functional_accumulate_sensitivity
 
  end type base_functional_t
 
  ! -------------------------------------------------------------------------- !
  ! Interface specifications for the derived types, these are the constructors
  ! for the different types of objective functions.
 
  abstract interface
 
     subroutine functional_free(this)
       import base_functional_t
       class(base_functional_t), intent(inout) :: this
     end subroutine functional_free
 
     subroutine functional_update_value(this, design)
       import base_functional_t, design_t
       class(base_functional_t), intent(inout) :: this
       class(design_t), intent(in) :: design
     end subroutine functional_update_value
 
     subroutine functional_update_sensitivity(this, design)
       import base_functional_t, design_t
       class(base_functional_t), intent(inout) :: this
       class(design_t), intent(in) :: design
     end subroutine functional_update_sensitivity
 
  end interface
 
contains
 
  subroutine functional_init_json(this, json, design)
    class(base_functional_t), intent(inout) :: this
    type(json_file), intent(inout) :: json
    class(design_t), intent(in) :: design
    character(len=:), allocatable :: type
 
    call json_get(json, 'type', type)
    call neko_error("Functional type: '" // type // &
         "' does not support initialization without simulation")
  end subroutine functional_init_json
 
  subroutine functional_init_json_sim(this, json, design, simulation)
    class(base_functional_t), intent(inout) :: this
    type(json_file), intent(inout) :: json
    class(design_t), intent(in) :: design
    type(simulation_t), target, intent(inout) :: simulation
    character(len=:), allocatable :: type
 
    call json_get(json, 'type', type)
    call neko_error("Functional type: '" // type // &
         "' does not support initialization with simulation")
  end subroutine functional_init_json_sim
 
  function functional_get_value(this) result(v)
    class(base_functional_t), intent(in) :: this
    real(kind=rp) :: v
 
    v = this%value
  end function functional_get_value
 
  subroutine functional_get_sensitivity(this, sensitivity)
    class(base_functional_t), intent(in) :: this
    type(vector_t), intent(inout) :: sensitivity
 
    sensitivity = this%sensitivity
  end subroutine functional_get_sensitivity
 
  function functional_get_log_size(this) result(n)
    class(base_functional_t), intent(in) :: this
    integer :: n
 
    n = 1
  end function functional_get_log_size
 
  subroutine functional_get_log_headers(this, headers)
    class(base_functional_t), intent(in) :: this
    character(len=*), intent(out) :: headers(:)
 
    if (size(headers) .eq. 0) return
    headers(1) = trim(this%name)
  end subroutine functional_get_log_headers
 
  subroutine functional_get_log_values(this, values)
    class(base_functional_t), intent(in) :: this
    real(kind=rp), intent(out) :: values(:)
 
    if (size(values) .eq. 0) return
    values(1) = this%value
  end subroutine functional_get_log_values
 
  subroutine functional_reset_value(this)
    class(base_functional_t), intent(inout) :: this
 
    this%value = 0.0_rp
  end subroutine functional_reset_value
 
  subroutine functional_reset_sensitivity(this)
    class(base_functional_t), intent(inout) :: this
 
    this%sensitivity = 0.0_rp
  end subroutine functional_reset_sensitivity
 
  subroutine functional_accumulate_value(this, design, time)
    class(base_functional_t), intent(inout) :: this
    class(design_t), intent(in) :: design
    type(time_state_t), intent(in) :: time
 
    if (time%t .lt. this%start_time .or. time%t .gt. this%end_time) return
 
    this%value_old = this%value
    call this%update_value(design)
 
    ! could potentially use higher order trapezoidal/Simpson etc, but this
    ! should suffice
    this%value = this%value_old + this%value * time%dt
  end subroutine functional_accumulate_value
 
  subroutine functional_accumulate_sensitivity(this, design, time)
    class(base_functional_t), intent(inout) :: this
    class(design_t), intent(in) :: design
    type(time_state_t), intent(in) :: time
 
    if (time%t .lt. this%start_time .or. time%t .gt. this%end_time) return
 
    call vector_copy(this%sensitivity_old, this%sensitivity)
    call this%update_sensitivity(design)
 
    ! could potentially use higher order trapezoidal/Simpson etc, but this
    ! should suffice
    call vector_add2s1(this%sensitivity, this%sensitivity_old, time%dt)
  end subroutine functional_accumulate_sensitivity
end module base_functional