design.f90

! Copyright (c) 2024-2025, The Neko Authors
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
!   * Redistributions of source code must retain the above copyright
!     notice, this list of conditions and the following disclaimer.
!
!   * Redistributions in binary form must reproduce the above
!     copyright notice, this list of conditions and the following
!     disclaimer in the documentation and/or other materials provided
!     with the distribution.
!
!   * Neither the name of the authors nor the names of its
!     contributors may be used to endorse or promote products derived
!     from this software without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! POSSIBILITY OF SUCH DAMAGE.
 
module design
  use json_module, only: json_file
  use simulation_m, only: simulation_t
  use vector, only: vector_t
  use utils, only: neko_error
  use comm, only: neko_comm
  use mpi_f08, only: mpi_allreduce, mpi_integer, mpi_sum
  implicit none
  private
 
  type, abstract :: design_t
     private
 
     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
     procedure, public, pass(this) :: get_x => design_get_x
     procedure, public, pass(this) :: get_y => design_get_y
     procedure, public, pass(this) :: get_z => design_get_z
 
     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
 
  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
 
     function design_get_values(this) result(values)
       import design_t, vector_t
       class(design_t), intent(in) :: this
       type(vector_t) :: values
     end function 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, n)
    class(design_t), intent(inout) :: this
    integer, intent(in) :: n
    integer :: ierr
 
    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%n = 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
 
  function design_get_x(this) result(values)
    class(design_t), intent(in) :: this
    type(vector_t) :: values
    call neko_error("Design type does not support x retrieval")
  end function design_get_x
 
  function design_get_y(this) result(values)
    class(design_t), intent(in) :: this
    type(vector_t) :: values
    call neko_error("Design type does not support y retrieval")
  end function design_get_y
 
  function design_get_z(this) result(values)
    class(design_t), intent(in) :: this
    type(vector_t) :: values
    call neko_error("Design type does not support z retrieval")
  end function design_get_z
 
end module design