point_zone.f90

Go to the documentation of this file.

! Copyright (c) 2019-2024, 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.
!
! Implements a zone as a subset of GLL points in the mesh
module point_zone
  use stack, only: stack_i4_t
  use num_types, only: rp
  use utils, only: neko_error, nonlinear_index
  use dofmap, only: dofmap_t
  use json_module, only: json_file
  use neko_config, only: neko_bcknd_device
  use device
  use, intrinsic :: iso_c_binding, only: c_ptr, c_null_ptr, c_associated
  implicit none
  private
 
  type, public, abstract :: point_zone_t
     integer, allocatable :: mask(:)
     type(c_ptr) :: mask_d = c_null_ptr
     type(stack_i4_t), private :: scratch
     integer :: size = 0
     logical, private :: finalized = .false.
     character(len=80) :: name
     logical :: invert = .false.
   contains
     procedure, pass(this) :: init_base => point_zone_init_base
     procedure, pass(this) :: free_base => point_zone_free_base
     procedure, pass(this) :: finalize => point_zone_finalize
     procedure, pass(this) :: add => point_zone_add
     procedure, pass(this) :: map => point_zone_map
     procedure(point_zone_init), pass(this), deferred :: init
     procedure(point_zone_free), pass(this), deferred :: free
     procedure(point_zone_criterion), pass(this), deferred :: criterion
  end type point_zone_t
 
  type, public :: point_zone_wrapper_t
     class(point_zone_t), allocatable :: pz
  end type point_zone_wrapper_t
 
  type, public :: point_zone_pointer_t
     class(point_zone_t), pointer :: pz => null()
  end type point_zone_pointer_t
 
  abstract interface
 
     pure function point_zone_criterion(this, x, y, z, j, k, l, e) &
          result(is_inside)
       import :: point_zone_t
       import :: rp
       class(point_zone_t), intent(in) :: this
       real(kind=rp), intent(in) :: x
       real(kind=rp), intent(in) :: y
       real(kind=rp), intent(in) :: z
       integer, intent(in) :: j
       integer, intent(in) :: k
       integer, intent(in) :: l
       integer, intent(in) :: e
       logical :: is_inside
     end function point_zone_criterion
  end interface
 
  abstract interface
 
     subroutine point_zone_init(this, json, size)
       import :: point_zone_t
       import :: json_file
       import :: dofmap_t
       class(point_zone_t), intent(inout) :: this
       type(json_file), intent(inout) :: json
       integer, intent(in) :: size
     end subroutine point_zone_init
  end interface
 
  abstract interface
 
     subroutine point_zone_free(this)
       import :: point_zone_t
       class(point_zone_t), intent(inout) :: this
     end subroutine point_zone_free
  end interface
 
  interface
 
     module subroutine point_zone_factory(object, json, dof)
       class(point_zone_t), allocatable, intent(inout) :: object
       type(json_file), intent(inout) :: json
       type(dofmap_t), intent(inout), optional :: dof
     end subroutine point_zone_factory
  end interface
 
  interface
 
     module subroutine point_zone_allocator(object, type_name)
       class(point_zone_t), allocatable, intent(inout) :: object
       character(len=:), allocatable, intent(in) :: type_name
     end subroutine point_zone_allocator
  end interface
 
  !
  ! Machinery for injecting user-defined types
  !
 
  abstract interface
     subroutine point_zone_allocate(obj)
       import point_zone_t
       class(point_zone_t), allocatable, intent(inout) :: obj
     end subroutine point_zone_allocate
  end interface
 
  interface
 
     module subroutine register_point_zone(type_name, allocator)
       character(len=*), intent(in) :: type_name
       procedure(point_zone_allocate), pointer, intent(in) :: allocator
     end subroutine register_point_zone
  end interface
 
  ! A name-allocator pair for user-defined types. A helper type to define a
  ! registry of custom allocators.
  type allocator_entry
     character(len=20) :: type_name
     procedure(point_zone_allocate), pointer, nopass :: allocator
  end type allocator_entry
 
  type(allocator_entry), allocatable :: point_zone_registry(:)
 
  integer :: point_zone_registry_size = 0
 
  public :: point_zone_factory, point_zone_allocator, register_point_zone, &
       point_zone_allocate
 
contains
 
  subroutine point_zone_init_base(this, size, name, invert)
    class(point_zone_t), intent(inout) :: this
    integer, intent(in), optional :: size
    character(len=*), intent(in) :: name
    logical, intent(in) :: invert
 
    call point_zone_free_base(this)
 
    if (present(size)) then
       call this%scratch%init(size)
    else
       call this%scratch%init()
    end if
 
    this%name = trim(name)
    this%invert = invert
 
  end subroutine point_zone_init_base
 
  subroutine point_zone_free_base(this)
    class(point_zone_t), intent(inout) :: this
    if (allocated(this%mask)) then
       deallocate(this%mask)
    end if
 
    this%finalized = .false.
    this%size = 0
 
    call this%scratch%free()
 
    if (c_associated(this%mask_d)) then
       call device_free(this%mask_d)
    end if
 
  end subroutine point_zone_free_base
 
  subroutine point_zone_finalize(this)
    class(point_zone_t), intent(inout) :: this
    integer, pointer :: tp(:)
    integer :: i
 
    if (.not. this%finalized) then
 
       if (this%scratch%size() .ne. 0) then
 
          allocate(this%mask(this%scratch%size()))
 
          tp => this%scratch%array()
          do i = 1, this%scratch%size()
             this%mask(i) = tp(i)
          end do
 
          this%size = this%scratch%size()
 
          call this%scratch%clear()
 
          if (neko_bcknd_device .eq. 1) then
             call device_map(this%mask, this%mask_d, this%size)
             call device_memcpy(this%mask, this%mask_d, this%size, &
                  host_to_device, sync = .false.)
          end if
 
       else
 
          this%size = 0
          call this%scratch%clear()
 
       end if
 
       this%finalized = .true.
 
    end if
 
  end subroutine point_zone_finalize
 
  subroutine point_zone_add(this, idx)
    class(point_zone_t), intent(inout) :: this
    integer, intent(inout) :: idx
 
    if (this%finalized) then
       call neko_error('Point zone already finalized')
    end if
 
    call this%scratch%push(idx)
 
  end subroutine point_zone_add
 
  subroutine point_zone_map(this, dof)
    class(point_zone_t), intent(inout) :: this
    type(dofmap_t), intent(in) :: dof
 
    integer :: i, ix, iy, iz, ie, nlindex(4), lx, idx
    real(kind=rp) :: x, y, z
 
    lx = dof%Xh%lx
 
    do i = 1, dof%size()
       nlindex = nonlinear_index(i, lx, lx, lx)
       x = dof%x(nlindex(1), nlindex(2), nlindex(3), nlindex(4))
       y = dof%y(nlindex(1), nlindex(2), nlindex(3), nlindex(4))
       z = dof%z(nlindex(1), nlindex(2), nlindex(3), nlindex(4))
       ix = nlindex(1)
       iy = nlindex(2)
       iz = nlindex(3)
       ie = nlindex(4)
 
       if (this%invert .neqv. this%criterion(x, y, z, ix, iy, iz, ie)) then
          idx = i
          call this%add(idx)
       end if
    end do
 
  end subroutine point_zone_map
 
end module point_zone