design.f90

Go to the documentation of this file.

 
 
module design
  use json_module, only: json_file
  use simulation_m, only: simulation_t
  use num_types, only: rp
  use vector, only: vector_t
  use utils, only: neko_error
  use point_zone, only: point_zone_t
  use comm, only: neko_comm
  use mpi_f08, only: mpi_allreduce, mpi_integer, mpi_sum
  implicit none
  private
 
  type, abstract :: design_t
     private
     character(len=:), allocatable :: name
 
     integer :: n = 0
     integer :: n_global = 0
 
   contains
 
     ! ----------------------------------------------------------------------- !
     ! Interfaces
 
     procedure, pass(this) :: init_from_json_sim => design_init_from_json_sim
 
     procedure, pass(this) :: init_from_json => design_init_from_json
 
     procedure(design_free), public, pass(this), deferred :: free
 
     procedure(design_get_values), public, pass(this), deferred :: get_values
     generic :: get_x => design_get_x
     generic :: x => design_get_x_i
     generic :: get_y => design_get_y
     generic :: y => design_get_y_i
     generic :: get_z => design_get_z
     generic :: z => design_get_z_i
 
     procedure(design_update_design), public, pass(this), deferred :: &
          update_design
 
     procedure(design_map_forward), public, pass(this), deferred :: &
          map_forward
     procedure(design_map_backward), public, pass(this), deferred :: &
          map_backward
     procedure(design_write), public, pass(this), deferred :: write
 
     ! ----------------------------------------------------------------------- !
     ! Methods
 
     procedure, pass(this) :: init_base => design_init_base
     procedure, pass(this) :: free_base => design_free_base
     procedure, public, pass(this) :: size => design_size
     procedure, public, pass(this) :: size_global => design_size_global
 
     procedure, pass(this) :: design_get_x
     procedure, pass(this) :: design_get_x_i
     procedure, pass(this) :: design_get_y
     procedure, pass(this) :: design_get_y_i
     procedure, pass(this) :: design_get_z
     procedure, pass(this) :: design_get_z_i
  end type design_t
 
  ! ========================================================================== !
  ! Interface for the factory function
 
  interface design_factory
     module subroutine design_factory(object, parameters, simulation)
       class(design_t), allocatable, intent(inout) :: object
       type(json_file), intent(inout) :: parameters
       type(simulation_t), intent(inout), optional :: simulation
     end subroutine design_factory
  end interface design_factory
 
 
  ! ========================================================================== !
  ! Public interface for the deferred methods
 
  abstract interface
     subroutine design_free(this)
       import design_t
       class(design_t), intent(inout) :: this
     end subroutine design_free
 
     subroutine design_get_values(this, values)
       import design_t, vector_t
       class(design_t), intent(in) :: this
       type(vector_t), intent(inout) :: values
     end subroutine design_get_values
 
     subroutine design_update_design(this, values)
       import design_t, vector_t
       class(design_t), intent(inout) :: this
       type(vector_t), intent(inout) :: values
     end subroutine design_update_design
 
     subroutine design_map_forward(this)
       import design_t
       class(design_t), intent(inout) :: this
     end subroutine design_map_forward
 
     subroutine design_map_backward(this, sensitivity)
       import design_t, vector_t
       class(design_t), intent(inout) :: this
       type(vector_t), intent(in) :: sensitivity
     end subroutine design_map_backward
 
     subroutine design_write(this, idx)
       import design_t
       class(design_t), intent(inout) :: this
       integer, intent(in) :: idx
     end subroutine design_write
  end interface
 
  public :: design_t, design_factory
contains
 
  subroutine design_init_from_json(this, parameters)
    class(design_t), intent(inout) :: this
    type(json_file), intent(inout) :: parameters
 
    call neko_error("Design type does not support initialization " // &
         "without simulation")
  end subroutine design_init_from_json
 
  subroutine design_init_from_json_sim(this, parameters, simulation)
    class(design_t), intent(inout) :: this
    type(json_file), intent(inout) :: parameters
    type(simulation_t), intent(inout) :: simulation
 
    call neko_error("Design type does not support initialization " // &
         "with simulation")
  end subroutine design_init_from_json_sim
 
  subroutine design_init_base(this, name, n)
    class(design_t), intent(inout) :: this
    character(len=*), intent(in) :: name
    integer, intent(in) :: n
    integer :: ierr
 
    this%name = name
    this%n = n
    call mpi_allreduce(n, this%n_global, 1, mpi_integer, mpi_sum, &
         neko_comm, ierr)
  end subroutine design_init_base
 
  subroutine design_free_base(this)
    class(design_t), intent(inout) :: this
    this%name = ""
    this%n = 0
    this%n_global = 0
  end subroutine design_free_base
 
  pure function design_size(this) result(n)
    class(design_t), intent(in) :: this
    integer :: n
    n = this%n
  end function design_size
 
  pure function design_size_global(this) result(n)
    class(design_t), intent(in) :: this
    integer :: n
    n = this%n_global
  end function design_size_global
 
  subroutine design_get_x(this, x)
    class(design_t), intent(in) :: this
    type(vector_t), intent(inout) :: x
    call neko_error("Design type does not support x retrieval")
  end subroutine design_get_x
 
  function design_get_x_i(this, i) result(x_i)
    class(design_t), intent(in) :: this
    integer, intent(in) :: i
    real(kind=rp) :: x_i
    x_i = -huge(x_i)
    call neko_error("Design type does not support x retrieval")
  end function design_get_x_i
 
  subroutine design_get_y(this, y)
    class(design_t), intent(in) :: this
    type(vector_t), intent(inout) :: y
    call neko_error("Design type does not support y retrieval")
  end subroutine design_get_y
 
  function design_get_y_i(this, i) result(y_i)
    class(design_t), intent(in) :: this
    integer, intent(in) :: i
    real(kind=rp) :: y_i
    y_i = -huge(y_i)
    call neko_error("Design type does not support y retrieval")
  end function design_get_y_i
 
  subroutine design_get_z(this, z)
    class(design_t), intent(in) :: this
    type(vector_t), intent(inout) :: z
    call neko_error("Design type does not support z retrieval")
  end subroutine design_get_z
 
  function design_get_z_i(this, i) result(z_i)
    class(design_t), intent(in) :: this
    integer, intent(in) :: i
    real(kind=rp) :: z_i
    z_i = -huge(z_i)
    call neko_error("Design type does not support z retrieval")
  end function design_get_z_i
 
end module design