mask.f90

Go to the documentation of this file.

! Copyright (c) 2020-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 mask
  use, intrinsic :: iso_c_binding, only : c_ptr, c_null_ptr, &
       c_size_t
  use neko_config, only : neko_bcknd_device
  use device, only : device_map, device_unmap, device_memcpy, &
       host_to_device, device_to_host, device_to_device
  use device_math, only : device_cadd
  use utils, only : neko_error
 
  implicit none
  private
 
  type, public :: mask_t
     private
     integer :: n_elements = 0 ! Number of elements in the mask
     integer, allocatable :: mask(:) ! The mask array
     type(c_ptr) :: mask_d = c_null_ptr ! Pointer to the device mask array
     logical :: is_set_ = .false. ! Flag to indicate if the mask is set
 
   contains
     ! Public interface for the mask type
     generic, public :: init => init_from_array, init_from_array_device, &
          init_from_mask
     procedure, public, pass(this) :: free => mask_free
 
     procedure, public, pass(this) :: invert_from => invert_mask
     procedure, public, pass(this) :: size => mask_size
     procedure, public, pass(this) :: is_set => mask_is_set
     procedure, public, pass(this) :: get_d => mask_get_d
 
     generic, public :: set => mask_set, mask_set_d
     generic, public :: get => mask_get, mask_get_i
 
     ! Private procedures
     procedure, pass(this) :: allocate => mask_allocate
     procedure, pass(this) :: init_from_array
     procedure, pass(this) :: init_from_array_device
     procedure, pass(this) :: init_from_mask
     procedure, pass(this) :: invert_mask
 
     ! Setters
     procedure, pass(this) :: mask_set
     procedure, pass(this) :: mask_set_d
 
     ! Getters
     procedure, pass(this) :: mask_get
     procedure, pass(this) :: mask_get_i
 
  end type mask_t
 
contains
 
  subroutine mask_allocate(this, n_elements)
    class(mask_t), intent(inout) :: this
    integer, intent(in) :: n_elements
 
    this%is_set_ = .false.
    if (n_elements .eq. this%n_elements) return
    call this%free()
 
    allocate(this%mask(n_elements))
 
    if (neko_bcknd_device .eq. 1) then
       call device_map(this%mask, this%mask_d, n_elements)
    end if
 
    this%n_elements = n_elements
  end subroutine mask_allocate
 
  subroutine mask_free(this)
    class(mask_t), intent(inout) :: this
 
    if (allocated(this%mask)) then
       if (neko_bcknd_device .eq. 1) then
          call device_unmap(this%mask, this%mask_d)
       end if
       deallocate(this%mask)
    end if
 
    this%n_elements = 0
    this%mask_d = c_null_ptr
    this%is_set_ = .false.
  end subroutine mask_free
 
  subroutine init_from_array(this, mask_array, n_elements)
    class(mask_t), intent(inout) :: this
    integer, intent(in) :: n_elements
    integer, intent(in) :: mask_array(n_elements)
 
    call this%allocate(n_elements)
 
    this%mask = mask_array
    if (neko_bcknd_device .eq. 1) then
       call device_memcpy(this%mask, this%mask_d, this%n_elements, &
            host_to_device, sync = .true.)
       call device_cadd(this%mask_d, -1, this%n_elements)
    end if
 
    this%is_set_ = .true.
  end subroutine init_from_array
 
  subroutine init_from_array_device(this, mask_array_d, n_elements)
    class(mask_t), intent(inout) :: this
    integer, intent(in) :: n_elements
    type(c_ptr), intent(inout):: mask_array_d
    integer(kind=c_size_t) :: size_c
 
    size_c = n_elements * int(4, c_size_t)
 
    call this%allocate(n_elements)
    call device_memcpy(this%mask_d, mask_array_d, size_c, &
         device_to_device, sync = .false.)
    call device_memcpy(this%mask, mask_array_d, n_elements, &
         device_to_host, sync = .true.)
    this%mask = this%mask - 1 ! Adjust for 0-based indexing
 
    this%is_set_ = .true.
  end subroutine init_from_array_device
 
  subroutine init_from_mask(this, other)
    class(mask_t), intent(inout) :: this
    class(mask_t), intent(inout) :: other
    integer(kind=c_size_t) :: size_c
 
    call this%allocate(other%n_elements)
 
    size_c = other%n_elements * int(4, c_size_t)
 
    this%mask = other%mask
    if (neko_bcknd_device .eq. 1) then
       call device_memcpy(this%mask_d, other%mask_d, size_c, &
            device_to_device, sync = .true.)
    end if
 
    this%n_elements = other%n_elements
    this%is_set_ = other%is_set_
  end subroutine init_from_mask
 
  subroutine invert_mask(this, other, total_elements)
    class(mask_t), intent(inout) :: this
    class(mask_t), intent(in) :: other
    integer, intent(in) :: total_elements
 
    logical, allocatable :: found(:)
    integer, allocatable :: new_mask(:)
    integer :: i, j, k, v, new_size
 
    allocate(found(total_elements))
    found = .false.
 
    ! mark present
    do i = 1, other%size()
       v = other%mask(i)
       if (v >= 1 .and. v <= total_elements) found(v) = .true.
    end do
 
    ! count complement
    new_size = 0
    do j = 1, total_elements
       if (.not. found(j)) new_size = new_size + 1
    end do
 
    allocate(new_mask(new_size))
 
    ! fill complement
    k = 1
    do j = 1, total_elements
       if (.not. found(j)) then
          new_mask(k) = j
          k = k + 1
       end if
    end do
 
    call this%init_from_array(new_mask, new_size)
  end subroutine invert_mask
 
  pure function mask_size(this) result(n_elements)
    class(mask_t), intent(in) :: this
    integer :: n_elements
 
    n_elements = this%n_elements
  end function mask_size
 
  pure function mask_is_set(this) result(is_set)
    class(mask_t), intent(in) :: this
    logical :: is_set
 
    is_set = this%is_set_
  end function mask_is_set
 
  function mask_get(this) result(mask_array)
    class(mask_t), intent(in), target :: this
    integer, pointer :: mask_array(:)
 
    if (.not. this%is_set()) call neko_error("Mask is not set.")
 
    mask_array => this%mask
  end function mask_get
 
  function mask_get_i(this, index) result(mask_value)
    class(mask_t), intent(in), target :: this
    integer, intent(in) :: index
    integer :: mask_value
 
    if (.not. this%is_set()) call neko_error("Mask is not set.")
    if (index < 1 .or. index > this%n_elements) then
       call neko_error("Index out of bounds in mask_get_i")
    end if
 
    mask_value = this%mask(index)
  end function mask_get_i
 
  function mask_get_d(this) result(mask_array_d)
    class(mask_t), intent(in) :: this
    type(c_ptr) :: mask_array_d
 
    if (.not. this%is_set()) call neko_error("Mask is not set.")
 
    mask_array_d = this%mask_d
  end function mask_get_d
 
  subroutine mask_set(this, mask_array, n_elements)
    class(mask_t), intent(inout) :: this
    integer, intent(in) :: n_elements
    integer, intent(in) :: mask_array(n_elements)
 
    call this%allocate(n_elements)
 
    this%mask = mask_array
    if (neko_bcknd_device .eq. 1) then
       call device_memcpy(this%mask, this%mask_d, n_elements, &
            host_to_device, sync = .true.)
       call device_cadd(this%mask_d, -1, n_elements)
    end if
 
    this%is_set_ = .true.
  end subroutine mask_set
 
  subroutine mask_set_d(this, mask_array_d, n_elements)
    class(mask_t), intent(inout) :: this
    integer, intent(in) :: n_elements
    type(c_ptr), intent(inout) :: mask_array_d
    integer(kind=c_size_t) :: size_c
 
    call this%allocate(n_elements)
    size_c = n_elements * int(4, c_size_t)
 
    call device_memcpy(this%mask_d, mask_array_d, size_c, &
         device_to_device, sync = .false.)
    call device_memcpy(this%mask, mask_array_d, n_elements, &
         device_to_host, sync = .true.)
    this%mask = this%mask - 1 ! Adjust for 0-based indexing
 
    this%is_set_ = .true.
  end subroutine mask_set_d
 
 
end module mask