field_math.f90

Go to the documentation of this file.

! Copyright (c) 2008-2020, UCHICAGO ARGONNE, LLC.
!
! The UChicago Argonne, LLC as Operator of Argonne National
! Laboratory holds copyright in the Software. The copyright holder
! reserves all rights except those expressly granted to licensees,
! and U.S. Government license rights.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
! 1. Redistributions of source code must retain the above copyright
! notice, this list of conditions and the disclaimer below.
!
! 2. Redistributions in binary form must reproduce the above copyright
! notice, this list of conditions and the disclaimer (as noted below)
! in the documentation and/or other materials provided with the
! distribution.
!
! 3. Neither the name of ANL 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
! UCHICAGO ARGONNE, LLC, THE U.S. DEPARTMENT OF
! ENERGY 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.
!
! Additional BSD Notice
! ---------------------
! 1. This notice is required to be provided under our contract with
! the U.S. Department of Energy (DOE). This work was produced at
! Argonne National Laboratory under Contract
! No. DE-AC02-06CH11357 with the DOE.
!
! 2. Neither the United States Government nor UCHICAGO ARGONNE,
! LLC nor any of their employees, makes any warranty,
! express or implied, or assumes any liability or responsibility for the
! accuracy, completeness, or usefulness of any information, apparatus,
! product, or process disclosed, or represents that its use would not
! infringe privately-owned rights.
!
! 3. Also, reference herein to any specific commercial products, process,
! or services by trade name, trademark, manufacturer or otherwise does
! not necessarily constitute or imply its endorsement, recommendation,
! or favoring by the United States Government or UCHICAGO ARGONNE LLC.
! The views and opinions of authors expressed
! herein do not necessarily state or reflect those of the United States
! Government or UCHICAGO ARGONNE, LLC, and shall
! not be used for advertising or product endorsement purposes.
!
module field_math
  use neko_config, only : neko_bcknd_device
  use num_types, only : rp
  use field, only : field_t
  use mask, only : mask_t
  use device, only : device_get_ptr
  use math, only : rzero, rone, copy, cmult, cadd, cfill, invcol1, vdot3, &
       add3, add4, sub2, sub3, add2s1, add2s2, addsqr2s2, cmult2, invcol2, &
       col2, col3, subcol3, add3s2, addcol3, addcol4, addcol3s2, glsum, &
       glmax, glmin, &
       glsc2, glsc3, masked_gather_copy, masked_gather_copy_0, &
       masked_scatter_copy_0, glsubnorm, invcol3, pwmax2, pwmax3, cpwmax2, &
       cpwmax3, pwmin2, pwmin3, cpwmin2, cpwmin3, add2
  use device_math, only : device_rzero, device_rone, device_copy, &
       device_cadd, device_cfill, device_invcol1, device_vdot3, device_add2, &
       device_add3, device_add4, device_sub2, device_sub3, device_add2s1, &
       device_add2s2, device_addsqr2s2, device_cmult2, device_invcol2, &
       device_col2, device_col3, device_subcol3, device_add3s2, &
       device_addcol3, device_addcol4, device_addcol3s2, device_glsum, &
       device_glsc2, &
       device_glmax, device_glmin, device_cmult, &
       device_glsc3, device_masked_gather_copy_0, device_masked_scatter_copy_0,&
       device_masked_gather_copy_aligned, &
       device_glsubnorm, device_invcol3, device_pwmax2, device_pwmax3, &
       device_cpwmax2, device_cpwmax3, device_pwmin2, device_pwmin3, &
       device_cpwmin2, device_cpwmin3
  use, intrinsic :: iso_c_binding, only : c_ptr
  implicit none
  private
 
  public :: field_rzero, field_rone, field_copy, field_cmult, &
       field_cadd, field_cfill, field_invcol1, field_invcol3, field_vdot3, &
       field_add2, field_sub2, field_sub3, field_add2s1, &
       field_add2s2, field_addsqr2s2, field_cmult2, &
       field_invcol2, field_col2, field_col3, field_subcol3, &
       field_add3s2, field_addcol3, field_addcol4, field_addcol3s2, &
       field_glsum, &
       field_glmax, field_glmin, &
       field_glsc2, field_glsc3, field_add3, field_masked_gather_copy_0, &
       field_masked_gather_copy, &
       field_masked_scatter_copy_0, field_glsubnorm, field_pwmax2, &
       field_pwmax3, field_cpwmax2, field_cpwmax3, field_pwmin2, &
       field_pwmin3, field_cpwmin2, field_cpwmin3
 
contains
 
  subroutine field_rzero(a, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_rzero(a%x_d, size)
    else
       call rzero(a%x, size)
    end if
  end subroutine field_rzero
 
  subroutine field_rone(a, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_rone(a%x_d, size)
    else
       call rone(a%x, size)
    end if
  end subroutine field_rone
 
  subroutine field_copy(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: b
    type(field_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_copy(a%x_d, b%x_d, size)
    else
       call copy(a%x, b%x, size)
    end if
  end subroutine field_copy
 
  subroutine field_cmult(a, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    real(kind=rp), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cmult(a%x_d, c, size)
    else
       call cmult(a%x, c, size)
    end if
  end subroutine field_cmult
 
  subroutine field_cadd(a, s, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    real(kind=rp), intent(in) :: s
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cadd(a%x_d, s, size)
    else
       call cadd(a%x, s, size)
    end if
  end subroutine field_cadd
 
  subroutine field_cfill(a, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    real(kind=rp), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cfill(a%x_d, c, size)
    else
       call cfill(a%x, c, size)
    end if
  end subroutine field_cfill
 
  subroutine field_invcol1(a, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_invcol1(a%x_d, size)
    else
       call invcol1(a%x, size)
    end if
 
  end subroutine field_invcol1
 
  subroutine field_invcol3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_invcol3(a%x_d, b%x_d, c%x_d, size)
    else
       call invcol3(a%x, b%x, c%x, size)
    end if
 
  end subroutine field_invcol3
 
  subroutine field_vdot3(dot, u1, u2, u3, v1, v2, v3, n)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: u1, u2, u3
    type(field_t), intent(in) :: v1, v2, v3
    type(field_t), intent(inout) :: dot
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = dot%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_vdot3(dot%x_d, &
            u1%x_d, u2%x_d, u3%x_d, &
            v1%x_d, v2%x_d, v3%x_d, &
            size)
    else
       call vdot3(dot%x, &
            u1%x, u2%x, u3%x, &
            v1%x, v2%x, v3%x, &
            size)
    end if
 
  end subroutine field_vdot3
 
  subroutine field_add2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add2(a%x_d, b%x_d, size)
    else
       call add2(a%x, b%x, size)
    end if
 
  end subroutine field_add2
 
  subroutine field_add3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b, c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add3(a%x_d, b%x_d, c%x_d, size)
    else
       call add3(a%x, b%x, c%x, size)
    end if
 
  end subroutine field_add3
 
  subroutine field_add4(a, b, c, d, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b, c, d
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add4(a%x_d, b%x_d, c%x_d, d%x_d, size)
    else
       call add4(a%x, b%x, c%x, d%x, size)
    end if
 
  end subroutine field_add4
 
  subroutine field_sub2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(inout) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_sub2(a%x_d, b%x_d, size)
    else
       call sub2(a%x, b%x, size)
    end if
 
  end subroutine field_sub2
 
  subroutine field_sub3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_sub3(a%x_d, b%x_d, c%x_d, size)
    else
       call sub3(a%x, b%x, c%x, size)
    end if
 
  end subroutine field_sub3
 
 
  subroutine field_add2s1(a, b, c1, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(inout) :: b
    real(kind=rp), intent(in) :: c1
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add2s1(a%x_d, b%x_d, c1, size)
    else
       call add2s1(a%x, b%x, c1, size)
    end if
 
  end subroutine field_add2s1
 
  subroutine field_add2s2(a, b, c1, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(inout) :: b
    real(kind=rp), intent(in) :: c1
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add2s2(a%x_d, b%x_d, c1, size)
    else
       call add2s2(a%x, b%x, c1, size)
    end if
 
  end subroutine field_add2s2
 
  subroutine field_addsqr2s2(a, b, c1, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    real(kind=rp), intent(in) :: c1
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addsqr2s2(a%x_d, b%x_d, c1, size)
    else
       call addsqr2s2(a%x, b%x, c1, size)
    end if
 
  end subroutine field_addsqr2s2
 
  subroutine field_cmult2(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    real(kind=rp), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cmult2(a%x_d, b%x_d, c, size)
    else
       call cmult2(a%x, b%x, c, size)
    end if
 
  end subroutine field_cmult2
 
  subroutine field_invcol2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_invcol2(a%x_d, b%x_d, size)
    else
       call invcol2(a%x, b%x, size)
    end if
 
  end subroutine field_invcol2
 
 
  subroutine field_col2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_col2(a%x_d, b%x_d, size)
    else
       call col2(a%x, b%x, size)
    end if
 
  end subroutine field_col2
 
  subroutine field_col3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_col3(a%x_d, b%x_d, c%x_d, size)
    else
       call col3(a%x, b%x, c%x, size)
    end if
 
  end subroutine field_col3
 
  subroutine field_subcol3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_subcol3(a%x_d, b%x_d, c%x_d, size)
    else
       call subcol3(a%x, b%x, c%x, size)
    end if
 
  end subroutine field_subcol3
 
  subroutine field_add3s2(a, b, c, c1, c2, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    real(kind=rp), intent(in) :: c1, c2
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add3s2(a%x_d, b%x_d, c%x_d, c1, c2, size)
    else
       call add3s2(a%x, b%x, c%x, c1, c2, size)
    end if
 
  end subroutine field_add3s2
 
  subroutine field_addcol3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addcol3(a%x_d, b%x_d, c%x_d, size)
    else
       call addcol3(a%x, b%x, c%x, size)
    end if
 
  end subroutine field_addcol3
 
  subroutine field_addcol3s2(a, b, c, s, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    real(kind=rp), intent(in) :: s
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addcol3s2(a%x_d, b%x_d, c%x_d, s, size)
    else
       call addcol3s2(a%x, b%x, c%x, s, size)
    end if
 
  end subroutine field_addcol3s2
 
  subroutine field_addcol4(a, b, c, d, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    type(field_t), intent(in) :: d
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addcol4(a%x_d, b%x_d, c%x_d, d%x_d, size)
    else
       call addcol4(a%x, b%x, c%x, d%x, size)
    end if
 
  end subroutine field_addcol4
 
  function field_glsum(a, n) result(sum)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: a
    real(kind=rp) :: sum
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       sum = device_glsum(a%x_d, size)
    else
       sum = glsum(a%x, size)
    end if
 
  end function field_glsum
 
  function field_glmax(a, n) result(val)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: a
    real(kind=rp) :: val
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       val = device_glmax(a%x_d, size)
    else
       val = glmax(a%x, size)
    end if
 
  end function field_glmax
 
  function field_glmin(a, n) result(val)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: a
    real(kind=rp) :: val
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       val = device_glmin(a%x_d, size)
    else
       val = glmin(a%x, size)
    end if
 
  end function field_glmin
 
  function field_glsc2(a, b, n) result(norm)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: a, b
    real(kind=rp) :: norm
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       norm = device_glsc2(a%x_d, b%x_d, size)
    else
       norm = glsc2(a%x, b%x, size)
    end if
 
  end function field_glsc2
 
  function field_glsc3(a, b, c, n) result(norm)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: a, b, c
    real(kind=rp) :: norm
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       norm = device_glsc3(a%x_d, b%x_d, c%x_d, size)
    else
       norm = glsc3(a%x, b%x, c%x, size)
    end if
 
  end function field_glsc3
 
  function field_glsubnorm(a, b, n) result(norm)
    integer, intent(in), optional :: n
    type(field_t), intent(in) :: a, b
    real(kind=rp) :: norm
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       norm = device_glsubnorm(a%x_d, b%x_d, size)
    else
       norm = glsubnorm(a%x, b%x, size)
    end if
 
  end function field_glsubnorm
 
  subroutine field_masked_gather_copy_0(a, b, mask, n, n_mask)
    integer, intent(in) :: n, n_mask
    real(kind=rp), dimension(n_mask), intent(inout) :: a
    type(field_t) :: b
    integer, dimension(0:n_mask) :: mask
    type(c_ptr) :: mask_d, a_d
 
    if (neko_bcknd_device .eq. 1) then
       mask_d = device_get_ptr(mask)
       a_d = device_get_ptr(a)
       call device_masked_gather_copy_0(a_d, b%x_d, mask_d, n, n_mask)
    else
       call masked_gather_copy_0(a, b%x, mask, n, n_mask)
    end if
 
  end subroutine field_masked_gather_copy_0
 
  subroutine field_masked_gather_copy(a, b, mask, n)
    type(field_t), intent(inout) :: a
    real(kind=rp), dimension(:), intent(inout) :: b
    type(mask_t), intent(in) :: mask
    integer, intent(in) :: n
    type(c_ptr) :: mask_d, b_d
 
    if (neko_bcknd_device .eq. 1) then
       mask_d = mask%get_d()
       b_d = device_get_ptr(b)
       call device_masked_gather_copy_aligned(a%x_d, b_d, mask_d, n, &
            mask%size())
    else
       call masked_gather_copy(a%x, b, mask%get(), n, mask%size())
    end if
 
  end subroutine field_masked_gather_copy
 
  subroutine field_masked_scatter_copy_0(a, b, mask, n, n_mask)
    integer, intent(in) :: n, n_mask
    real(kind=rp), dimension(n_mask), intent(in) :: b
    type(field_t), intent(inout) :: a
    integer, dimension(0:n_mask) :: mask
    type(c_ptr) :: mask_d, b_d
 
    if (neko_bcknd_device .eq. 1) then
       mask_d = device_get_ptr(mask)
       b_d = device_get_ptr(b)
       call device_masked_scatter_copy_0(a%x_d, b_d, mask_d, n, n_mask)
    else
       call masked_scatter_copy_0(a%x, b, mask, n, n_mask)
    end if
 
  end subroutine field_masked_scatter_copy_0
 
  subroutine field_pwmax2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_pwmax2(a%x_d, b%x_d, size)
    else
       call pwmax2(a%x, b%x, size)
    end if
 
  end subroutine field_pwmax2
 
  subroutine field_pwmax3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_pwmax3(a%x_d, b%x_d, c%x_d, size)
    else
       call pwmax3(a%x, b%x, c%x, size)
    end if
  end subroutine field_pwmax3
 
  subroutine field_cpwmax2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    real(kind=rp), intent(in) :: b
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cpwmax2(a%x_d, b, size)
    else
       call cpwmax2(a%x, b, size)
    end if
 
  end subroutine field_cpwmax2
 
  subroutine field_cpwmax3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    real(kind=rp), intent(in) :: c
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cpwmax3(a%x_d, b%x_d, c, size)
    else
       call cpwmax3(a%x, b%x, c, size)
    end if
 
  end subroutine field_cpwmax3
 
  subroutine field_pwmin2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_pwmin2(a%x_d, b%x_d, size)
    else
       call pwmin2(a%x, b%x, size)
    end if
 
  end subroutine field_pwmin2
 
  subroutine field_pwmin3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    type(field_t), intent(in) :: c
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_pwmin3(a%x_d, b%x_d, c%x_d, size)
    else
       call pwmin3(a%x, b%x, c%x, size)
    end if
  end subroutine field_pwmin3
 
  subroutine field_cpwmin2(a, b, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    real(kind=rp), intent(in) :: b
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cpwmin2(a%x_d, b, size)
    else
       call cpwmin2(a%x, b, size)
    end if
 
  end subroutine field_cpwmin2
 
  subroutine field_cpwmin3(a, b, c, n)
    integer, intent(in), optional :: n
    type(field_t), intent(inout) :: a
    type(field_t), intent(in) :: b
    real(kind=rp), intent(in) :: c
    integer :: size, i
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cpwmin3(a%x_d, b%x_d, c, size)
    else
       call cpwmin3(a%x, b%x, c, size)
    end if
 
  end subroutine field_cpwmin3
 
end module field_math