refactor: Make all transpose operations work on a single field.

Author: semi-h

src/backend.f90

@@ -28,8 +28,8 @@ module m_base_backend
       procedure(transeq_ders), deferred :: transeq_y
       procedure(transeq_ders), deferred :: transeq_z
       procedure(tds_solve), deferred :: tds_solve
-      procedure(transposer), deferred :: trans_x2y
-      procedure(transposer), deferred :: trans_x2z
+      procedure(trans_d2d), deferred :: trans_x2y
+      procedure(trans_d2d), deferred :: trans_x2z
       procedure(trans_d2d), deferred :: trans_y2z
       procedure(trans_d2d), deferred :: trans_z2y
       procedure(trans_d2d), deferred :: trans_y2x
@@ -81,20 +81,6 @@ end subroutine tds_solve
    end interface
 
    abstract interface
-      subroutine transposer(self, u_, v_, w_, u, v, w)
-         !! transposer subroutines are straightforward, they rearrange
-         !! data into our specialist data structure so that regardless
-         !! of the direction tridiagonal systems are solved efficiently
-         !! and fast.
-         import :: base_backend_t
-         import :: field_t
-         implicit none
-
-         class(base_backend_t) :: self
-         class(field_t), intent(inout) :: u_, v_, w_
-         class(field_t), intent(in) :: u, v, w
-      end subroutine transposer
-
       subroutine trans_d2d(self, u_, u)
          !! transposer subroutines are straightforward, they rearrange
          !! data into our specialist data structure so that regardless

src/cuda/backend.f90

@@ -415,21 +415,21 @@ subroutine tds_solve_dist(self, du, u, dirps, tdsops, blocks, threads)
 
    end subroutine tds_solve_dist
 
-   subroutine trans_x2y_cuda(self, u_y, v_y, w_y, u, v, w)
+   subroutine trans_x2y_cuda(self, u_y, u)
       implicit none
 
       class(cuda_backend_t) :: self
-      class(field_t), intent(inout) :: u_y, v_y, w_y
-      class(field_t), intent(in) :: u, v, w
+      class(field_t), intent(inout) :: u_y
+      class(field_t), intent(in) :: u
 
    end subroutine trans_x2y_cuda
 
-   subroutine trans_x2z_cuda(self, u_z, v_z, w_z, u, v, w)
+   subroutine trans_x2z_cuda(self, u_z, u)
       implicit none
 
       class(cuda_backend_t) :: self
-      class(field_t), intent(inout) :: u_z, v_z, w_z
-      class(field_t), intent(in) :: u, v, w
+      class(field_t), intent(inout) :: u_z
+      class(field_t), intent(in) :: u
 
    end subroutine trans_x2z_cuda
 

src/omp/backend.f90

@@ -164,21 +164,21 @@ subroutine tds_solve_omp(self, du, u, dirps, tdsops)
 
    end subroutine tds_solve_omp
 
-   subroutine trans_x2y_omp(self, u_, v_, w_, u, v, w)
+   subroutine trans_x2y_omp(self, u_, u)
       implicit none
 
       class(omp_backend_t) :: self
-      class(field_t), intent(inout) :: u_, v_, w_
-      class(field_t), intent(in) :: u, v, w
+      class(field_t), intent(inout) :: u_
+      class(field_t), intent(in) :: u
 
    end subroutine trans_x2y_omp
 
-   subroutine trans_x2z_omp(self, u_, v_, w_, u, v, w)
+   subroutine trans_x2z_omp(self, u_, u)
       implicit none
 
       class(omp_backend_t) :: self
-      class(field_t), intent(inout) :: u_, v_, w_
-      class(field_t), intent(in) :: u, v, w
+      class(field_t), intent(inout) :: u_
+      class(field_t), intent(in) :: u
 
    end subroutine trans_x2z_omp
 

src/solver.f90

@@ -185,7 +185,10 @@ 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_x2y(u_y, v_y, w_y, u, v, w)
+      call self%backend%trans_x2y(u_y, u)
+      call self%backend%trans_x2y(v_y, v)
+      call self%backend%trans_x2y(w_y, w)
+
       ! 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)
 
@@ -206,7 +209,10 @@ 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_x2z(u_z, v_z, w_z, u, v, w)
+      call self%backend%trans_x2z(u_z, u)
+      call self%backend%trans_x2z(v_z, v)
+      call self%backend%trans_x2z(w_z, w)
+
       ! get the derivatives in z
       call self%backend%transeq_z(du_z, dv_z, dw_z, u_z, v_z, w_z, self%zdirps)
 
@@ -261,7 +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_x2y(u_y, v_y, w_y, du_x, dv_x, dw_x)
+      call self%backend%trans_x2y(u_y, du_x)
+      call self%backend%trans_x2y(v_y, dv_x)
+      call self%backend%trans_x2y(w_y, dw_x)
 
       call self%backend%allocator%release_block(du_x)
       call self%backend%allocator%release_block(dv_x)