mom_array_transform Module Reference

Detailed Description

Module for supporting the rotation of a field's index map. The implementation of each angle is described below.

+90deg: B(i,j) = A(n-j,i) = transpose, then row reverse 180deg: B(i,j) = A(m-i,n-j) = row reversal + column reversal -90deg: B(i,j) = A(j,m-i) = row reverse, then transpose

90 degree rotations change the shape of the field, and are handled separately from 180 degree rotations.

Data Types
interface	allocate_rotated_array
	Allocate an array based on the rotated index map of an unrotated reference array. More...
interface	rotate_array
	Rotate the elements of an array to the rotated set of indices. Rotation is applied across the first and second axes of the array. More...
interface	rotate_array_pair
	Rotate a pair of arrays which map to a rotated set of indices. Rotation is applied across the first and second axes of the array. This rotation should be applied when one field is mapped onto the other. For example, a tracer indexed along u or v face points will map from one to the other after a quarter turn, and back onto itself after a half turn. More...
interface	rotate_vector
	Rotate an array pair representing the components of a vector. Rotation is applied across the first and second axes of the array. This rotation should be applied when the fields satisfy vector transformation rules. For example, the u and v components of a velocity will map from one to the other for quarter turns, with a sign change in one component. A half turn will map elements onto themselves with sign changes in both components. More...

Functions/Subroutines
subroutine	rotate_array_real_2d (A_in, turns, A)
	Rotate the elements of a 2d real array along first and second axes. More...
subroutine	rotate_array_real_3d (A_in, turns, A)
	Rotate the elements of a 3d real array along first and second axes. More...
subroutine	rotate_array_real_4d (A_in, turns, A)
	Rotate the elements of a 4d real array along first and second axes. More...
subroutine	rotate_array_integer (A_in, turns, A)
	Rotate the elements of a 2d integer array along first and second axes. More...
subroutine	rotate_array_logical (A_in, turns, A)
	Rotate the elements of a 2d logical array along first and second axes. More...
subroutine	rotate_array_pair_real_2d (A_in, B_in, turns, A, B)
	Rotate the elements of a 2d real array pair along first and second axes. More...
subroutine	rotate_array_pair_real_3d (A_in, B_in, turns, A, B)
	Rotate the elements of a 3d real array pair along first and second axes. More...
subroutine	rotate_array_pair_integer (A_in, B_in, turns, A, B)
	Rotate the elements of a 4d real array pair along first and second axes. More...
subroutine	rotate_vector_real_2d (A_in, B_in, turns, A, B)
	Rotate the elements of a 2d real vector along first and second axes. More...
subroutine	rotate_vector_real_3d (A_in, B_in, turns, A, B)
	Rotate the elements of a 3d real vector along first and second axes. More...
subroutine	rotate_vector_real_4d (A_in, B_in, turns, A, B)
	Rotate the elements of a 4d real vector along first and second axes. More...
subroutine	allocate_rotated_array_real_2d (A_in, lb, turns, A)
	Allocate a 2d real array on the rotated index map of a reference array. More...
subroutine	allocate_rotated_array_real_3d (A_in, lb, turns, A)
	Allocate a 3d real array on the rotated index map of a reference array. More...
subroutine	allocate_rotated_array_real_4d (A_in, lb, turns, A)
	Allocate a 4d real array on the rotated index map of a reference array. More...
subroutine	allocate_rotated_array_integer (A_in, lb, turns, A)
	Allocate a 2d integer array on the rotated index map of a reference array. More...

Function/Subroutine Documentation

allocate_rotated_array_integer()

subroutine mom_array_transform::allocate_rotated_array_integer ( integer, dimension(lb(1):,lb(2):), intent(in)  A_in, integer, dimension(2), intent(in)  lb, integer, intent(in)  turns, integer, dimension(:,:), intent(inout), allocatable  A  )

private

Allocate a 2d integer array on the rotated index map of a reference array.

Parameters

[in]	lb	Lower index bounds of A_in
[in]	a_in	Reference array
[in]	turns	Number of quarter turns
[in,out]	a	Array on rotated index

Definition at line 342 of file MOM_array_transform.F90.

  integer, intent(in) :: lb(2)                  !< Lower index bounds of A_in
  integer, intent(in) :: A_in(lb(1):,lb(2):)    !< Reference array
  integer, intent(in) :: turns                  !< Number of quarter turns
  integer, allocatable, intent(inout) :: A(:,:) !< Array on rotated index

  integer :: ub(2)

  ub(:) = ubound(a_in)

  if (modulo(turns, 2) /= 0) then
    allocate(a(lb(2):ub(2), lb(1):ub(1)))
  else
    allocate(a(lb(1):ub(1), lb(2):ub(2)))
  endif

allocate_rotated_array_real_2d()

subroutine mom_array_transform::allocate_rotated_array_real_2d ( real, dimension(lb(1):, lb(2):), intent(in)  A_in, integer, dimension(2), intent(in)  lb, integer, intent(in)  turns, real, dimension(:,:), intent(inout), allocatable  A  )

private

Allocate a 2d real array on the rotated index map of a reference array.

Parameters

[in]	lb	Lower index bounds of A_in
[in]	a_in	Reference array
[in]	turns	Number of quarter turns
[in,out]	a	Array on rotated index

Definition at line 282 of file MOM_array_transform.F90.

  ! NOTE: lb must be declared before A_in
  integer, intent(in) :: lb(2)                !< Lower index bounds of A_in
  real, intent(in) :: A_in(lb(1):, lb(2):)    !< Reference array
  integer, intent(in) :: turns                !< Number of quarter turns
  real, allocatable, intent(inout) :: A(:,:)  !< Array on rotated index

  integer :: ub(2)

  ub(:) = ubound(a_in)

  if (modulo(turns, 2) /= 0) then
    allocate(a(lb(2):ub(2), lb(1):ub(1)))
  else
    allocate(a(lb(1):ub(1), lb(2):ub(2)))
  endif

allocate_rotated_array_real_3d()

subroutine mom_array_transform::allocate_rotated_array_real_3d ( real, dimension(lb(1):, lb(2):, lb(3):), intent(in)  A_in, integer, dimension(3), intent(in)  lb, integer, intent(in)  turns, real, dimension(:,:,:), intent(inout), allocatable  A  )

private

Allocate a 3d real array on the rotated index map of a reference array.

Parameters

[in]	lb	Lower index bounds of A_in
[in]	a_in	Reference array
[in]	turns	Number of quarter turns
[in,out]	a	Array on rotated index

Definition at line 302 of file MOM_array_transform.F90.

  ! NOTE: lb must be declared before A_in
  integer, intent(in) :: lb(3)                    !< Lower index bounds of A_in
  real, intent(in) :: A_in(lb(1):, lb(2):, lb(3):)  !< Reference array
  integer, intent(in) :: turns                    !< Number of quarter turns
  real, allocatable, intent(inout) :: A(:,:,:)    !< Array on rotated index

  integer :: ub(3)

  ub(:) = ubound(a_in)

  if (modulo(turns, 2) /= 0) then
    allocate(a(lb(2):ub(2), lb(1):ub(1), lb(3):ub(3)))
  else
    allocate(a(lb(1):ub(1), lb(2):ub(2), lb(3):ub(3)))
  endif

allocate_rotated_array_real_4d()

subroutine mom_array_transform::allocate_rotated_array_real_4d ( real, dimension(lb(1):,lb(2):,lb(3):,lb(4):), intent(in)  A_in, integer, dimension(4), intent(in)  lb, integer, intent(in)  turns, real, dimension(:,:,:,:), intent(inout), allocatable  A  )

private

Allocate a 4d real array on the rotated index map of a reference array.

Parameters

[in]	lb	Lower index bounds of A_in
[in]	a_in	Reference array
[in]	turns	Number of quarter turns
[in,out]	a	Array on rotated index

Definition at line 322 of file MOM_array_transform.F90.

  ! NOTE: lb must be declared before A_in
  integer, intent(in) :: lb(4)                    !< Lower index bounds of A_in
  real, intent(in) :: A_in(lb(1):,lb(2):,lb(3):,lb(4):) !< Reference array
  integer, intent(in) :: turns                    !< Number of quarter turns
  real, allocatable, intent(inout) :: A(:,:,:,:)  !< Array on rotated index

  integer:: ub(4)

  ub(:) = ubound(a_in)

  if (modulo(turns, 2) /= 0) then
    allocate(a(lb(2):ub(2), lb(1):ub(1), lb(3):ub(3), lb(4):ub(4)))
  else
    allocate(a(lb(1):ub(1), lb(2):ub(2), lb(3):ub(3), lb(4):ub(4)))
  endif

rotate_array_integer()

subroutine mom_array_transform::rotate_array_integer ( integer, dimension(:,:), intent(in)  A_in, integer, intent(in)  turns, integer, dimension(:,:), intent(out)  A  )

private

Rotate the elements of a 2d integer array along first and second axes.

Parameters

[in]	a_in	Unrotated array
[in]	turns	Number of quarter turns
[out]	a	Rotated array

Definition at line 128 of file MOM_array_transform.F90.

  integer, intent(in) :: A_in(:,:)  !< Unrotated array
  integer, intent(in) :: turns      !< Number of quarter turns
  integer, intent(out) :: A(:,:)    !< Rotated array

  integer :: m, n

  m = size(a_in, 1)
  n = size(a_in, 2)

  select case (modulo(turns, 4))
    case(0)
      a(:,:) = a_in(:,:)
    case(1)
      a(:,:) = transpose(a_in)
      a(:,:) = a(n:1:-1, :)
    case(2)
      a(:,:) = a_in(m:1:-1, n:1:-1)
    case(3)
      a(:,:) = transpose(a_in(m:1:-1, :))
  end select

rotate_array_logical()

subroutine mom_array_transform::rotate_array_logical ( logical, dimension(:,:), intent(in)  A_in, integer, intent(in)  turns, logical, dimension(:,:), intent(out)  A  )

private

Rotate the elements of a 2d logical array along first and second axes.

Parameters

[in]	a_in	Unrotated array
[in]	turns	Number of quarter turns
[out]	a	Rotated array

Definition at line 153 of file MOM_array_transform.F90.

  logical, intent(in) :: A_in(:,:)  !< Unrotated array
  integer, intent(in) :: turns      !< Number of quarter turns
  logical, intent(out) :: A(:,:)    !< Rotated array

  integer :: m, n

  m = size(a_in, 1)
  n = size(a_in, 2)

  select case (modulo(turns, 4))
    case(0)
      a(:,:) = a_in(:,:)
    case(1)
      a(:,:) = transpose(a_in)
      a(:,:) = a(n:1:-1, :)
    case(2)
      a(:,:) = a_in(m:1:-1, n:1:-1)
    case(3)
      a(:,:) = transpose(a_in(m:1:-1, :))
  end select

rotate_array_pair_integer()

subroutine mom_array_transform::rotate_array_pair_integer ( integer, dimension(:,:), intent(in)  A_in, integer, dimension(:,:), intent(in)  B_in, integer, intent(in)  turns, integer, dimension(:,:), intent(out)  A, integer, dimension(:,:), intent(out)  B  )

private

Rotate the elements of a 4d real array pair along first and second axes.

Parameters

[in]	a_in	Unrotated scalar array pair
[in]	b_in	Unrotated scalar array pair
[in]	turns	Number of quarter turns
[out]	a	Rotated scalar array pair
[out]	b	Rotated scalar array pair

Definition at line 213 of file MOM_array_transform.F90.

  integer, intent(in) :: A_in(:,:)  !< Unrotated scalar array pair
  integer, intent(in) :: B_in(:,:)  !< Unrotated scalar array pair
  integer, intent(in) :: turns      !< Number of quarter turns
  integer, intent(out) :: A(:,:)    !< Rotated scalar array pair
  integer, intent(out) :: B(:,:)    !< Rotated scalar array pair

  if (modulo(turns, 2) /= 0) then
    call rotate_array(b_in, turns, a)
    call rotate_array(a_in, turns, b)
  else
    call rotate_array(a_in, turns, a)
    call rotate_array(b_in, turns, b)
  endif

rotate_array_pair_real_2d()

subroutine mom_array_transform::rotate_array_pair_real_2d ( real, dimension(:,:), intent(in)  A_in, real, dimension(:,:), intent(in)  B_in, integer, intent(in)  turns, real, dimension(:,:), intent(out)  A, real, dimension(:,:), intent(out)  B  )

private

Rotate the elements of a 2d real array pair along first and second axes.

Parameters

[in]	a_in	Unrotated scalar array pair
[in]	b_in	Unrotated scalar array pair
[in]	turns	Number of quarter turns
[out]	a	Rotated scalar array pair
[out]	b	Rotated scalar array pair

Definition at line 178 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:)   !< Unrotated scalar array pair
  real, intent(in) :: B_in(:,:)   !< Unrotated scalar array pair
  integer, intent(in) :: turns    !< Number of quarter turns
  real, intent(out) :: A(:,:)     !< Rotated scalar array pair
  real, intent(out) :: B(:,:)     !< Rotated scalar array pair

  if (modulo(turns, 2) /= 0) then
    call rotate_array(b_in, turns, a)
    call rotate_array(a_in, turns, b)
  else
    call rotate_array(a_in, turns, a)
    call rotate_array(b_in, turns, b)
  endif

rotate_array_pair_real_3d()

subroutine mom_array_transform::rotate_array_pair_real_3d ( real, dimension(:,:,:), intent(in)  A_in, real, dimension(:,:,:), intent(in)  B_in, integer, intent(in)  turns, real, dimension(:,:,:), intent(out)  A, real, dimension(:,:,:), intent(out)  B  )

private

Rotate the elements of a 3d real array pair along first and second axes.

Parameters

[in]	a_in	Unrotated scalar array pair
[in]	b_in	Unrotated scalar array pair
[in]	turns	Number of quarter turns
[out]	a	Rotated scalar array pair
[out]	b	Rotated scalar array pair

Definition at line 196 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:,:)   !< Unrotated scalar array pair
  real, intent(in) :: B_in(:,:,:)   !< Unrotated scalar array pair
  integer, intent(in) :: turns      !< Number of quarter turns
  real, intent(out) :: A(:,:,:)     !< Rotated scalar array pair
  real, intent(out) :: B(:,:,:)     !< Rotated scalar array pair

  integer :: k

  do k = 1, size(a_in, 3)
    call rotate_array_pair(a_in(:,:,k), b_in(:,:,k), turns, &
        a(:,:,k), b(:,:,k))
  enddo

rotate_array_real_2d()

subroutine mom_array_transform::rotate_array_real_2d ( real, dimension(:,:), intent(in)  A_in, integer, intent(in)  turns, real, dimension(:,:), intent(out)  A  )

private

Rotate the elements of a 2d real array along first and second axes.

Parameters

[in]	a_in	Unrotated array
[in]	turns	Number of quarter turns
[out]	a	Rotated array

Definition at line 75 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:) !< Unrotated array
  integer, intent(in) :: turns  !< Number of quarter turns
  real, intent(out) :: A(:,:)   !< Rotated array

  integer :: m, n

  m = size(a_in, 1)
  n = size(a_in, 2)

  select case (modulo(turns, 4))
    case(0)
      a(:,:) = a_in(:,:)
    case(1)
      a(:,:) = transpose(a_in)
      a(:,:) = a(n:1:-1, :)
    case(2)
      a(:,:) = a_in(m:1:-1, n:1:-1)
    case(3)
      a(:,:) = transpose(a_in(m:1:-1, :))
  end select

rotate_array_real_3d()

subroutine mom_array_transform::rotate_array_real_3d ( real, dimension(:,:,:), intent(in)  A_in, integer, intent(in)  turns, real, dimension(:,:,:), intent(out)  A  )

private

Rotate the elements of a 3d real array along first and second axes.

Parameters

[in]	a_in	Unrotated array
[in]	turns	Number of quarter turns
[out]	a	Rotated array

Definition at line 100 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:,:) !< Unrotated array
  integer, intent(in) :: turns    !< Number of quarter turns
  real, intent(out) :: A(:,:,:)   !< Rotated array

  integer :: k

  do k = 1, size(a_in, 3)
    call rotate_array(a_in(:,:,k), turns, a(:,:,k))
  enddo

rotate_array_real_4d()

subroutine mom_array_transform::rotate_array_real_4d ( real, dimension(:,:,:,:), intent(in)  A_in, integer, intent(in)  turns, real, dimension(:,:,:,:), intent(out)  A  )

private

Rotate the elements of a 4d real array along first and second axes.

Parameters

[in]	a_in	Unrotated array
[in]	turns	Number of quarter turns
[out]	a	Rotated array

Definition at line 114 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:,:,:) !< Unrotated array
  integer, intent(in) :: turns      !< Number of quarter turns
  real, intent(out) :: A(:,:,:,:)   !< Rotated array

  integer :: n

  do n = 1, size(a_in, 4)
    call rotate_array(a_in(:,:,:,n), turns, a(:,:,:,n))
  enddo

rotate_vector_real_2d()

subroutine mom_array_transform::rotate_vector_real_2d ( real, dimension(:,:), intent(in)  A_in, real, dimension(:,:), intent(in)  B_in, integer, intent(in)  turns, real, dimension(:,:), intent(out)  A, real, dimension(:,:), intent(out)  B  )

private

Rotate the elements of a 2d real vector along first and second axes.

Parameters

[in]	a_in	First component of unrotated vector
[in]	b_in	Second component of unrotated vector
[in]	turns	Number of quarter turns
[out]	a	First component of rotated vector
[out]	b	Second component of unrotated vector

Definition at line 231 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:) !< First component of unrotated vector
  real, intent(in) :: B_in(:,:) !< Second component of unrotated vector
  integer, intent(in) :: turns  !< Number of quarter turns
  real, intent(out) :: A(:,:)   !< First component of rotated vector
  real, intent(out) :: B(:,:)   !< Second component of unrotated vector

  call rotate_array_pair(a_in, b_in, turns, a, b)

  if (modulo(turns, 4) == 1 .or. modulo(turns, 4) == 2) &
    a(:,:) = -a(:,:)

  if (modulo(turns, 4) == 2 .or. modulo(turns, 4) == 3) &
    b(:,:) = -b(:,:)

rotate_vector_real_3d()

subroutine mom_array_transform::rotate_vector_real_3d ( real, dimension(:,:,:), intent(in)  A_in, real, dimension(:,:,:), intent(in)  B_in, integer, intent(in)  turns, real, dimension(:,:,:), intent(out)  A, real, dimension(:,:,:), intent(out)  B  )

private

Rotate the elements of a 3d real vector along first and second axes.

Parameters

[in]	a_in	First component of unrotated vector
[in]	b_in	Second component of unrotated vector
[in]	turns	Number of quarter turns
[out]	a	First component of rotated vector
[out]	b	Second component of unrotated vector

Definition at line 249 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:,:) !< First component of unrotated vector
  real, intent(in) :: B_in(:,:,:) !< Second component of unrotated vector
  integer, intent(in) :: turns    !< Number of quarter turns
  real, intent(out) :: A(:,:,:)   !< First component of rotated vector
  real, intent(out) :: B(:,:,:)   !< Second component of unrotated vector

  integer :: k

  do k = 1, size(a_in, 3)
    call rotate_vector(a_in(:,:,k), b_in(:,:,k), turns, a(:,:,k), b(:,:,k))
  enddo

rotate_vector_real_4d()

subroutine mom_array_transform::rotate_vector_real_4d ( real, dimension(:,:,:,:), intent(in)  A_in, real, dimension(:,:,:,:), intent(in)  B_in, integer, intent(in)  turns, real, dimension(:,:,:,:), intent(out)  A, real, dimension(:,:,:,:), intent(out)  B  )

private

Rotate the elements of a 4d real vector along first and second axes.

Parameters

[in]	a_in	First component of unrotated vector
[in]	b_in	Second component of unrotated vector
[in]	turns	Number of quarter turns
[out]	a	First component of rotated vector
[out]	b	Second component of unrotated vector

Definition at line 265 of file MOM_array_transform.F90.

  real, intent(in) :: A_in(:,:,:,:) !< First component of unrotated vector
  real, intent(in) :: B_in(:,:,:,:) !< Second component of unrotated vector
  integer, intent(in) :: turns      !< Number of quarter turns
  real, intent(out) :: A(:,:,:,:)   !< First component of rotated vector
  real, intent(out) :: B(:,:,:,:)   !< Second component of unrotated vector

  integer :: n

  do n = 1, size(a_in, 4)
    call rotate_vector(a_in(:,:,:,n), b_in(:,:,:,n), turns, &
        a(:,:,:,n), b(:,:,:,n))
  enddo