gridsorting Module Reference

Functions/Subroutines
subroutine, public	quicksortgrid (array, arraySize, idxToGlobal, z_only)

Function/Subroutine Documentation

quicksortgrid()

subroutine, public gridsorting::quicksortgrid	(	integer, dimension(:), intent(inout)	array,
		integer, intent(in)	arraySize,
		type(globalcelltype), dimension(:), pointer	idxToGlobal,
		logical(lgp)	z_only
	)

Parameters

z_only

only sort by z coordinate

Definition at line 14 of file GridSorting.f90.

    integer, intent(inout), dimension(:) :: array
    integer, intent(in) :: arraySize
    type(GlobalCellType), dimension(:), pointer :: idxToGlobal
    logical(LGP) :: z_only !< only sort by z coordinate
    ! local
    integer :: QSORT_THRESHOLD = 8
    include "qsort_inline.inc"
 
  contains
    subroutine init()
    end subroutine init
 
    ! Compare two grid cells, this doesn't work as
    ! smooth for staggered discretizations though...
    function lessthan(n, m) result(isLess)
      integer(I4B), intent(in) :: n
      integer(I4B), intent(in) :: m
      logical(LGP) :: isLess
      ! local
      real(DP), dimension(3) :: xyz_n, xyz_m
 
      ! get coordinates as 3-vectors
      xyz_n = get_global_xyz(idxtoglobal(array(n)), z_only)
      xyz_m = get_global_xyz(idxtoglobal(array(m)), z_only)
 
      ! compare
      if (.not. is_close(xyz_n(3), xyz_m(3), 10 * epsilon(xyz_n(3)))) then
        isless = xyz_n(3) > xyz_m(3)
      else if (.not. is_close(xyz_n(2), xyz_m(2), 10 * epsilon(xyz_n(2)))) then
        isless = xyz_n(2) > xyz_m(2)
      else if (.not. is_close(xyz_n(1), xyz_m(1), 10 * epsilon(xyz_n(1)))) then
        isless = xyz_n(1) < xyz_m(1)
      else
        isless = .false.
      end if
 
    end function lessthan
 
    !> @brief Utility function to convert global cell
    !< id to global x,y,z coordinates
    function get_global_xyz(gc, use_only_z) result(global_xyz)
      type(GlobalCellType) :: gc !< the global cell id
      logical(LGP) :: use_only_z !< only z coordinate is needed or available, skip transform
      real(DP), dimension(3) :: global_xyz !< return xyz
      ! local
      real(DP) :: x, y, z
      real(DP) :: xc, yc, xo, yo, angrot
 
      z = dhalf * (gc%v_model%dis_top%get(gc%index) + &
                   gc%v_model%dis_bot%get(gc%index))
 
      x = dzero
      y = dzero
      if (.not. use_only_z) then
        xc = gc%v_model%dis_xc%get(gc%index)
        yc = gc%v_model%dis_yc%get(gc%index)
        xo = gc%v_model%dis_xorigin%get()
        yo = gc%v_model%dis_yorigin%get()
        angrot = gc%v_model%dis_angrot%get()
        call dis_transform_xy(xc, yc, xo, yo, angrot, x, y)
      end if
 
      global_xyz = [x, y, z]
 
    end function get_global_xyz
 
    ! swap indices
    subroutine swap(a, b)
      integer, intent(in) :: a, b
      integer :: hold
 
      hold = array(a)
      array(a) = array(b)
      array(b) = hold
 
    end subroutine swap
 
    ! circular shift-right by one
    subroutine rshift(left, right)
      integer, intent(in) :: left, right
      integer :: hold
 
      hold = array(right)
      array(left + 1:right) = array(left:right - 1)
      array(left) = hold
 
    end subroutine rshift

Here is the caller graph for this function: