feat: Use an integer parameter for transpose direction.

Author: semi-h

src/common.f90

@@ -4,6 +4,9 @@ module m_common
    integer, parameter :: dp=kind(0.0d0)
    real(dp), parameter :: pi = 4*atan(1.0_dp)
 
+   integer, parameter :: TRP_X2Y = 12, TRP_X2Z = 13, TRP_Y2X = 21, &
+                         TRP_Y2Z = 23, TRP_Z2Y = 32
+
    type :: globs_t
       integer :: nx, ny, nz
       integer :: nx_loc, ny_loc, nz_loc

src/cuda/backend.f90

@@ -3,7 +3,7 @@ module m_cuda_backend
 
    use m_allocator, only: allocator_t, field_t
    use m_base_backend, only: base_backend_t
-   use m_common, only: dp, globs_t
+   use m_common, only: dp, globs_t, TRP_X2Y, TRP_X2Z, TRP_Y2X, TRP_Y2Z, TRP_Z2Y
    use m_tdsops, only: dirps_t, tdsops_t
 
    use m_cuda_allocator, only: cuda_allocator_t, cuda_field_t
@@ -432,24 +432,24 @@ subroutine trans_d2d_cuda(self, u_o, u_i, direction)
       select type(u_i); type is (cuda_field_t); u_i_d => u_i%data_d; end select
 
       select case (direction)
-      case (12) ! x2y
+      case (TRP_X2Y) ! x2y
          blocks = dim3(self%nx_loc/SZ, self%nz_loc, self%ny_loc/SZ)
          threads = dim3(SZ, SZ, 1)
          call trans_x2y_k<<<blocks, threads>>>(u_o_d, u_i_d, self%nz_loc)
-      case (13) ! x2z
+      case (TRP_X2Z) ! x2z
          blocks = dim3(self%nx_loc, self%ny_loc/SZ, 1)
          threads = dim3(SZ, 1, 1)
          call trans_x2z_k<<<blocks, threads>>>(u_o_d, u_i_d, self%nz_loc)
-      case (21) ! y2x
+      case (TRP_Y2X) ! y2x
          blocks = dim3(self%nx_loc/SZ, self%ny_loc/SZ, self%nz_loc)
          threads = dim3(SZ, SZ, 1)
          call trans_y2x_k<<<blocks, threads>>>(u_o_d, u_i_d, self%nz_loc)
-      case (23) ! y2z
+      case (TRP_Y2Z) ! y2z
          blocks = dim3(self%nx_loc/SZ, self%ny_loc/SZ, self%nz_loc)
          threads = dim3(SZ, SZ, 1)
          call trans_y2z_k<<<blocks, threads>>>(u_o_d, u_i_d, &
                                                self%nx_loc, self%nz_loc)
-      case (32) ! z2y
+      case (TRP_Z2Y) ! z2y
          blocks = dim3(self%nx_loc/SZ, self%ny_loc/SZ, self%nz_loc)
          threads = dim3(SZ, SZ, 1)
 

src/solver.f90

@@ -1,7 +1,7 @@
 module m_solver
    use m_allocator, only: allocator_t, field_t
    use m_base_backend, only: base_backend_t
-   use m_common, only: dp, globs_t
+   use m_common, only: dp, globs_t, TRP_X2Y, TRP_X2Z, TRP_Y2X, TRP_Y2Z, TRP_Z2Y
    use m_tdsops, only: tdsops_t, dirps_t
    use m_time_integrator, only: time_intg_t
 
@@ -185,9 +185,9 @@ subroutine transeq(self, du, dv, dw, u, v, w)
       dw_y => self%backend%allocator%get_block()
 
       ! reorder data from x orientation to y orientation
-      call self%backend%trans_d2d(u_y, u, 12)
-      call self%backend%trans_d2d(v_y, v, 12)
-      call self%backend%trans_d2d(w_y, w, 12)
+      call self%backend%trans_d2d(u_y, u, TRP_X2Y)
+      call self%backend%trans_d2d(v_y, v, TRP_X2Y)
+      call self%backend%trans_d2d(w_y, w, TRP_X2Y)
 
       ! similar to the x direction, obtain derivatives in y.
       call self%backend%transeq_y(du_y, dv_y, dw_y, u_y, v_y, w_y, self%ydirps)
@@ -209,9 +209,9 @@ subroutine transeq(self, du, dv, dw, u, v, w)
       dw_z => self%backend%allocator%get_block()
 
       ! reorder from x to z
-      call self%backend%trans_d2d(u_z, u, 13)
-      call self%backend%trans_d2d(v_z, v, 13)
-      call self%backend%trans_d2d(w_z, w, 13)
+      call self%backend%trans_d2d(u_z, u, TRP_X2Z)
+      call self%backend%trans_d2d(v_z, v, TRP_X2Z)
+      call self%backend%trans_d2d(w_z, w, TRP_X2Z)
 
       ! get the derivatives in z
       call self%backend%transeq_z(du_z, dv_z, dw_z, u_z, v_z, w_z, self%zdirps)
@@ -267,9 +267,9 @@ subroutine divergence(self, div_u, u, v, w)
       w_y => self%backend%allocator%get_block()
 
       ! reorder data from x orientation to y orientation
-      call self%backend%trans_d2d(u_y, du_x, 12)
-      call self%backend%trans_d2d(v_y, dv_x, 12)
-      call self%backend%trans_d2d(w_y, dw_x, 12)
+      call self%backend%trans_d2d(u_y, du_x, TRP_X2Y)
+      call self%backend%trans_d2d(v_y, dv_x, TRP_X2Y)
+      call self%backend%trans_d2d(w_y, dw_x, TRP_X2Y)
 
       call self%backend%allocator%release_block(du_x)
       call self%backend%allocator%release_block(dv_x)
@@ -303,8 +303,8 @@ subroutine divergence(self, div_u, u, v, w)
       call self%backend%vecadd(1._dp, dw_y, 1._dp, dv_y)
 
       ! reorder from y to z
-      call self%backend%trans_d2d(u_z, du_y, 23)
-      call self%backend%trans_d2d(w_z, dw_y, 23)
+      call self%backend%trans_d2d(u_z, du_y, TRP_Y2Z)
+      call self%backend%trans_d2d(w_z, dw_y, TRP_Y2Z)
 
       ! release all the unnecessary blocks.
       call self%backend%allocator%release_block(du_y)
@@ -358,8 +358,8 @@ subroutine gradient(self, dpdx, dpdy, dpdz, pressure)
       dpdz_sxy_y => self%backend%allocator%get_block()
 
       ! reorder data from z orientation to y orientation
-      call self%backend%trans_d2d(p_sxy_y, p_sxy_z, 32)
-      call self%backend%trans_d2d(dpdz_sxy_y, dpdz_sxy_z, 32)
+      call self%backend%trans_d2d(p_sxy_y, p_sxy_z, TRP_Z2Y)
+      call self%backend%trans_d2d(dpdz_sxy_y, dpdz_sxy_z, TRP_Z2Y)
 
       call self%backend%allocator%release_block(p_sxy_z)
       call self%backend%allocator%release_block(dpdz_sxy_z)
@@ -386,9 +386,9 @@ subroutine gradient(self, dpdx, dpdy, dpdz, pressure)
       dpdz_sx_x => self%backend%allocator%get_block()
 
       ! reorder from y to x
-      call self%backend%trans_d2d(p_sx_x, p_sx_y, 21)
-      call self%backend%trans_d2d(dpdy_sx_x, dpdy_sx_y, 21)
-      call self%backend%trans_d2d(dpdz_sx_x, dpdz_sx_y, 21)
+      call self%backend%trans_d2d(p_sx_x, p_sx_y, TRP_Y2X)
+      call self%backend%trans_d2d(dpdy_sx_x, dpdy_sx_y, TRP_Y2X)
+      call self%backend%trans_d2d(dpdz_sx_x, dpdz_sx_y, TRP_Y2X)
 
       ! release all the y directional fields.
       call self%backend%allocator%release_block(p_sx_y)