scale_element_operation_tensorprod3D_kernel.F90

Go to the documentation of this file.

 
!-------------------------------------------------------------------------------
! Warning: This file was generated from element/scale_element_operation_tensorprod3D_kernel.F90.erb.
!          Do not edit this file.
!-------------------------------------------------------------------------------
!-------------------------------------------------------------------------------
!> module FElib / Element / Operation with 3D tensor product elements
!!
!! @par Description
!!           A module for providing kernels of matrix and vector operations assuming a 3D tensor product element with (p+1)^3 DOF
!!
!! @author Yuta Kawai, Xuanzhengbo Ren, and Team SCALE
!!
!<
#include "scaleFElib.h"
module scale_element_operation_tensorprod3d_kernel
 
  !-----------------------------------------------------------------------------
  !
  !++ used modules
  !
  use scale_precision
 
  use scale_element_base, only: &
    elementbase3d, &
    elementbase3d_init, elementbase3d_final
  !-----------------------------------------------------------------------------
  implicit none
  private
 
  !-----------------------------------------------------------------------------
  !
  !++ Public type & procedure
  !  
  public :: element_operation_kernel_matvec_dirx_p1
  public :: element_operation_kernel_matvec_diry_p1  
  public :: element_operation_kernel_matvec_dirz_p1
  public :: element_operation_kernel_matvec_lift_hexahedral_p1
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p1
  public :: element_operation_kernel_matvec_divlike_dirxyz_p1
  public :: element_operation_kernel_matvec_modalfilter_p1
  public :: element_operation_kernel_matvec_dirx_p2
  public :: element_operation_kernel_matvec_diry_p2  
  public :: element_operation_kernel_matvec_dirz_p2
  public :: element_operation_kernel_matvec_lift_hexahedral_p2
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p2
  public :: element_operation_kernel_matvec_divlike_dirxyz_p2
  public :: element_operation_kernel_matvec_modalfilter_p2
  public :: element_operation_kernel_matvec_dirx_p3
  public :: element_operation_kernel_matvec_diry_p3  
  public :: element_operation_kernel_matvec_dirz_p3
  public :: element_operation_kernel_matvec_lift_hexahedral_p3
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p3
  public :: element_operation_kernel_matvec_divlike_dirxyz_p3
  public :: element_operation_kernel_matvec_modalfilter_p3
  public :: element_operation_kernel_matvec_dirx_p4
  public :: element_operation_kernel_matvec_diry_p4  
  public :: element_operation_kernel_matvec_dirz_p4
  public :: element_operation_kernel_matvec_lift_hexahedral_p4
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p4
  public :: element_operation_kernel_matvec_divlike_dirxyz_p4
  public :: element_operation_kernel_matvec_modalfilter_p4
  public :: element_operation_kernel_matvec_dirx_p5
  public :: element_operation_kernel_matvec_diry_p5  
  public :: element_operation_kernel_matvec_dirz_p5
  public :: element_operation_kernel_matvec_lift_hexahedral_p5
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p5
  public :: element_operation_kernel_matvec_divlike_dirxyz_p5
  public :: element_operation_kernel_matvec_modalfilter_p5
  public :: element_operation_kernel_matvec_dirx_p6
  public :: element_operation_kernel_matvec_diry_p6  
  public :: element_operation_kernel_matvec_dirz_p6
  public :: element_operation_kernel_matvec_lift_hexahedral_p6
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p6
  public :: element_operation_kernel_matvec_divlike_dirxyz_p6
  public :: element_operation_kernel_matvec_modalfilter_p6
  public :: element_operation_kernel_matvec_dirx_p7
  public :: element_operation_kernel_matvec_diry_p7  
  public :: element_operation_kernel_matvec_dirz_p7
  public :: element_operation_kernel_matvec_lift_hexahedral_p7
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p7
  public :: element_operation_kernel_matvec_divlike_dirxyz_p7
  public :: element_operation_kernel_matvec_modalfilter_p7
  public :: element_operation_kernel_matvec_dirx_p8
  public :: element_operation_kernel_matvec_diry_p8  
  public :: element_operation_kernel_matvec_dirz_p8
  public :: element_operation_kernel_matvec_lift_hexahedral_p8
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p8
  public :: element_operation_kernel_matvec_divlike_dirxyz_p8
  public :: element_operation_kernel_matvec_modalfilter_p8
  public :: element_operation_kernel_matvec_dirx_p9
  public :: element_operation_kernel_matvec_diry_p9  
  public :: element_operation_kernel_matvec_dirz_p9
  public :: element_operation_kernel_matvec_lift_hexahedral_p9
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p9
  public :: element_operation_kernel_matvec_divlike_dirxyz_p9
  public :: element_operation_kernel_matvec_modalfilter_p9
  public :: element_operation_kernel_matvec_dirx_p10
  public :: element_operation_kernel_matvec_diry_p10  
  public :: element_operation_kernel_matvec_dirz_p10
  public :: element_operation_kernel_matvec_lift_hexahedral_p10
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p10
  public :: element_operation_kernel_matvec_divlike_dirxyz_p10
  public :: element_operation_kernel_matvec_modalfilter_p10
  public :: element_operation_kernel_matvec_dirx_p11
  public :: element_operation_kernel_matvec_diry_p11  
  public :: element_operation_kernel_matvec_dirz_p11
  public :: element_operation_kernel_matvec_lift_hexahedral_p11
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p11
  public :: element_operation_kernel_matvec_divlike_dirxyz_p11
  public :: element_operation_kernel_matvec_modalfilter_p11
  public :: element_operation_kernel_matvec_dirx_p12
  public :: element_operation_kernel_matvec_diry_p12  
  public :: element_operation_kernel_matvec_dirz_p12
  public :: element_operation_kernel_matvec_lift_hexahedral_p12
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p12
  public :: element_operation_kernel_matvec_divlike_dirxyz_p12
  public :: element_operation_kernel_matvec_modalfilter_p12
  public :: element_operation_kernel_matvec_dirx_p13
  public :: element_operation_kernel_matvec_diry_p13  
  public :: element_operation_kernel_matvec_dirz_p13
  public :: element_operation_kernel_matvec_lift_hexahedral_p13
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p13
  public :: element_operation_kernel_matvec_divlike_dirxyz_p13
  public :: element_operation_kernel_matvec_modalfilter_p13
  public :: element_operation_kernel_matvec_dirx_p14
  public :: element_operation_kernel_matvec_diry_p14  
  public :: element_operation_kernel_matvec_dirz_p14
  public :: element_operation_kernel_matvec_lift_hexahedral_p14
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p14
  public :: element_operation_kernel_matvec_divlike_dirxyz_p14
  public :: element_operation_kernel_matvec_modalfilter_p14
  public :: element_operation_kernel_matvec_dirx_p15
  public :: element_operation_kernel_matvec_diry_p15  
  public :: element_operation_kernel_matvec_dirz_p15
  public :: element_operation_kernel_matvec_lift_hexahedral_p15
  public :: element_operation_kernel_matvec_gradlike_dirxyz_p15
  public :: element_operation_kernel_matvec_divlike_dirxyz_p15
  public :: element_operation_kernel_matvec_modalfilter_p15
 
contains
!--- For p=1 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=1
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p1( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(2,2)
    real(rp), intent(in) :: vec_in(2,2**2)
    real(rp), intent(out) :: vec_out(2,2**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 2**2
    do i=1, 2
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p1
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=1
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p1( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(2,2)
    real(rp), intent(in) :: vec_in(2,2,2)
    real(rp), intent(out) :: vec_out(2,2,2)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 2
    do j=1, 2
    do i=1, 2
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p1
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=1
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p1( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(2,2)
    real(rp), intent(in) :: vec_in(2,2,2)
    real(rp), intent(out) :: vec_out(2,2,2)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 2
    do j=1, 2
    do i=1, 2
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p1
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=1
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p1( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(2,2,2,6)
    real(rp), intent(in) :: vec_in(2,2,6)
    real(rp), intent(out) :: vec_out(2,2,2)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 2
    do j=1, 2
    do i=1, 2
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p1
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=1
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p1( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(2,2)
    real(rp), intent(in) :: mat_tr(2,2)
    real(rp), intent(in) :: vec_in_(2,2**2)
    real(rp), intent(in) :: vec_in(2,2,2)
    real(rp), intent(out) :: vec_out_x(2,2**2)
    real(rp), intent(out) :: vec_out_y(2,2,2)
    real(rp), intent(out) :: vec_out_z(2,2,2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 2**2
    do i=1, 2
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 2
    do j=1, 2
    do i=1, 2
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 2
    do j=1, 2
    do i=1, 2
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p1
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=1
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p1( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(2,2)
    real(rp), intent(in) :: mat_tr(2,2)
    real(rp), intent(in) :: vec_in_x(2,2**2)
    real(rp), intent(in) :: vec_in_y(2,2,2)
    real(rp), intent(in) :: vec_in_z(2,2,2)
    real(rp), intent(out) :: vec_out_x(2,2**2)
    real(rp), intent(out) :: vec_out_y(2,2**2)
    real(rp), intent(out) :: vec_out_z(2,2**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 2**2
    do i=1, 2
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 2
    do j=1, 2
      jk = j + (k-1)*2
      do i=1, 2
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 2
    do j=1, 2
      jk = j + (k-1)*2
      do i=1, 2
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p1
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p1( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(2,2)
    real(rp), intent(in) :: mat_tr(2,2)
    real(rp), intent(in) :: vec_in_x(2,2**2*5)
    real(rp), intent(in) :: vec_in_y(2,2,2*5)
    real(rp), intent(in) :: vec_in_z(2,2,2,5)
    real(rp), intent(out) :: vec_out_x(2,2**2*5)
    real(rp), intent(out) :: vec_out_y(2,2**2*5)
    real(rp), intent(out) :: vec_out_z(2,2**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 2**2*5
    do i=1, 2
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 2*5
    do j=1, 2
      jkv = j + (kv-1)*10
      do i=1, 2
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 2
    do j=1, 2
      jk = j + (k-1)*2
      do i=1, 2
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p1
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=1
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p1( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(2,2)
    real(rp), intent(in) :: mat_h1d_tr(2,2)
    real(rp), intent(in) :: mat_v1d_tr(2,2)
    real(rp), intent(in) :: vec_in(2,2,2)
    real(rp), intent(out) :: vec_work(2,2,2)
    real(rp), intent(out) :: vec_out(2,2,2)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 2
    do j=1, 2
    do i=1, 2
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 2
    do j=1, 2
    do i=1, 2
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 2
    do j=1, 2
    do i=1, 2
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p1
 
!--- For p=2 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=2
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p2( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(3,3)
    real(rp), intent(in) :: vec_in(3,3**2)
    real(rp), intent(out) :: vec_out(3,3**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 3**2
    do i=1, 3
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p2
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=2
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p2( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(3,3)
    real(rp), intent(in) :: vec_in(3,3,3)
    real(rp), intent(out) :: vec_out(3,3,3)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 3
    do j=1, 3
    do i=1, 3
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p2
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=2
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p2( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(3,3)
    real(rp), intent(in) :: vec_in(3,3,3)
    real(rp), intent(out) :: vec_out(3,3,3)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 3
    do j=1, 3
    do i=1, 3
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p2
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=2
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p2( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(3,3,3,6)
    real(rp), intent(in) :: vec_in(3,3,6)
    real(rp), intent(out) :: vec_out(3,3,3)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 3
    do j=1, 3
    do i=1, 3
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p2
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=2
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p2( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(3,3)
    real(rp), intent(in) :: mat_tr(3,3)
    real(rp), intent(in) :: vec_in_(3,3**2)
    real(rp), intent(in) :: vec_in(3,3,3)
    real(rp), intent(out) :: vec_out_x(3,3**2)
    real(rp), intent(out) :: vec_out_y(3,3,3)
    real(rp), intent(out) :: vec_out_z(3,3,3)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 3**2
    do i=1, 3
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 3
    do j=1, 3
    do i=1, 3
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 3
    do j=1, 3
    do i=1, 3
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p2
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=2
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p2( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(3,3)
    real(rp), intent(in) :: mat_tr(3,3)
    real(rp), intent(in) :: vec_in_x(3,3**2)
    real(rp), intent(in) :: vec_in_y(3,3,3)
    real(rp), intent(in) :: vec_in_z(3,3,3)
    real(rp), intent(out) :: vec_out_x(3,3**2)
    real(rp), intent(out) :: vec_out_y(3,3**2)
    real(rp), intent(out) :: vec_out_z(3,3**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 3**2
    do i=1, 3
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk) &
                      + mat(i,3) * vec_in_x(3,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 3
    do j=1, 3
      jk = j + (k-1)*3
      do i=1, 3
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) &
                        + vec_in_y(i,3,k) * mat_tr(3,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 3
    do j=1, 3
      jk = j + (k-1)*3
      do i=1, 3
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) &
                        + vec_in_z(i,j,3) * mat_tr(3,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p2
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p2( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(3,3)
    real(rp), intent(in) :: mat_tr(3,3)
    real(rp), intent(in) :: vec_in_x(3,3**2*5)
    real(rp), intent(in) :: vec_in_y(3,3,3*5)
    real(rp), intent(in) :: vec_in_z(3,3,3,5)
    real(rp), intent(out) :: vec_out_x(3,3**2*5)
    real(rp), intent(out) :: vec_out_y(3,3**2*5)
    real(rp), intent(out) :: vec_out_z(3,3**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 3**2*5
    do i=1, 3
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv) &
                      + mat(i,3) * vec_in_x(3,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 3*5
    do j=1, 3
      jkv = j + (kv-1)*15
      do i=1, 3
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) &
                        + vec_in_y(i,3,kv) * mat_tr(3,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 3
    do j=1, 3
      jk = j + (k-1)*3
      do i=1, 3
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) &
                        + vec_in_z(i,j,3,v) * mat_tr(3,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p2
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=2
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p2( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(3,3)
    real(rp), intent(in) :: mat_h1d_tr(3,3)
    real(rp), intent(in) :: mat_v1d_tr(3,3)
    real(rp), intent(in) :: vec_in(3,3,3)
    real(rp), intent(out) :: vec_work(3,3,3)
    real(rp), intent(out) :: vec_out(3,3,3)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 3
    do j=1, 3
    do i=1, 3
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k) &
                     + mat_h1d(i,3) * vec_in(3,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 3
    do j=1, 3
    do i=1, 3
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) &
                      + vec_out(i,3,k) * mat_h1d_tr(3,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 3
    do j=1, 3
    do i=1, 3
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) &
                     + vec_work(i,j,3) * mat_v1d_tr(3,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p2
 
!--- For p=3 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=3
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p3( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(4,4)
    real(rp), intent(in) :: vec_in(4,4**2)
    real(rp), intent(out) :: vec_out(4,4**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 4**2
    do i=1, 4
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p3
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=3
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p3( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(4,4)
    real(rp), intent(in) :: vec_in(4,4,4)
    real(rp), intent(out) :: vec_out(4,4,4)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 4
    do j=1, 4
    do i=1, 4
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p3
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=3
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p3( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(4,4)
    real(rp), intent(in) :: vec_in(4,4,4)
    real(rp), intent(out) :: vec_out(4,4,4)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 4
    do j=1, 4
    do i=1, 4
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p3
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=3
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p3( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(4,4,4,6)
    real(rp), intent(in) :: vec_in(4,4,6)
    real(rp), intent(out) :: vec_out(4,4,4)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 4
    do j=1, 4
    do i=1, 4
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p3
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=3
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p3( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(4,4)
    real(rp), intent(in) :: mat_tr(4,4)
    real(rp), intent(in) :: vec_in_(4,4**2)
    real(rp), intent(in) :: vec_in(4,4,4)
    real(rp), intent(out) :: vec_out_x(4,4**2)
    real(rp), intent(out) :: vec_out_y(4,4,4)
    real(rp), intent(out) :: vec_out_z(4,4,4)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 4**2
    do i=1, 4
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 4
    do j=1, 4
    do i=1, 4
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 4
    do j=1, 4
    do i=1, 4
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p3
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=3
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p3( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(4,4)
    real(rp), intent(in) :: mat_tr(4,4)
    real(rp), intent(in) :: vec_in_x(4,4**2)
    real(rp), intent(in) :: vec_in_y(4,4,4)
    real(rp), intent(in) :: vec_in_z(4,4,4)
    real(rp), intent(out) :: vec_out_x(4,4**2)
    real(rp), intent(out) :: vec_out_y(4,4**2)
    real(rp), intent(out) :: vec_out_z(4,4**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 4**2
    do i=1, 4
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk) &
                      + mat(i,3) * vec_in_x(3,jk) &
                      + mat(i,4) * vec_in_x(4,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 4
    do j=1, 4
      jk = j + (k-1)*4
      do i=1, 4
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) &
                        + vec_in_y(i,3,k) * mat_tr(3,j) &
                        + vec_in_y(i,4,k) * mat_tr(4,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 4
    do j=1, 4
      jk = j + (k-1)*4
      do i=1, 4
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) &
                        + vec_in_z(i,j,3) * mat_tr(3,k) &
                        + vec_in_z(i,j,4) * mat_tr(4,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p3
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p3( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(4,4)
    real(rp), intent(in) :: mat_tr(4,4)
    real(rp), intent(in) :: vec_in_x(4,4**2*5)
    real(rp), intent(in) :: vec_in_y(4,4,4*5)
    real(rp), intent(in) :: vec_in_z(4,4,4,5)
    real(rp), intent(out) :: vec_out_x(4,4**2*5)
    real(rp), intent(out) :: vec_out_y(4,4**2*5)
    real(rp), intent(out) :: vec_out_z(4,4**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 4**2*5
    do i=1, 4
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv) &
                      + mat(i,3) * vec_in_x(3,jkv) &
                      + mat(i,4) * vec_in_x(4,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 4*5
    do j=1, 4
      jkv = j + (kv-1)*20
      do i=1, 4
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) &
                        + vec_in_y(i,3,kv) * mat_tr(3,j) &
                        + vec_in_y(i,4,kv) * mat_tr(4,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 4
    do j=1, 4
      jk = j + (k-1)*4
      do i=1, 4
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) &
                        + vec_in_z(i,j,3,v) * mat_tr(3,k) &
                        + vec_in_z(i,j,4,v) * mat_tr(4,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p3
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=3
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p3( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(4,4)
    real(rp), intent(in) :: mat_h1d_tr(4,4)
    real(rp), intent(in) :: mat_v1d_tr(4,4)
    real(rp), intent(in) :: vec_in(4,4,4)
    real(rp), intent(out) :: vec_work(4,4,4)
    real(rp), intent(out) :: vec_out(4,4,4)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 4
    do j=1, 4
    do i=1, 4
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k) &
                     + mat_h1d(i,3) * vec_in(3,j,k) &
                     + mat_h1d(i,4) * vec_in(4,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 4
    do j=1, 4
    do i=1, 4
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) &
                      + vec_out(i,3,k) * mat_h1d_tr(3,j) &
                      + vec_out(i,4,k) * mat_h1d_tr(4,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 4
    do j=1, 4
    do i=1, 4
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) &
                     + vec_work(i,j,3) * mat_v1d_tr(3,k) &
                     + vec_work(i,j,4) * mat_v1d_tr(4,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p3
 
!--- For p=4 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=4
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p4( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(5,5)
    real(rp), intent(in) :: vec_in(5,5**2)
    real(rp), intent(out) :: vec_out(5,5**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 5**2
    do i=1, 5
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p4
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=4
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p4( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(5,5)
    real(rp), intent(in) :: vec_in(5,5,5)
    real(rp), intent(out) :: vec_out(5,5,5)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 5
    do j=1, 5
    do i=1, 5
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p4
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=4
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p4( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(5,5)
    real(rp), intent(in) :: vec_in(5,5,5)
    real(rp), intent(out) :: vec_out(5,5,5)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 5
    do j=1, 5
    do i=1, 5
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p4
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=4
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p4( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(5,5,5,6)
    real(rp), intent(in) :: vec_in(5,5,6)
    real(rp), intent(out) :: vec_out(5,5,5)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 5
    do j=1, 5
    do i=1, 5
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p4
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=4
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p4( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(5,5)
    real(rp), intent(in) :: mat_tr(5,5)
    real(rp), intent(in) :: vec_in_(5,5**2)
    real(rp), intent(in) :: vec_in(5,5,5)
    real(rp), intent(out) :: vec_out_x(5,5**2)
    real(rp), intent(out) :: vec_out_y(5,5,5)
    real(rp), intent(out) :: vec_out_z(5,5,5)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 5**2
    do i=1, 5
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 5
    do j=1, 5
    do i=1, 5
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 5
    do j=1, 5
    do i=1, 5
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p4
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=4
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p4( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(5,5)
    real(rp), intent(in) :: mat_tr(5,5)
    real(rp), intent(in) :: vec_in_x(5,5**2)
    real(rp), intent(in) :: vec_in_y(5,5,5)
    real(rp), intent(in) :: vec_in_z(5,5,5)
    real(rp), intent(out) :: vec_out_x(5,5**2)
    real(rp), intent(out) :: vec_out_y(5,5**2)
    real(rp), intent(out) :: vec_out_z(5,5**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 5**2
    do i=1, 5
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk) &
                      + mat(i,3) * vec_in_x(3,jk) &
                      + mat(i,4) * vec_in_x(4,jk) &
                      + mat(i,5) * vec_in_x(5,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 5
    do j=1, 5
      jk = j + (k-1)*5
      do i=1, 5
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) &
                        + vec_in_y(i,3,k) * mat_tr(3,j) &
                        + vec_in_y(i,4,k) * mat_tr(4,j) &
                        + vec_in_y(i,5,k) * mat_tr(5,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 5
    do j=1, 5
      jk = j + (k-1)*5
      do i=1, 5
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) &
                        + vec_in_z(i,j,3) * mat_tr(3,k) &
                        + vec_in_z(i,j,4) * mat_tr(4,k) &
                        + vec_in_z(i,j,5) * mat_tr(5,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p4
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p4( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(5,5)
    real(rp), intent(in) :: mat_tr(5,5)
    real(rp), intent(in) :: vec_in_x(5,5**2*5)
    real(rp), intent(in) :: vec_in_y(5,5,5*5)
    real(rp), intent(in) :: vec_in_z(5,5,5,5)
    real(rp), intent(out) :: vec_out_x(5,5**2*5)
    real(rp), intent(out) :: vec_out_y(5,5**2*5)
    real(rp), intent(out) :: vec_out_z(5,5**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 5**2*5
    do i=1, 5
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv) &
                      + mat(i,3) * vec_in_x(3,jkv) &
                      + mat(i,4) * vec_in_x(4,jkv) &
                      + mat(i,5) * vec_in_x(5,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 5*5
    do j=1, 5
      jkv = j + (kv-1)*25
      do i=1, 5
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) &
                        + vec_in_y(i,3,kv) * mat_tr(3,j) &
                        + vec_in_y(i,4,kv) * mat_tr(4,j) &
                        + vec_in_y(i,5,kv) * mat_tr(5,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 5
    do j=1, 5
      jk = j + (k-1)*5
      do i=1, 5
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) &
                        + vec_in_z(i,j,3,v) * mat_tr(3,k) &
                        + vec_in_z(i,j,4,v) * mat_tr(4,k) &
                        + vec_in_z(i,j,5,v) * mat_tr(5,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p4
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=4
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p4( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(5,5)
    real(rp), intent(in) :: mat_h1d_tr(5,5)
    real(rp), intent(in) :: mat_v1d_tr(5,5)
    real(rp), intent(in) :: vec_in(5,5,5)
    real(rp), intent(out) :: vec_work(5,5,5)
    real(rp), intent(out) :: vec_out(5,5,5)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 5
    do j=1, 5
    do i=1, 5
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k) &
                     + mat_h1d(i,3) * vec_in(3,j,k) &
                     + mat_h1d(i,4) * vec_in(4,j,k) &
                     + mat_h1d(i,5) * vec_in(5,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 5
    do j=1, 5
    do i=1, 5
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) &
                      + vec_out(i,3,k) * mat_h1d_tr(3,j) &
                      + vec_out(i,4,k) * mat_h1d_tr(4,j) &
                      + vec_out(i,5,k) * mat_h1d_tr(5,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 5
    do j=1, 5
    do i=1, 5
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) &
                     + vec_work(i,j,3) * mat_v1d_tr(3,k) &
                     + vec_work(i,j,4) * mat_v1d_tr(4,k) &
                     + vec_work(i,j,5) * mat_v1d_tr(5,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p4
 
!--- For p=5 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=5
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p5( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(6,6)
    real(rp), intent(in) :: vec_in(6,6**2)
    real(rp), intent(out) :: vec_out(6,6**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 6**2
    do i=1, 6
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p5
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=5
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p5( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(6,6)
    real(rp), intent(in) :: vec_in(6,6,6)
    real(rp), intent(out) :: vec_out(6,6,6)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 6
    do j=1, 6
    do i=1, 6
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p5
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=5
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p5( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(6,6)
    real(rp), intent(in) :: vec_in(6,6,6)
    real(rp), intent(out) :: vec_out(6,6,6)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 6
    do j=1, 6
    do i=1, 6
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p5
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=5
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p5( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(6,6,6,6)
    real(rp), intent(in) :: vec_in(6,6,6)
    real(rp), intent(out) :: vec_out(6,6,6)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 6
    do j=1, 6
    do i=1, 6
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p5
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=5
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p5( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(6,6)
    real(rp), intent(in) :: mat_tr(6,6)
    real(rp), intent(in) :: vec_in_(6,6**2)
    real(rp), intent(in) :: vec_in(6,6,6)
    real(rp), intent(out) :: vec_out_x(6,6**2)
    real(rp), intent(out) :: vec_out_y(6,6,6)
    real(rp), intent(out) :: vec_out_z(6,6,6)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 6**2
    do i=1, 6
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 6
    do j=1, 6
    do i=1, 6
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 6
    do j=1, 6
    do i=1, 6
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p5
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=5
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p5( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(6,6)
    real(rp), intent(in) :: mat_tr(6,6)
    real(rp), intent(in) :: vec_in_x(6,6**2)
    real(rp), intent(in) :: vec_in_y(6,6,6)
    real(rp), intent(in) :: vec_in_z(6,6,6)
    real(rp), intent(out) :: vec_out_x(6,6**2)
    real(rp), intent(out) :: vec_out_y(6,6**2)
    real(rp), intent(out) :: vec_out_z(6,6**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 6**2
    do i=1, 6
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk) &
                      + mat(i,3) * vec_in_x(3,jk) &
                      + mat(i,4) * vec_in_x(4,jk) &
                      + mat(i,5) * vec_in_x(5,jk) &
                      + mat(i,6) * vec_in_x(6,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 6
    do j=1, 6
      jk = j + (k-1)*6
      do i=1, 6
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) &
                        + vec_in_y(i,3,k) * mat_tr(3,j) &
                        + vec_in_y(i,4,k) * mat_tr(4,j) &
                        + vec_in_y(i,5,k) * mat_tr(5,j) &
                        + vec_in_y(i,6,k) * mat_tr(6,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 6
    do j=1, 6
      jk = j + (k-1)*6
      do i=1, 6
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) &
                        + vec_in_z(i,j,3) * mat_tr(3,k) &
                        + vec_in_z(i,j,4) * mat_tr(4,k) &
                        + vec_in_z(i,j,5) * mat_tr(5,k) &
                        + vec_in_z(i,j,6) * mat_tr(6,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p5
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p5( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(6,6)
    real(rp), intent(in) :: mat_tr(6,6)
    real(rp), intent(in) :: vec_in_x(6,6**2*5)
    real(rp), intent(in) :: vec_in_y(6,6,6*5)
    real(rp), intent(in) :: vec_in_z(6,6,6,5)
    real(rp), intent(out) :: vec_out_x(6,6**2*5)
    real(rp), intent(out) :: vec_out_y(6,6**2*5)
    real(rp), intent(out) :: vec_out_z(6,6**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 6**2*5
    do i=1, 6
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv) &
                      + mat(i,3) * vec_in_x(3,jkv) &
                      + mat(i,4) * vec_in_x(4,jkv) &
                      + mat(i,5) * vec_in_x(5,jkv) &
                      + mat(i,6) * vec_in_x(6,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 6*5
    do j=1, 6
      jkv = j + (kv-1)*30
      do i=1, 6
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) &
                        + vec_in_y(i,3,kv) * mat_tr(3,j) &
                        + vec_in_y(i,4,kv) * mat_tr(4,j) &
                        + vec_in_y(i,5,kv) * mat_tr(5,j) &
                        + vec_in_y(i,6,kv) * mat_tr(6,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 6
    do j=1, 6
      jk = j + (k-1)*6
      do i=1, 6
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) &
                        + vec_in_z(i,j,3,v) * mat_tr(3,k) &
                        + vec_in_z(i,j,4,v) * mat_tr(4,k) &
                        + vec_in_z(i,j,5,v) * mat_tr(5,k) &
                        + vec_in_z(i,j,6,v) * mat_tr(6,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p5
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=5
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p5( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(6,6)
    real(rp), intent(in) :: mat_h1d_tr(6,6)
    real(rp), intent(in) :: mat_v1d_tr(6,6)
    real(rp), intent(in) :: vec_in(6,6,6)
    real(rp), intent(out) :: vec_work(6,6,6)
    real(rp), intent(out) :: vec_out(6,6,6)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 6
    do j=1, 6
    do i=1, 6
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k) &
                     + mat_h1d(i,3) * vec_in(3,j,k) &
                     + mat_h1d(i,4) * vec_in(4,j,k) &
                     + mat_h1d(i,5) * vec_in(5,j,k) &
                     + mat_h1d(i,6) * vec_in(6,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 6
    do j=1, 6
    do i=1, 6
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) &
                      + vec_out(i,3,k) * mat_h1d_tr(3,j) &
                      + vec_out(i,4,k) * mat_h1d_tr(4,j) &
                      + vec_out(i,5,k) * mat_h1d_tr(5,j) &
                      + vec_out(i,6,k) * mat_h1d_tr(6,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 6
    do j=1, 6
    do i=1, 6
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) &
                     + vec_work(i,j,3) * mat_v1d_tr(3,k) &
                     + vec_work(i,j,4) * mat_v1d_tr(4,k) &
                     + vec_work(i,j,5) * mat_v1d_tr(5,k) &
                     + vec_work(i,j,6) * mat_v1d_tr(6,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p5
 
!--- For p=6 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=6
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p6( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(7,7)
    real(rp), intent(in) :: vec_in(7,7**2)
    real(rp), intent(out) :: vec_out(7,7**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 7**2
    do i=1, 7
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p6
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=6
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p6( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(7,7)
    real(rp), intent(in) :: vec_in(7,7,7)
    real(rp), intent(out) :: vec_out(7,7,7)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 7
    do j=1, 7
    do i=1, 7
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p6
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=6
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p6( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(7,7)
    real(rp), intent(in) :: vec_in(7,7,7)
    real(rp), intent(out) :: vec_out(7,7,7)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 7
    do j=1, 7
    do i=1, 7
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p6
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=6
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p6( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(7,7,7,6)
    real(rp), intent(in) :: vec_in(7,7,6)
    real(rp), intent(out) :: vec_out(7,7,7)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 7
    do j=1, 7
    do i=1, 7
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p6
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=6
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p6( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(7,7)
    real(rp), intent(in) :: mat_tr(7,7)
    real(rp), intent(in) :: vec_in_(7,7**2)
    real(rp), intent(in) :: vec_in(7,7,7)
    real(rp), intent(out) :: vec_out_x(7,7**2)
    real(rp), intent(out) :: vec_out_y(7,7,7)
    real(rp), intent(out) :: vec_out_z(7,7,7)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 7**2
    do i=1, 7
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 7
    do j=1, 7
    do i=1, 7
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 7
    do j=1, 7
    do i=1, 7
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p6
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=6
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p6( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(7,7)
    real(rp), intent(in) :: mat_tr(7,7)
    real(rp), intent(in) :: vec_in_x(7,7**2)
    real(rp), intent(in) :: vec_in_y(7,7,7)
    real(rp), intent(in) :: vec_in_z(7,7,7)
    real(rp), intent(out) :: vec_out_x(7,7**2)
    real(rp), intent(out) :: vec_out_y(7,7**2)
    real(rp), intent(out) :: vec_out_z(7,7**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 7**2
    do i=1, 7
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk) &
                      + mat(i,3) * vec_in_x(3,jk) &
                      + mat(i,4) * vec_in_x(4,jk) &
                      + mat(i,5) * vec_in_x(5,jk) &
                      + mat(i,6) * vec_in_x(6,jk) &
                      + mat(i,7) * vec_in_x(7,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 7
    do j=1, 7
      jk = j + (k-1)*7
      do i=1, 7
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) &
                        + vec_in_y(i,3,k) * mat_tr(3,j) &
                        + vec_in_y(i,4,k) * mat_tr(4,j) &
                        + vec_in_y(i,5,k) * mat_tr(5,j) &
                        + vec_in_y(i,6,k) * mat_tr(6,j) &
                        + vec_in_y(i,7,k) * mat_tr(7,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 7
    do j=1, 7
      jk = j + (k-1)*7
      do i=1, 7
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) &
                        + vec_in_z(i,j,3) * mat_tr(3,k) &
                        + vec_in_z(i,j,4) * mat_tr(4,k) &
                        + vec_in_z(i,j,5) * mat_tr(5,k) &
                        + vec_in_z(i,j,6) * mat_tr(6,k) &
                        + vec_in_z(i,j,7) * mat_tr(7,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p6
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p6( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(7,7)
    real(rp), intent(in) :: mat_tr(7,7)
    real(rp), intent(in) :: vec_in_x(7,7**2*5)
    real(rp), intent(in) :: vec_in_y(7,7,7*5)
    real(rp), intent(in) :: vec_in_z(7,7,7,5)
    real(rp), intent(out) :: vec_out_x(7,7**2*5)
    real(rp), intent(out) :: vec_out_y(7,7**2*5)
    real(rp), intent(out) :: vec_out_z(7,7**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 7**2*5
    do i=1, 7
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv) &
                      + mat(i,3) * vec_in_x(3,jkv) &
                      + mat(i,4) * vec_in_x(4,jkv) &
                      + mat(i,5) * vec_in_x(5,jkv) &
                      + mat(i,6) * vec_in_x(6,jkv) &
                      + mat(i,7) * vec_in_x(7,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 7*5
    do j=1, 7
      jkv = j + (kv-1)*35
      do i=1, 7
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) &
                        + vec_in_y(i,3,kv) * mat_tr(3,j) &
                        + vec_in_y(i,4,kv) * mat_tr(4,j) &
                        + vec_in_y(i,5,kv) * mat_tr(5,j) &
                        + vec_in_y(i,6,kv) * mat_tr(6,j) &
                        + vec_in_y(i,7,kv) * mat_tr(7,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 7
    do j=1, 7
      jk = j + (k-1)*7
      do i=1, 7
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) &
                        + vec_in_z(i,j,3,v) * mat_tr(3,k) &
                        + vec_in_z(i,j,4,v) * mat_tr(4,k) &
                        + vec_in_z(i,j,5,v) * mat_tr(5,k) &
                        + vec_in_z(i,j,6,v) * mat_tr(6,k) &
                        + vec_in_z(i,j,7,v) * mat_tr(7,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p6
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=6
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p6( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(7,7)
    real(rp), intent(in) :: mat_h1d_tr(7,7)
    real(rp), intent(in) :: mat_v1d_tr(7,7)
    real(rp), intent(in) :: vec_in(7,7,7)
    real(rp), intent(out) :: vec_work(7,7,7)
    real(rp), intent(out) :: vec_out(7,7,7)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 7
    do j=1, 7
    do i=1, 7
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k) &
                     + mat_h1d(i,3) * vec_in(3,j,k) &
                     + mat_h1d(i,4) * vec_in(4,j,k) &
                     + mat_h1d(i,5) * vec_in(5,j,k) &
                     + mat_h1d(i,6) * vec_in(6,j,k) &
                     + mat_h1d(i,7) * vec_in(7,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 7
    do j=1, 7
    do i=1, 7
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) &
                      + vec_out(i,3,k) * mat_h1d_tr(3,j) &
                      + vec_out(i,4,k) * mat_h1d_tr(4,j) &
                      + vec_out(i,5,k) * mat_h1d_tr(5,j) &
                      + vec_out(i,6,k) * mat_h1d_tr(6,j) &
                      + vec_out(i,7,k) * mat_h1d_tr(7,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 7
    do j=1, 7
    do i=1, 7
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) &
                     + vec_work(i,j,3) * mat_v1d_tr(3,k) &
                     + vec_work(i,j,4) * mat_v1d_tr(4,k) &
                     + vec_work(i,j,5) * mat_v1d_tr(5,k) &
                     + vec_work(i,j,6) * mat_v1d_tr(6,k) &
                     + vec_work(i,j,7) * mat_v1d_tr(7,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p6
 
!--- For p=7 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=7
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p7( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(8,8)
    real(rp), intent(in) :: vec_in(8,8**2)
    real(rp), intent(out) :: vec_out(8,8**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 8**2
    do i=1, 8
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p7
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=7
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p7( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(8,8)
    real(rp), intent(in) :: vec_in(8,8,8)
    real(rp), intent(out) :: vec_out(8,8,8)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 8
    do j=1, 8
    do i=1, 8
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p7
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=7
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p7( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(8,8)
    real(rp), intent(in) :: vec_in(8,8,8)
    real(rp), intent(out) :: vec_out(8,8,8)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 8
    do j=1, 8
    do i=1, 8
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p7
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=7
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p7( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(8,8,8,6)
    real(rp), intent(in) :: vec_in(8,8,6)
    real(rp), intent(out) :: vec_out(8,8,8)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 8
    do j=1, 8
    do i=1, 8
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p7
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=7
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p7( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(8,8)
    real(rp), intent(in) :: mat_tr(8,8)
    real(rp), intent(in) :: vec_in_(8,8**2)
    real(rp), intent(in) :: vec_in(8,8,8)
    real(rp), intent(out) :: vec_out_x(8,8**2)
    real(rp), intent(out) :: vec_out_y(8,8,8)
    real(rp), intent(out) :: vec_out_z(8,8,8)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 8**2
    do i=1, 8
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 8
    do j=1, 8
    do i=1, 8
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 8
    do j=1, 8
    do i=1, 8
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p7
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=7
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p7( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(8,8)
    real(rp), intent(in) :: mat_tr(8,8)
    real(rp), intent(in) :: vec_in_x(8,8**2)
    real(rp), intent(in) :: vec_in_y(8,8,8)
    real(rp), intent(in) :: vec_in_z(8,8,8)
    real(rp), intent(out) :: vec_out_x(8,8**2)
    real(rp), intent(out) :: vec_out_y(8,8**2)
    real(rp), intent(out) :: vec_out_z(8,8**2)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 8**2
    do i=1, 8
      vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
                      + mat(i,2) * vec_in_x(2,jk) &
                      + mat(i,3) * vec_in_x(3,jk) &
                      + mat(i,4) * vec_in_x(4,jk) &
                      + mat(i,5) * vec_in_x(5,jk) &
                      + mat(i,6) * vec_in_x(6,jk) &
                      + mat(i,7) * vec_in_x(7,jk) &
                      + mat(i,8) * vec_in_x(8,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 8
    do j=1, 8
      jk = j + (k-1)*8
      do i=1, 8
        vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
                        + vec_in_y(i,2,k) * mat_tr(2,j) &
                        + vec_in_y(i,3,k) * mat_tr(3,j) &
                        + vec_in_y(i,4,k) * mat_tr(4,j) &
                        + vec_in_y(i,5,k) * mat_tr(5,j) &
                        + vec_in_y(i,6,k) * mat_tr(6,j) &
                        + vec_in_y(i,7,k) * mat_tr(7,j) &
                        + vec_in_y(i,8,k) * mat_tr(8,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 8
    do j=1, 8
      jk = j + (k-1)*8
      do i=1, 8
        vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
                        + vec_in_z(i,j,2) * mat_tr(2,k) &
                        + vec_in_z(i,j,3) * mat_tr(3,k) &
                        + vec_in_z(i,j,4) * mat_tr(4,k) &
                        + vec_in_z(i,j,5) * mat_tr(5,k) &
                        + vec_in_z(i,j,6) * mat_tr(6,k) &
                        + vec_in_z(i,j,7) * mat_tr(7,k) &
                        + vec_in_z(i,j,8) * mat_tr(8,k) 
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p7
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p7( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(8,8)
    real(rp), intent(in) :: mat_tr(8,8)
    real(rp), intent(in) :: vec_in_x(8,8**2*5)
    real(rp), intent(in) :: vec_in_y(8,8,8*5)
    real(rp), intent(in) :: vec_in_z(8,8,8,5)
    real(rp), intent(out) :: vec_out_x(8,8**2*5)
    real(rp), intent(out) :: vec_out_y(8,8**2*5)
    real(rp), intent(out) :: vec_out_z(8,8**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 8**2*5
    do i=1, 8
      vec_out_x(i,jkv) = mat(i,1) * vec_in_x(1,jkv) &
                      + mat(i,2) * vec_in_x(2,jkv) &
                      + mat(i,3) * vec_in_x(3,jkv) &
                      + mat(i,4) * vec_in_x(4,jkv) &
                      + mat(i,5) * vec_in_x(5,jkv) &
                      + mat(i,6) * vec_in_x(6,jkv) &
                      + mat(i,7) * vec_in_x(7,jkv) &
                      + mat(i,8) * vec_in_x(8,jkv)
    end do
    end do
 
    ! Y-dir
    do kv=1, 8*5
    do j=1, 8
      jkv = j + (kv-1)*40
      do i=1, 8
        vec_out_y(i,jkv) = vec_in_y(i,1,kv) * mat_tr(1,j) &
                        + vec_in_y(i,2,kv) * mat_tr(2,j) &
                        + vec_in_y(i,3,kv) * mat_tr(3,j) &
                        + vec_in_y(i,4,kv) * mat_tr(4,j) &
                        + vec_in_y(i,5,kv) * mat_tr(5,j) &
                        + vec_in_y(i,6,kv) * mat_tr(6,j) &
                        + vec_in_y(i,7,kv) * mat_tr(7,j) &
                        + vec_in_y(i,8,kv) * mat_tr(8,j) 
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 8
    do j=1, 8
      jk = j + (k-1)*8
      do i=1, 8
        vec_out_z(i,jk,v) = vec_in_z(i,j,1,v) * mat_tr(1,k) &
                        + vec_in_z(i,j,2,v) * mat_tr(2,k) &
                        + vec_in_z(i,j,3,v) * mat_tr(3,k) &
                        + vec_in_z(i,j,4,v) * mat_tr(4,k) &
                        + vec_in_z(i,j,5,v) * mat_tr(5,k) &
                        + vec_in_z(i,j,6,v) * mat_tr(6,k) &
                        + vec_in_z(i,j,7,v) * mat_tr(7,k) &
                        + vec_in_z(i,j,8,v) * mat_tr(8,k) 
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p7
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=7
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p7( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(8,8)
    real(rp), intent(in) :: mat_h1d_tr(8,8)
    real(rp), intent(in) :: mat_v1d_tr(8,8)
    real(rp), intent(in) :: vec_in(8,8,8)
    real(rp), intent(out) :: vec_work(8,8,8)
    real(rp), intent(out) :: vec_out(8,8,8)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 8
    do j=1, 8
    do i=1, 8
      vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
                     + mat_h1d(i,2) * vec_in(2,j,k) &
                     + mat_h1d(i,3) * vec_in(3,j,k) &
                     + mat_h1d(i,4) * vec_in(4,j,k) &
                     + mat_h1d(i,5) * vec_in(5,j,k) &
                     + mat_h1d(i,6) * vec_in(6,j,k) &
                     + mat_h1d(i,7) * vec_in(7,j,k) &
                     + mat_h1d(i,8) * vec_in(8,j,k)
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 8
    do j=1, 8
    do i=1, 8
      vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
                      + vec_out(i,2,k) * mat_h1d_tr(2,j) &
                      + vec_out(i,3,k) * mat_h1d_tr(3,j) &
                      + vec_out(i,4,k) * mat_h1d_tr(4,j) &
                      + vec_out(i,5,k) * mat_h1d_tr(5,j) &
                      + vec_out(i,6,k) * mat_h1d_tr(6,j) &
                      + vec_out(i,7,k) * mat_h1d_tr(7,j) &
                      + vec_out(i,8,k) * mat_h1d_tr(8,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 8
    do j=1, 8
    do i=1, 8
      vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
                     + vec_work(i,j,2) * mat_v1d_tr(2,k) &
                     + vec_work(i,j,3) * mat_v1d_tr(3,k) &
                     + vec_work(i,j,4) * mat_v1d_tr(4,k) &
                     + vec_work(i,j,5) * mat_v1d_tr(5,k) &
                     + vec_work(i,j,6) * mat_v1d_tr(6,k) &
                     + vec_work(i,j,7) * mat_v1d_tr(7,k) &
                     + vec_work(i,j,8) * mat_v1d_tr(8,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p7
 
!--- For p=8 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=8
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p8( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(9,9)
    real(rp), intent(in) :: vec_in(9,9**2)
    real(rp), intent(out) :: vec_out(9,9**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 9**2
    do i=1, 9
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p8
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=8
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p8( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(9,9)
    real(rp), intent(in) :: vec_in(9,9,9)
    real(rp), intent(out) :: vec_out(9,9,9)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 9
    do j=1, 9
    do i=1, 9
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p8
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=8
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p8( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(9,9)
    real(rp), intent(in) :: vec_in(9,9,9)
    real(rp), intent(out) :: vec_out(9,9,9)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 9
    do j=1, 9
    do i=1, 9
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p8
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=8
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p8( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(9,9,9,6)
    real(rp), intent(in) :: vec_in(9,9,6)
    real(rp), intent(out) :: vec_out(9,9,9)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 9
    do j=1, 9
    do i=1, 9
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p8
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=8
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p8( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(9,9)
    real(rp), intent(in) :: mat_tr(9,9)
    real(rp), intent(in) :: vec_in_(9,9**2)
    real(rp), intent(in) :: vec_in(9,9,9)
    real(rp), intent(out) :: vec_out_x(9,9**2)
    real(rp), intent(out) :: vec_out_y(9,9,9)
    real(rp), intent(out) :: vec_out_z(9,9,9)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 9**2
    do i=1, 9
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 9
    do j=1, 9
    do i=1, 9
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 9
    do j=1, 9
    do i=1, 9
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p8
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=8
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p8( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(9,9)
    real(rp), intent(in) :: mat_tr(9,9)
    real(rp), intent(in) :: vec_in_x(9,9**2)
    real(rp), intent(in) :: vec_in_y(9,9,9)
    real(rp), intent(in) :: vec_in_z(9,9,9)
    real(rp), intent(out) :: vec_out_x(9,9**2)
    real(rp), intent(out) :: vec_out_y(9,9**2)
    real(rp), intent(out) :: vec_out_z(9,9**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 9**2
    do i=1, 9
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk)
      tmp2 = mat(i,4) * vec_in_x(4,jk) &
           + mat(i,5) * vec_in_x(5,jk) &
           + mat(i,6) * vec_in_x(6,jk)
      tmp3 = mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk) &
           + mat(i,9) * vec_in_x(9,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 9
    do j=1, 9
      jk = j + (k-1)*9
      do i=1, 9
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) 
        tmp2 = vec_in_y(i,4,k) * mat_tr(4,j) &
             + vec_in_y(i,5,k) * mat_tr(5,j) &
             + vec_in_y(i,6,k) * mat_tr(6,j) 
        tmp3 = vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) &
             + vec_in_y(i,9,k) * mat_tr(9,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 9
    do j=1, 9
      jk = j + (k-1)*9
      do i=1, 9
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) 
        tmp2 = vec_in_z(i,j,4) * mat_tr(4,k) &
             + vec_in_z(i,j,5) * mat_tr(5,k) &
             + vec_in_z(i,j,6) * mat_tr(6,k) 
        tmp3 = vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) &
             + vec_in_z(i,j,9) * mat_tr(9,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p8
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p8( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(9,9)
    real(rp), intent(in) :: mat_tr(9,9)
    real(rp), intent(in) :: vec_in_x(9,9**2*5)
    real(rp), intent(in) :: vec_in_y(9,9,9*5)
    real(rp), intent(in) :: vec_in_z(9,9,9,5)
    real(rp), intent(out) :: vec_out_x(9,9**2*5)
    real(rp), intent(out) :: vec_out_y(9,9**2*5)
    real(rp), intent(out) :: vec_out_z(9,9**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 9**2*5
    do i=1, 9
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv)
      tmp2 = mat(i,4) * vec_in_x(4,jkv) &
           + mat(i,5) * vec_in_x(5,jkv) &
           + mat(i,6) * vec_in_x(6,jkv)
      tmp3 = mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv) &
           + mat(i,9) * vec_in_x(9,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 9*5
    do j=1, 9
      jkv = j + (kv-1)*45
      do i=1, 9
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) 
        tmp2 = vec_in_y(i,4,kv) * mat_tr(4,j) &
             + vec_in_y(i,5,kv) * mat_tr(5,j) &
             + vec_in_y(i,6,kv) * mat_tr(6,j) 
        tmp3 = vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) &
             + vec_in_y(i,9,kv) * mat_tr(9,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 9
    do j=1, 9
      jk = j + (k-1)*9
      do i=1, 9
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) 
        tmp2 = vec_in_z(i,j,4,v) * mat_tr(4,k) &
             + vec_in_z(i,j,5,v) * mat_tr(5,k) &
             + vec_in_z(i,j,6,v) * mat_tr(6,k) 
        tmp3 = vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) &
             + vec_in_z(i,j,9,v) * mat_tr(9,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p8
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=8
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p8( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(9,9)
    real(rp), intent(in) :: mat_h1d_tr(9,9)
    real(rp), intent(in) :: mat_v1d_tr(9,9)
    real(rp), intent(in) :: vec_in(9,9,9)
    real(rp), intent(out) :: vec_work(9,9,9)
    real(rp), intent(out) :: vec_out(9,9,9)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 9
    do j=1, 9
    do i=1, 9
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k)
      tmp2 = mat_h1d(i,4) * vec_in(4,j,k) &
           + mat_h1d(i,5) * vec_in(5,j,k) &
           + mat_h1d(i,6) * vec_in(6,j,k)
      tmp3 = mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k) &
           + mat_h1d(i,9) * vec_in(9,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 9
    do j=1, 9
    do i=1, 9
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) 
      tmp2 = vec_out(i,4,k) * mat_h1d_tr(4,j) &
           + vec_out(i,5,k) * mat_h1d_tr(5,j) &
           + vec_out(i,6,k) * mat_h1d_tr(6,j) 
      tmp3 = vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) &
           + vec_out(i,9,k) * mat_h1d_tr(9,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 9
    do j=1, 9
    do i=1, 9
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) 
      tmp2 = vec_work(i,j,4) * mat_v1d_tr(4,k) &
           + vec_work(i,j,5) * mat_v1d_tr(5,k) &
           + vec_work(i,j,6) * mat_v1d_tr(6,k) 
      tmp3 = vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) &
           + vec_work(i,j,9) * mat_v1d_tr(9,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p8
 
!--- For p=9 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=9
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p9( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(10,10)
    real(rp), intent(in) :: vec_in(10,10**2)
    real(rp), intent(out) :: vec_out(10,10**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 10**2
    do i=1, 10
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p9
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=9
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p9( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(10,10)
    real(rp), intent(in) :: vec_in(10,10,10)
    real(rp), intent(out) :: vec_out(10,10,10)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 10
    do j=1, 10
    do i=1, 10
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p9
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=9
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p9( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(10,10)
    real(rp), intent(in) :: vec_in(10,10,10)
    real(rp), intent(out) :: vec_out(10,10,10)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 10
    do j=1, 10
    do i=1, 10
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p9
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=9
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p9( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(10,10,10,6)
    real(rp), intent(in) :: vec_in(10,10,6)
    real(rp), intent(out) :: vec_out(10,10,10)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 10
    do j=1, 10
    do i=1, 10
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p9
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=9
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p9( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(10,10)
    real(rp), intent(in) :: mat_tr(10,10)
    real(rp), intent(in) :: vec_in_(10,10**2)
    real(rp), intent(in) :: vec_in(10,10,10)
    real(rp), intent(out) :: vec_out_x(10,10**2)
    real(rp), intent(out) :: vec_out_y(10,10,10)
    real(rp), intent(out) :: vec_out_z(10,10,10)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 10**2
    do i=1, 10
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 10
    do j=1, 10
    do i=1, 10
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 10
    do j=1, 10
    do i=1, 10
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p9
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=9
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p9( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(10,10)
    real(rp), intent(in) :: mat_tr(10,10)
    real(rp), intent(in) :: vec_in_x(10,10**2)
    real(rp), intent(in) :: vec_in_y(10,10,10)
    real(rp), intent(in) :: vec_in_z(10,10,10)
    real(rp), intent(out) :: vec_out_x(10,10**2)
    real(rp), intent(out) :: vec_out_y(10,10**2)
    real(rp), intent(out) :: vec_out_z(10,10**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 10**2
    do i=1, 10
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk)
      tmp2 = mat(i,4) * vec_in_x(4,jk) &
           + mat(i,5) * vec_in_x(5,jk) &
           + mat(i,6) * vec_in_x(6,jk)
      tmp3 = mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk) &
           + mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 10
    do j=1, 10
      jk = j + (k-1)*10
      do i=1, 10
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) 
        tmp2 = vec_in_y(i,4,k) * mat_tr(4,j) &
             + vec_in_y(i,5,k) * mat_tr(5,j) &
             + vec_in_y(i,6,k) * mat_tr(6,j) 
        tmp3 = vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) &
             + vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 10
    do j=1, 10
      jk = j + (k-1)*10
      do i=1, 10
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) 
        tmp2 = vec_in_z(i,j,4) * mat_tr(4,k) &
             + vec_in_z(i,j,5) * mat_tr(5,k) &
             + vec_in_z(i,j,6) * mat_tr(6,k) 
        tmp3 = vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) &
             + vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p9
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p9( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(10,10)
    real(rp), intent(in) :: mat_tr(10,10)
    real(rp), intent(in) :: vec_in_x(10,10**2*5)
    real(rp), intent(in) :: vec_in_y(10,10,10*5)
    real(rp), intent(in) :: vec_in_z(10,10,10,5)
    real(rp), intent(out) :: vec_out_x(10,10**2*5)
    real(rp), intent(out) :: vec_out_y(10,10**2*5)
    real(rp), intent(out) :: vec_out_z(10,10**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 10**2*5
    do i=1, 10
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv)
      tmp2 = mat(i,4) * vec_in_x(4,jkv) &
           + mat(i,5) * vec_in_x(5,jkv) &
           + mat(i,6) * vec_in_x(6,jkv)
      tmp3 = mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv) &
           + mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 10*5
    do j=1, 10
      jkv = j + (kv-1)*50
      do i=1, 10
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) 
        tmp2 = vec_in_y(i,4,kv) * mat_tr(4,j) &
             + vec_in_y(i,5,kv) * mat_tr(5,j) &
             + vec_in_y(i,6,kv) * mat_tr(6,j) 
        tmp3 = vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) &
             + vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 10
    do j=1, 10
      jk = j + (k-1)*10
      do i=1, 10
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) 
        tmp2 = vec_in_z(i,j,4,v) * mat_tr(4,k) &
             + vec_in_z(i,j,5,v) * mat_tr(5,k) &
             + vec_in_z(i,j,6,v) * mat_tr(6,k) 
        tmp3 = vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) &
             + vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p9
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=9
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p9( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(10,10)
    real(rp), intent(in) :: mat_h1d_tr(10,10)
    real(rp), intent(in) :: mat_v1d_tr(10,10)
    real(rp), intent(in) :: vec_in(10,10,10)
    real(rp), intent(out) :: vec_work(10,10,10)
    real(rp), intent(out) :: vec_out(10,10,10)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 10
    do j=1, 10
    do i=1, 10
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k)
      tmp2 = mat_h1d(i,4) * vec_in(4,j,k) &
           + mat_h1d(i,5) * vec_in(5,j,k) &
           + mat_h1d(i,6) * vec_in(6,j,k)
      tmp3 = mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k) &
           + mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 10
    do j=1, 10
    do i=1, 10
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) 
      tmp2 = vec_out(i,4,k) * mat_h1d_tr(4,j) &
           + vec_out(i,5,k) * mat_h1d_tr(5,j) &
           + vec_out(i,6,k) * mat_h1d_tr(6,j) 
      tmp3 = vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) &
           + vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 10
    do j=1, 10
    do i=1, 10
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) 
      tmp2 = vec_work(i,j,4) * mat_v1d_tr(4,k) &
           + vec_work(i,j,5) * mat_v1d_tr(5,k) &
           + vec_work(i,j,6) * mat_v1d_tr(6,k) 
      tmp3 = vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) &
           + vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p9
 
!--- For p=10 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=10
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p10( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(11,11)
    real(rp), intent(in) :: vec_in(11,11**2)
    real(rp), intent(out) :: vec_out(11,11**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 11**2
    do i=1, 11
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk) &
                      + mat_x(i,11) * vec_in(11,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p10
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=10
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p10( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(11,11)
    real(rp), intent(in) :: vec_in(11,11,11)
    real(rp), intent(out) :: vec_out(11,11,11)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 11
    do j=1, 11
    do i=1, 11
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) &
                       + vec_in(i,11,k) * mat_y_tr(11,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p10
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=10
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p10( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(11,11)
    real(rp), intent(in) :: vec_in(11,11,11)
    real(rp), intent(out) :: vec_out(11,11,11)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 11
    do j=1, 11
    do i=1, 11
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) &
                       + vec_in(i,j,11) * mat_z_tr(11,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p10
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=10
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p10( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(11,11,11,6)
    real(rp), intent(in) :: vec_in(11,11,6)
    real(rp), intent(out) :: vec_out(11,11,11)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 11
    do j=1, 11
    do i=1, 11
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p10
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=10
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p10( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(11,11)
    real(rp), intent(in) :: mat_tr(11,11)
    real(rp), intent(in) :: vec_in_(11,11**2)
    real(rp), intent(in) :: vec_in(11,11,11)
    real(rp), intent(out) :: vec_out_x(11,11**2)
    real(rp), intent(out) :: vec_out_y(11,11,11)
    real(rp), intent(out) :: vec_out_z(11,11,11)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 11**2
    do i=1, 11
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk) &
                        + mat(i,11) * vec_in_(11,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 11
    do j=1, 11
    do i=1, 11
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) &
                         + vec_in(i,11,k) * mat_tr(11,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 11
    do j=1, 11
    do i=1, 11
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) &
                         + vec_in(i,j,11) * mat_tr(11,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p10
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=10
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p10( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(11,11)
    real(rp), intent(in) :: mat_tr(11,11)
    real(rp), intent(in) :: vec_in_x(11,11**2)
    real(rp), intent(in) :: vec_in_y(11,11,11)
    real(rp), intent(in) :: vec_in_z(11,11,11)
    real(rp), intent(out) :: vec_out_x(11,11**2)
    real(rp), intent(out) :: vec_out_y(11,11**2)
    real(rp), intent(out) :: vec_out_z(11,11**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 11**2
    do i=1, 11
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk) &
           + mat(i,4) * vec_in_x(4,jk)
      tmp2 = mat(i,5) * vec_in_x(5,jk) &
           + mat(i,6) * vec_in_x(6,jk) &
           + mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk)
      tmp3 = mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk) &
           + mat(i,11) * vec_in_x(11,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 11
    do j=1, 11
      jk = j + (k-1)*11
      do i=1, 11
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) &
             + vec_in_y(i,4,k) * mat_tr(4,j) 
        tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
             + vec_in_y(i,6,k) * mat_tr(6,j) &
             + vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) 
        tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) &
             + vec_in_y(i,11,k) * mat_tr(11,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 11
    do j=1, 11
      jk = j + (k-1)*11
      do i=1, 11
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) &
             + vec_in_z(i,j,4) * mat_tr(4,k) 
        tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
             + vec_in_z(i,j,6) * mat_tr(6,k) &
             + vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) 
        tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) &
             + vec_in_z(i,j,11) * mat_tr(11,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p10
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p10( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(11,11)
    real(rp), intent(in) :: mat_tr(11,11)
    real(rp), intent(in) :: vec_in_x(11,11**2*5)
    real(rp), intent(in) :: vec_in_y(11,11,11*5)
    real(rp), intent(in) :: vec_in_z(11,11,11,5)
    real(rp), intent(out) :: vec_out_x(11,11**2*5)
    real(rp), intent(out) :: vec_out_y(11,11**2*5)
    real(rp), intent(out) :: vec_out_z(11,11**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 11**2*5
    do i=1, 11
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv) &
           + mat(i,4) * vec_in_x(4,jkv)
      tmp2 = mat(i,5) * vec_in_x(5,jkv) &
           + mat(i,6) * vec_in_x(6,jkv) &
           + mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv)
      tmp3 = mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv) &
           + mat(i,11) * vec_in_x(11,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 11*5
    do j=1, 11
      jkv = j + (kv-1)*55
      do i=1, 11
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) &
             + vec_in_y(i,4,kv) * mat_tr(4,j) 
        tmp2 = vec_in_y(i,5,kv) * mat_tr(5,j) &
             + vec_in_y(i,6,kv) * mat_tr(6,j) &
             + vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) 
        tmp3 = vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) &
             + vec_in_y(i,11,kv) * mat_tr(11,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 11
    do j=1, 11
      jk = j + (k-1)*11
      do i=1, 11
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) &
             + vec_in_z(i,j,4,v) * mat_tr(4,k) 
        tmp2 = vec_in_z(i,j,5,v) * mat_tr(5,k) &
             + vec_in_z(i,j,6,v) * mat_tr(6,k) &
             + vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) 
        tmp3 = vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) &
             + vec_in_z(i,j,11,v) * mat_tr(11,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p10
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=10
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p10( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(11,11)
    real(rp), intent(in) :: mat_h1d_tr(11,11)
    real(rp), intent(in) :: mat_v1d_tr(11,11)
    real(rp), intent(in) :: vec_in(11,11,11)
    real(rp), intent(out) :: vec_work(11,11,11)
    real(rp), intent(out) :: vec_out(11,11,11)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 11
    do j=1, 11
    do i=1, 11
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k) &
           + mat_h1d(i,4) * vec_in(4,j,k)
      tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
           + mat_h1d(i,6) * vec_in(6,j,k) &
           + mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k)
      tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k) &
           + mat_h1d(i,11) * vec_in(11,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 11
    do j=1, 11
    do i=1, 11
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) &
           + vec_out(i,4,k) * mat_h1d_tr(4,j) 
      tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
           + vec_out(i,6,k) * mat_h1d_tr(6,j) &
           + vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) 
      tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) &
           + vec_out(i,11,k) * mat_h1d_tr(11,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 11
    do j=1, 11
    do i=1, 11
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) &
           + vec_work(i,j,4) * mat_v1d_tr(4,k) 
      tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
           + vec_work(i,j,6) * mat_v1d_tr(6,k) &
           + vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) 
      tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) &
           + vec_work(i,j,11) * mat_v1d_tr(11,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p10
 
!--- For p=11 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=11
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p11( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(12,12)
    real(rp), intent(in) :: vec_in(12,12**2)
    real(rp), intent(out) :: vec_out(12,12**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 12**2
    do i=1, 12
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk) &
                      + mat_x(i,11) * vec_in(11,jk) &
                      + mat_x(i,12) * vec_in(12,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p11
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=11
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p11( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(12,12)
    real(rp), intent(in) :: vec_in(12,12,12)
    real(rp), intent(out) :: vec_out(12,12,12)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 12
    do j=1, 12
    do i=1, 12
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) &
                       + vec_in(i,11,k) * mat_y_tr(11,j) &
                       + vec_in(i,12,k) * mat_y_tr(12,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p11
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=11
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p11( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(12,12)
    real(rp), intent(in) :: vec_in(12,12,12)
    real(rp), intent(out) :: vec_out(12,12,12)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 12
    do j=1, 12
    do i=1, 12
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) &
                       + vec_in(i,j,11) * mat_z_tr(11,k) &
                       + vec_in(i,j,12) * mat_z_tr(12,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p11
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=11
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p11( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(12,12,12,6)
    real(rp), intent(in) :: vec_in(12,12,6)
    real(rp), intent(out) :: vec_out(12,12,12)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 12
    do j=1, 12
    do i=1, 12
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p11
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=11
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p11( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(12,12)
    real(rp), intent(in) :: mat_tr(12,12)
    real(rp), intent(in) :: vec_in_(12,12**2)
    real(rp), intent(in) :: vec_in(12,12,12)
    real(rp), intent(out) :: vec_out_x(12,12**2)
    real(rp), intent(out) :: vec_out_y(12,12,12)
    real(rp), intent(out) :: vec_out_z(12,12,12)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 12**2
    do i=1, 12
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk) &
                        + mat(i,11) * vec_in_(11,jk) &
                        + mat(i,12) * vec_in_(12,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 12
    do j=1, 12
    do i=1, 12
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) &
                         + vec_in(i,11,k) * mat_tr(11,j) &
                         + vec_in(i,12,k) * mat_tr(12,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 12
    do j=1, 12
    do i=1, 12
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) &
                         + vec_in(i,j,11) * mat_tr(11,k) &
                         + vec_in(i,j,12) * mat_tr(12,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p11
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=11
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p11( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(12,12)
    real(rp), intent(in) :: mat_tr(12,12)
    real(rp), intent(in) :: vec_in_x(12,12**2)
    real(rp), intent(in) :: vec_in_y(12,12,12)
    real(rp), intent(in) :: vec_in_z(12,12,12)
    real(rp), intent(out) :: vec_out_x(12,12**2)
    real(rp), intent(out) :: vec_out_y(12,12**2)
    real(rp), intent(out) :: vec_out_z(12,12**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 12**2
    do i=1, 12
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk) &
           + mat(i,4) * vec_in_x(4,jk)
      tmp2 = mat(i,5) * vec_in_x(5,jk) &
           + mat(i,6) * vec_in_x(6,jk) &
           + mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk)
      tmp3 = mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk) &
           + mat(i,11) * vec_in_x(11,jk) &
           + mat(i,12) * vec_in_x(12,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 12
    do j=1, 12
      jk = j + (k-1)*12
      do i=1, 12
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) &
             + vec_in_y(i,4,k) * mat_tr(4,j) 
        tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
             + vec_in_y(i,6,k) * mat_tr(6,j) &
             + vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) 
        tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) &
             + vec_in_y(i,11,k) * mat_tr(11,j) &
             + vec_in_y(i,12,k) * mat_tr(12,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 12
    do j=1, 12
      jk = j + (k-1)*12
      do i=1, 12
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) &
             + vec_in_z(i,j,4) * mat_tr(4,k) 
        tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
             + vec_in_z(i,j,6) * mat_tr(6,k) &
             + vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) 
        tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) &
             + vec_in_z(i,j,11) * mat_tr(11,k) &
             + vec_in_z(i,j,12) * mat_tr(12,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p11
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p11( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(12,12)
    real(rp), intent(in) :: mat_tr(12,12)
    real(rp), intent(in) :: vec_in_x(12,12**2*5)
    real(rp), intent(in) :: vec_in_y(12,12,12*5)
    real(rp), intent(in) :: vec_in_z(12,12,12,5)
    real(rp), intent(out) :: vec_out_x(12,12**2*5)
    real(rp), intent(out) :: vec_out_y(12,12**2*5)
    real(rp), intent(out) :: vec_out_z(12,12**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 12**2*5
    do i=1, 12
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv) &
           + mat(i,4) * vec_in_x(4,jkv)
      tmp2 = mat(i,5) * vec_in_x(5,jkv) &
           + mat(i,6) * vec_in_x(6,jkv) &
           + mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv)
      tmp3 = mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv) &
           + mat(i,11) * vec_in_x(11,jkv) &
           + mat(i,12) * vec_in_x(12,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 12*5
    do j=1, 12
      jkv = j + (kv-1)*60
      do i=1, 12
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) &
             + vec_in_y(i,4,kv) * mat_tr(4,j) 
        tmp2 = vec_in_y(i,5,kv) * mat_tr(5,j) &
             + vec_in_y(i,6,kv) * mat_tr(6,j) &
             + vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) 
        tmp3 = vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) &
             + vec_in_y(i,11,kv) * mat_tr(11,j) &
             + vec_in_y(i,12,kv) * mat_tr(12,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 12
    do j=1, 12
      jk = j + (k-1)*12
      do i=1, 12
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) &
             + vec_in_z(i,j,4,v) * mat_tr(4,k) 
        tmp2 = vec_in_z(i,j,5,v) * mat_tr(5,k) &
             + vec_in_z(i,j,6,v) * mat_tr(6,k) &
             + vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) 
        tmp3 = vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) &
             + vec_in_z(i,j,11,v) * mat_tr(11,k) &
             + vec_in_z(i,j,12,v) * mat_tr(12,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p11
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=11
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p11( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(12,12)
    real(rp), intent(in) :: mat_h1d_tr(12,12)
    real(rp), intent(in) :: mat_v1d_tr(12,12)
    real(rp), intent(in) :: vec_in(12,12,12)
    real(rp), intent(out) :: vec_work(12,12,12)
    real(rp), intent(out) :: vec_out(12,12,12)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 12
    do j=1, 12
    do i=1, 12
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k) &
           + mat_h1d(i,4) * vec_in(4,j,k)
      tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
           + mat_h1d(i,6) * vec_in(6,j,k) &
           + mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k)
      tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k) &
           + mat_h1d(i,11) * vec_in(11,j,k) &
           + mat_h1d(i,12) * vec_in(12,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 12
    do j=1, 12
    do i=1, 12
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) &
           + vec_out(i,4,k) * mat_h1d_tr(4,j) 
      tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
           + vec_out(i,6,k) * mat_h1d_tr(6,j) &
           + vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) 
      tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) &
           + vec_out(i,11,k) * mat_h1d_tr(11,j) &
           + vec_out(i,12,k) * mat_h1d_tr(12,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 12
    do j=1, 12
    do i=1, 12
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) &
           + vec_work(i,j,4) * mat_v1d_tr(4,k) 
      tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
           + vec_work(i,j,6) * mat_v1d_tr(6,k) &
           + vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) 
      tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) &
           + vec_work(i,j,11) * mat_v1d_tr(11,k) &
           + vec_work(i,j,12) * mat_v1d_tr(12,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p11
 
!--- For p=12 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=12
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p12( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(13,13)
    real(rp), intent(in) :: vec_in(13,13**2)
    real(rp), intent(out) :: vec_out(13,13**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 13**2
    do i=1, 13
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk) &
                      + mat_x(i,11) * vec_in(11,jk) &
                      + mat_x(i,12) * vec_in(12,jk) &
                      + mat_x(i,13) * vec_in(13,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p12
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=12
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p12( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(13,13)
    real(rp), intent(in) :: vec_in(13,13,13)
    real(rp), intent(out) :: vec_out(13,13,13)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 13
    do j=1, 13
    do i=1, 13
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) &
                       + vec_in(i,11,k) * mat_y_tr(11,j) &
                       + vec_in(i,12,k) * mat_y_tr(12,j) &
                       + vec_in(i,13,k) * mat_y_tr(13,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p12
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=12
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p12( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(13,13)
    real(rp), intent(in) :: vec_in(13,13,13)
    real(rp), intent(out) :: vec_out(13,13,13)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 13
    do j=1, 13
    do i=1, 13
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) &
                       + vec_in(i,j,11) * mat_z_tr(11,k) &
                       + vec_in(i,j,12) * mat_z_tr(12,k) &
                       + vec_in(i,j,13) * mat_z_tr(13,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p12
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=12
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p12( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(13,13,13,6)
    real(rp), intent(in) :: vec_in(13,13,6)
    real(rp), intent(out) :: vec_out(13,13,13)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 13
    do j=1, 13
    do i=1, 13
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p12
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=12
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p12( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(13,13)
    real(rp), intent(in) :: mat_tr(13,13)
    real(rp), intent(in) :: vec_in_(13,13**2)
    real(rp), intent(in) :: vec_in(13,13,13)
    real(rp), intent(out) :: vec_out_x(13,13**2)
    real(rp), intent(out) :: vec_out_y(13,13,13)
    real(rp), intent(out) :: vec_out_z(13,13,13)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 13**2
    do i=1, 13
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk) &
                        + mat(i,11) * vec_in_(11,jk) &
                        + mat(i,12) * vec_in_(12,jk) &
                        + mat(i,13) * vec_in_(13,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 13
    do j=1, 13
    do i=1, 13
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) &
                         + vec_in(i,11,k) * mat_tr(11,j) &
                         + vec_in(i,12,k) * mat_tr(12,j) &
                         + vec_in(i,13,k) * mat_tr(13,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 13
    do j=1, 13
    do i=1, 13
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) &
                         + vec_in(i,j,11) * mat_tr(11,k) &
                         + vec_in(i,j,12) * mat_tr(12,k) &
                         + vec_in(i,j,13) * mat_tr(13,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p12
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=12
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p12( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(13,13)
    real(rp), intent(in) :: mat_tr(13,13)
    real(rp), intent(in) :: vec_in_x(13,13**2)
    real(rp), intent(in) :: vec_in_y(13,13,13)
    real(rp), intent(in) :: vec_in_z(13,13,13)
    real(rp), intent(out) :: vec_out_x(13,13**2)
    real(rp), intent(out) :: vec_out_y(13,13**2)
    real(rp), intent(out) :: vec_out_z(13,13**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 13**2
    do i=1, 13
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk) &
           + mat(i,4) * vec_in_x(4,jk)
      tmp2 = mat(i,5) * vec_in_x(5,jk) &
           + mat(i,6) * vec_in_x(6,jk) &
           + mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk)
      tmp3 = mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk) &
           + mat(i,11) * vec_in_x(11,jk) &
           + mat(i,12) * vec_in_x(12,jk) &
           + mat(i,13) * vec_in_x(13,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 13
    do j=1, 13
      jk = j + (k-1)*13
      do i=1, 13
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) &
             + vec_in_y(i,4,k) * mat_tr(4,j) 
        tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
             + vec_in_y(i,6,k) * mat_tr(6,j) &
             + vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) 
        tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) &
             + vec_in_y(i,11,k) * mat_tr(11,j) &
             + vec_in_y(i,12,k) * mat_tr(12,j) &
             + vec_in_y(i,13,k) * mat_tr(13,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 13
    do j=1, 13
      jk = j + (k-1)*13
      do i=1, 13
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) &
             + vec_in_z(i,j,4) * mat_tr(4,k) 
        tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
             + vec_in_z(i,j,6) * mat_tr(6,k) &
             + vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) 
        tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) &
             + vec_in_z(i,j,11) * mat_tr(11,k) &
             + vec_in_z(i,j,12) * mat_tr(12,k) &
             + vec_in_z(i,j,13) * mat_tr(13,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p12
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p12( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(13,13)
    real(rp), intent(in) :: mat_tr(13,13)
    real(rp), intent(in) :: vec_in_x(13,13**2*5)
    real(rp), intent(in) :: vec_in_y(13,13,13*5)
    real(rp), intent(in) :: vec_in_z(13,13,13,5)
    real(rp), intent(out) :: vec_out_x(13,13**2*5)
    real(rp), intent(out) :: vec_out_y(13,13**2*5)
    real(rp), intent(out) :: vec_out_z(13,13**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 13**2*5
    do i=1, 13
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv) &
           + mat(i,4) * vec_in_x(4,jkv)
      tmp2 = mat(i,5) * vec_in_x(5,jkv) &
           + mat(i,6) * vec_in_x(6,jkv) &
           + mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv)
      tmp3 = mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv) &
           + mat(i,11) * vec_in_x(11,jkv) &
           + mat(i,12) * vec_in_x(12,jkv) &
           + mat(i,13) * vec_in_x(13,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 13*5
    do j=1, 13
      jkv = j + (kv-1)*65
      do i=1, 13
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) &
             + vec_in_y(i,4,kv) * mat_tr(4,j) 
        tmp2 = vec_in_y(i,5,kv) * mat_tr(5,j) &
             + vec_in_y(i,6,kv) * mat_tr(6,j) &
             + vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) 
        tmp3 = vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) &
             + vec_in_y(i,11,kv) * mat_tr(11,j) &
             + vec_in_y(i,12,kv) * mat_tr(12,j) &
             + vec_in_y(i,13,kv) * mat_tr(13,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 13
    do j=1, 13
      jk = j + (k-1)*13
      do i=1, 13
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) &
             + vec_in_z(i,j,4,v) * mat_tr(4,k) 
        tmp2 = vec_in_z(i,j,5,v) * mat_tr(5,k) &
             + vec_in_z(i,j,6,v) * mat_tr(6,k) &
             + vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) 
        tmp3 = vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) &
             + vec_in_z(i,j,11,v) * mat_tr(11,k) &
             + vec_in_z(i,j,12,v) * mat_tr(12,k) &
             + vec_in_z(i,j,13,v) * mat_tr(13,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p12
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=12
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p12( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(13,13)
    real(rp), intent(in) :: mat_h1d_tr(13,13)
    real(rp), intent(in) :: mat_v1d_tr(13,13)
    real(rp), intent(in) :: vec_in(13,13,13)
    real(rp), intent(out) :: vec_work(13,13,13)
    real(rp), intent(out) :: vec_out(13,13,13)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 13
    do j=1, 13
    do i=1, 13
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k) &
           + mat_h1d(i,4) * vec_in(4,j,k)
      tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
           + mat_h1d(i,6) * vec_in(6,j,k) &
           + mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k)
      tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k) &
           + mat_h1d(i,11) * vec_in(11,j,k) &
           + mat_h1d(i,12) * vec_in(12,j,k) &
           + mat_h1d(i,13) * vec_in(13,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 13
    do j=1, 13
    do i=1, 13
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) &
           + vec_out(i,4,k) * mat_h1d_tr(4,j) 
      tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
           + vec_out(i,6,k) * mat_h1d_tr(6,j) &
           + vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) 
      tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) &
           + vec_out(i,11,k) * mat_h1d_tr(11,j) &
           + vec_out(i,12,k) * mat_h1d_tr(12,j) &
           + vec_out(i,13,k) * mat_h1d_tr(13,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 13
    do j=1, 13
    do i=1, 13
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) &
           + vec_work(i,j,4) * mat_v1d_tr(4,k) 
      tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
           + vec_work(i,j,6) * mat_v1d_tr(6,k) &
           + vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) 
      tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) &
           + vec_work(i,j,11) * mat_v1d_tr(11,k) &
           + vec_work(i,j,12) * mat_v1d_tr(12,k) &
           + vec_work(i,j,13) * mat_v1d_tr(13,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p12
 
!--- For p=13 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=13
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p13( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(14,14)
    real(rp), intent(in) :: vec_in(14,14**2)
    real(rp), intent(out) :: vec_out(14,14**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 14**2
    do i=1, 14
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk) &
                      + mat_x(i,11) * vec_in(11,jk) &
                      + mat_x(i,12) * vec_in(12,jk) &
                      + mat_x(i,13) * vec_in(13,jk) &
                      + mat_x(i,14) * vec_in(14,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p13
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=13
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p13( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(14,14)
    real(rp), intent(in) :: vec_in(14,14,14)
    real(rp), intent(out) :: vec_out(14,14,14)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 14
    do j=1, 14
    do i=1, 14
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) &
                       + vec_in(i,11,k) * mat_y_tr(11,j) &
                       + vec_in(i,12,k) * mat_y_tr(12,j) &
                       + vec_in(i,13,k) * mat_y_tr(13,j) &
                       + vec_in(i,14,k) * mat_y_tr(14,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p13
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=13
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p13( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(14,14)
    real(rp), intent(in) :: vec_in(14,14,14)
    real(rp), intent(out) :: vec_out(14,14,14)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 14
    do j=1, 14
    do i=1, 14
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) &
                       + vec_in(i,j,11) * mat_z_tr(11,k) &
                       + vec_in(i,j,12) * mat_z_tr(12,k) &
                       + vec_in(i,j,13) * mat_z_tr(13,k) &
                       + vec_in(i,j,14) * mat_z_tr(14,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p13
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=13
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p13( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(14,14,14,6)
    real(rp), intent(in) :: vec_in(14,14,6)
    real(rp), intent(out) :: vec_out(14,14,14)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 14
    do j=1, 14
    do i=1, 14
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p13
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=13
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p13( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(14,14)
    real(rp), intent(in) :: mat_tr(14,14)
    real(rp), intent(in) :: vec_in_(14,14**2)
    real(rp), intent(in) :: vec_in(14,14,14)
    real(rp), intent(out) :: vec_out_x(14,14**2)
    real(rp), intent(out) :: vec_out_y(14,14,14)
    real(rp), intent(out) :: vec_out_z(14,14,14)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 14**2
    do i=1, 14
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk) &
                        + mat(i,11) * vec_in_(11,jk) &
                        + mat(i,12) * vec_in_(12,jk) &
                        + mat(i,13) * vec_in_(13,jk) &
                        + mat(i,14) * vec_in_(14,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 14
    do j=1, 14
    do i=1, 14
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) &
                         + vec_in(i,11,k) * mat_tr(11,j) &
                         + vec_in(i,12,k) * mat_tr(12,j) &
                         + vec_in(i,13,k) * mat_tr(13,j) &
                         + vec_in(i,14,k) * mat_tr(14,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 14
    do j=1, 14
    do i=1, 14
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) &
                         + vec_in(i,j,11) * mat_tr(11,k) &
                         + vec_in(i,j,12) * mat_tr(12,k) &
                         + vec_in(i,j,13) * mat_tr(13,k) &
                         + vec_in(i,j,14) * mat_tr(14,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p13
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=13
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p13( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(14,14)
    real(rp), intent(in) :: mat_tr(14,14)
    real(rp), intent(in) :: vec_in_x(14,14**2)
    real(rp), intent(in) :: vec_in_y(14,14,14)
    real(rp), intent(in) :: vec_in_z(14,14,14)
    real(rp), intent(out) :: vec_out_x(14,14**2)
    real(rp), intent(out) :: vec_out_y(14,14**2)
    real(rp), intent(out) :: vec_out_z(14,14**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 14**2
    do i=1, 14
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk) &
           + mat(i,4) * vec_in_x(4,jk) &
           + mat(i,5) * vec_in_x(5,jk)
      tmp2 = mat(i,6) * vec_in_x(6,jk) &
           + mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk) &
           + mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk)
      tmp3 = mat(i,11) * vec_in_x(11,jk) &
           + mat(i,12) * vec_in_x(12,jk) &
           + mat(i,13) * vec_in_x(13,jk) &
           + mat(i,14) * vec_in_x(14,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 14
    do j=1, 14
      jk = j + (k-1)*14
      do i=1, 14
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) &
             + vec_in_y(i,4,k) * mat_tr(4,j) &
             + vec_in_y(i,5,k) * mat_tr(5,j) 
        tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
             + vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) &
             + vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) 
        tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
             + vec_in_y(i,12,k) * mat_tr(12,j) &
             + vec_in_y(i,13,k) * mat_tr(13,j) &
             + vec_in_y(i,14,k) * mat_tr(14,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 14
    do j=1, 14
      jk = j + (k-1)*14
      do i=1, 14
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) &
             + vec_in_z(i,j,4) * mat_tr(4,k) &
             + vec_in_z(i,j,5) * mat_tr(5,k) 
        tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
             + vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) &
             + vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) 
        tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
             + vec_in_z(i,j,12) * mat_tr(12,k) &
             + vec_in_z(i,j,13) * mat_tr(13,k) &
             + vec_in_z(i,j,14) * mat_tr(14,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p13
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p13( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(14,14)
    real(rp), intent(in) :: mat_tr(14,14)
    real(rp), intent(in) :: vec_in_x(14,14**2*5)
    real(rp), intent(in) :: vec_in_y(14,14,14*5)
    real(rp), intent(in) :: vec_in_z(14,14,14,5)
    real(rp), intent(out) :: vec_out_x(14,14**2*5)
    real(rp), intent(out) :: vec_out_y(14,14**2*5)
    real(rp), intent(out) :: vec_out_z(14,14**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 14**2*5
    do i=1, 14
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv) &
           + mat(i,4) * vec_in_x(4,jkv) &
           + mat(i,5) * vec_in_x(5,jkv)
      tmp2 = mat(i,6) * vec_in_x(6,jkv) &
           + mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv) &
           + mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv)
      tmp3 = mat(i,11) * vec_in_x(11,jkv) &
           + mat(i,12) * vec_in_x(12,jkv) &
           + mat(i,13) * vec_in_x(13,jkv) &
           + mat(i,14) * vec_in_x(14,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 14*5
    do j=1, 14
      jkv = j + (kv-1)*70
      do i=1, 14
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) &
             + vec_in_y(i,4,kv) * mat_tr(4,j) &
             + vec_in_y(i,5,kv) * mat_tr(5,j) 
        tmp2 = vec_in_y(i,6,kv) * mat_tr(6,j) &
             + vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) &
             + vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) 
        tmp3 = vec_in_y(i,11,kv) * mat_tr(11,j) &
             + vec_in_y(i,12,kv) * mat_tr(12,j) &
             + vec_in_y(i,13,kv) * mat_tr(13,j) &
             + vec_in_y(i,14,kv) * mat_tr(14,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 14
    do j=1, 14
      jk = j + (k-1)*14
      do i=1, 14
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) &
             + vec_in_z(i,j,4,v) * mat_tr(4,k) &
             + vec_in_z(i,j,5,v) * mat_tr(5,k) 
        tmp2 = vec_in_z(i,j,6,v) * mat_tr(6,k) &
             + vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) &
             + vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) 
        tmp3 = vec_in_z(i,j,11,v) * mat_tr(11,k) &
             + vec_in_z(i,j,12,v) * mat_tr(12,k) &
             + vec_in_z(i,j,13,v) * mat_tr(13,k) &
             + vec_in_z(i,j,14,v) * mat_tr(14,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p13
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=13
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p13( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(14,14)
    real(rp), intent(in) :: mat_h1d_tr(14,14)
    real(rp), intent(in) :: mat_v1d_tr(14,14)
    real(rp), intent(in) :: vec_in(14,14,14)
    real(rp), intent(out) :: vec_work(14,14,14)
    real(rp), intent(out) :: vec_out(14,14,14)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 14
    do j=1, 14
    do i=1, 14
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k) &
           + mat_h1d(i,4) * vec_in(4,j,k) &
           + mat_h1d(i,5) * vec_in(5,j,k)
      tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
           + mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k) &
           + mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k)
      tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
           + mat_h1d(i,12) * vec_in(12,j,k) &
           + mat_h1d(i,13) * vec_in(13,j,k) &
           + mat_h1d(i,14) * vec_in(14,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 14
    do j=1, 14
    do i=1, 14
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) &
           + vec_out(i,4,k) * mat_h1d_tr(4,j) &
           + vec_out(i,5,k) * mat_h1d_tr(5,j) 
      tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
           + vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) &
           + vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) 
      tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
           + vec_out(i,12,k) * mat_h1d_tr(12,j) &
           + vec_out(i,13,k) * mat_h1d_tr(13,j) &
           + vec_out(i,14,k) * mat_h1d_tr(14,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 14
    do j=1, 14
    do i=1, 14
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) &
           + vec_work(i,j,4) * mat_v1d_tr(4,k) &
           + vec_work(i,j,5) * mat_v1d_tr(5,k) 
      tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
           + vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) &
           + vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) 
      tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
           + vec_work(i,j,12) * mat_v1d_tr(12,k) &
           + vec_work(i,j,13) * mat_v1d_tr(13,k) &
           + vec_work(i,j,14) * mat_v1d_tr(14,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p13
 
!--- For p=14 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=14
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p14( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(15,15)
    real(rp), intent(in) :: vec_in(15,15**2)
    real(rp), intent(out) :: vec_out(15,15**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 15**2
    do i=1, 15
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk) &
                      + mat_x(i,11) * vec_in(11,jk) &
                      + mat_x(i,12) * vec_in(12,jk) &
                      + mat_x(i,13) * vec_in(13,jk) &
                      + mat_x(i,14) * vec_in(14,jk) &
                      + mat_x(i,15) * vec_in(15,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p14
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=14
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p14( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(15,15)
    real(rp), intent(in) :: vec_in(15,15,15)
    real(rp), intent(out) :: vec_out(15,15,15)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 15
    do j=1, 15
    do i=1, 15
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) &
                       + vec_in(i,11,k) * mat_y_tr(11,j) &
                       + vec_in(i,12,k) * mat_y_tr(12,j) &
                       + vec_in(i,13,k) * mat_y_tr(13,j) &
                       + vec_in(i,14,k) * mat_y_tr(14,j) &
                       + vec_in(i,15,k) * mat_y_tr(15,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p14
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=14
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p14( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(15,15)
    real(rp), intent(in) :: vec_in(15,15,15)
    real(rp), intent(out) :: vec_out(15,15,15)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 15
    do j=1, 15
    do i=1, 15
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) &
                       + vec_in(i,j,11) * mat_z_tr(11,k) &
                       + vec_in(i,j,12) * mat_z_tr(12,k) &
                       + vec_in(i,j,13) * mat_z_tr(13,k) &
                       + vec_in(i,j,14) * mat_z_tr(14,k) &
                       + vec_in(i,j,15) * mat_z_tr(15,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p14
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=14
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p14( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(15,15,15,6)
    real(rp), intent(in) :: vec_in(15,15,6)
    real(rp), intent(out) :: vec_out(15,15,15)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 15
    do j=1, 15
    do i=1, 15
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p14
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=14
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p14( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(15,15)
    real(rp), intent(in) :: mat_tr(15,15)
    real(rp), intent(in) :: vec_in_(15,15**2)
    real(rp), intent(in) :: vec_in(15,15,15)
    real(rp), intent(out) :: vec_out_x(15,15**2)
    real(rp), intent(out) :: vec_out_y(15,15,15)
    real(rp), intent(out) :: vec_out_z(15,15,15)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 15**2
    do i=1, 15
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk) &
                        + mat(i,11) * vec_in_(11,jk) &
                        + mat(i,12) * vec_in_(12,jk) &
                        + mat(i,13) * vec_in_(13,jk) &
                        + mat(i,14) * vec_in_(14,jk) &
                        + mat(i,15) * vec_in_(15,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 15
    do j=1, 15
    do i=1, 15
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) &
                         + vec_in(i,11,k) * mat_tr(11,j) &
                         + vec_in(i,12,k) * mat_tr(12,j) &
                         + vec_in(i,13,k) * mat_tr(13,j) &
                         + vec_in(i,14,k) * mat_tr(14,j) &
                         + vec_in(i,15,k) * mat_tr(15,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 15
    do j=1, 15
    do i=1, 15
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) &
                         + vec_in(i,j,11) * mat_tr(11,k) &
                         + vec_in(i,j,12) * mat_tr(12,k) &
                         + vec_in(i,j,13) * mat_tr(13,k) &
                         + vec_in(i,j,14) * mat_tr(14,k) &
                         + vec_in(i,j,15) * mat_tr(15,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p14
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=14
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p14( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(15,15)
    real(rp), intent(in) :: mat_tr(15,15)
    real(rp), intent(in) :: vec_in_x(15,15**2)
    real(rp), intent(in) :: vec_in_y(15,15,15)
    real(rp), intent(in) :: vec_in_z(15,15,15)
    real(rp), intent(out) :: vec_out_x(15,15**2)
    real(rp), intent(out) :: vec_out_y(15,15**2)
    real(rp), intent(out) :: vec_out_z(15,15**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 15**2
    do i=1, 15
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk) &
           + mat(i,4) * vec_in_x(4,jk) &
           + mat(i,5) * vec_in_x(5,jk)
      tmp2 = mat(i,6) * vec_in_x(6,jk) &
           + mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk) &
           + mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk)
      tmp3 = mat(i,11) * vec_in_x(11,jk) &
           + mat(i,12) * vec_in_x(12,jk) &
           + mat(i,13) * vec_in_x(13,jk) &
           + mat(i,14) * vec_in_x(14,jk) &
           + mat(i,15) * vec_in_x(15,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 15
    do j=1, 15
      jk = j + (k-1)*15
      do i=1, 15
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) &
             + vec_in_y(i,4,k) * mat_tr(4,j) &
             + vec_in_y(i,5,k) * mat_tr(5,j) 
        tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
             + vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) &
             + vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) 
        tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
             + vec_in_y(i,12,k) * mat_tr(12,j) &
             + vec_in_y(i,13,k) * mat_tr(13,j) &
             + vec_in_y(i,14,k) * mat_tr(14,j) &
             + vec_in_y(i,15,k) * mat_tr(15,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 15
    do j=1, 15
      jk = j + (k-1)*15
      do i=1, 15
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) &
             + vec_in_z(i,j,4) * mat_tr(4,k) &
             + vec_in_z(i,j,5) * mat_tr(5,k) 
        tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
             + vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) &
             + vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) 
        tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
             + vec_in_z(i,j,12) * mat_tr(12,k) &
             + vec_in_z(i,j,13) * mat_tr(13,k) &
             + vec_in_z(i,j,14) * mat_tr(14,k) &
             + vec_in_z(i,j,15) * mat_tr(15,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p14
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p14( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(15,15)
    real(rp), intent(in) :: mat_tr(15,15)
    real(rp), intent(in) :: vec_in_x(15,15**2*5)
    real(rp), intent(in) :: vec_in_y(15,15,15*5)
    real(rp), intent(in) :: vec_in_z(15,15,15,5)
    real(rp), intent(out) :: vec_out_x(15,15**2*5)
    real(rp), intent(out) :: vec_out_y(15,15**2*5)
    real(rp), intent(out) :: vec_out_z(15,15**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 15**2*5
    do i=1, 15
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv) &
           + mat(i,4) * vec_in_x(4,jkv) &
           + mat(i,5) * vec_in_x(5,jkv)
      tmp2 = mat(i,6) * vec_in_x(6,jkv) &
           + mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv) &
           + mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv)
      tmp3 = mat(i,11) * vec_in_x(11,jkv) &
           + mat(i,12) * vec_in_x(12,jkv) &
           + mat(i,13) * vec_in_x(13,jkv) &
           + mat(i,14) * vec_in_x(14,jkv) &
           + mat(i,15) * vec_in_x(15,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 15*5
    do j=1, 15
      jkv = j + (kv-1)*75
      do i=1, 15
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) &
             + vec_in_y(i,4,kv) * mat_tr(4,j) &
             + vec_in_y(i,5,kv) * mat_tr(5,j) 
        tmp2 = vec_in_y(i,6,kv) * mat_tr(6,j) &
             + vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) &
             + vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) 
        tmp3 = vec_in_y(i,11,kv) * mat_tr(11,j) &
             + vec_in_y(i,12,kv) * mat_tr(12,j) &
             + vec_in_y(i,13,kv) * mat_tr(13,j) &
             + vec_in_y(i,14,kv) * mat_tr(14,j) &
             + vec_in_y(i,15,kv) * mat_tr(15,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 15
    do j=1, 15
      jk = j + (k-1)*15
      do i=1, 15
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) &
             + vec_in_z(i,j,4,v) * mat_tr(4,k) &
             + vec_in_z(i,j,5,v) * mat_tr(5,k) 
        tmp2 = vec_in_z(i,j,6,v) * mat_tr(6,k) &
             + vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) &
             + vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) 
        tmp3 = vec_in_z(i,j,11,v) * mat_tr(11,k) &
             + vec_in_z(i,j,12,v) * mat_tr(12,k) &
             + vec_in_z(i,j,13,v) * mat_tr(13,k) &
             + vec_in_z(i,j,14,v) * mat_tr(14,k) &
             + vec_in_z(i,j,15,v) * mat_tr(15,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p14
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=14
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p14( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(15,15)
    real(rp), intent(in) :: mat_h1d_tr(15,15)
    real(rp), intent(in) :: mat_v1d_tr(15,15)
    real(rp), intent(in) :: vec_in(15,15,15)
    real(rp), intent(out) :: vec_work(15,15,15)
    real(rp), intent(out) :: vec_out(15,15,15)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 15
    do j=1, 15
    do i=1, 15
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k) &
           + mat_h1d(i,4) * vec_in(4,j,k) &
           + mat_h1d(i,5) * vec_in(5,j,k)
      tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
           + mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k) &
           + mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k)
      tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
           + mat_h1d(i,12) * vec_in(12,j,k) &
           + mat_h1d(i,13) * vec_in(13,j,k) &
           + mat_h1d(i,14) * vec_in(14,j,k) &
           + mat_h1d(i,15) * vec_in(15,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 15
    do j=1, 15
    do i=1, 15
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) &
           + vec_out(i,4,k) * mat_h1d_tr(4,j) &
           + vec_out(i,5,k) * mat_h1d_tr(5,j) 
      tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
           + vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) &
           + vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) 
      tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
           + vec_out(i,12,k) * mat_h1d_tr(12,j) &
           + vec_out(i,13,k) * mat_h1d_tr(13,j) &
           + vec_out(i,14,k) * mat_h1d_tr(14,j) &
           + vec_out(i,15,k) * mat_h1d_tr(15,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 15
    do j=1, 15
    do i=1, 15
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) &
           + vec_work(i,j,4) * mat_v1d_tr(4,k) &
           + vec_work(i,j,5) * mat_v1d_tr(5,k) 
      tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
           + vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) &
           + vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) 
      tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
           + vec_work(i,j,12) * mat_v1d_tr(12,k) &
           + vec_work(i,j,13) * mat_v1d_tr(13,k) &
           + vec_work(i,j,14) * mat_v1d_tr(14,k) &
           + vec_work(i,j,15) * mat_v1d_tr(15,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p14
 
!--- For p=15 ------------------------------------
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=15
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirx_p15( Mat_x, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_x(16,16)
    real(rp), intent(in) :: vec_in(16,16**2)
    real(rp), intent(out) :: vec_out(16,16**2)
 
    integer :: i, jk
    !----------------------------------------------------------
 
    do jk=1, 16**2
    do i=1, 16
        vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
                      + mat_x(i,2) * vec_in(2,jk) &
                      + mat_x(i,3) * vec_in(3,jk) &
                      + mat_x(i,4) * vec_in(4,jk) &
                      + mat_x(i,5) * vec_in(5,jk) &
                      + mat_x(i,6) * vec_in(6,jk) &
                      + mat_x(i,7) * vec_in(7,jk) &
                      + mat_x(i,8) * vec_in(8,jk) &
                      + mat_x(i,9) * vec_in(9,jk) &
                      + mat_x(i,10) * vec_in(10,jk) &
                      + mat_x(i,11) * vec_in(11,jk) &
                      + mat_x(i,12) * vec_in(12,jk) &
                      + mat_x(i,13) * vec_in(13,jk) &
                      + mat_x(i,14) * vec_in(14,jk) &
                      + mat_x(i,15) * vec_in(15,jk) &
                      + mat_x(i,16) * vec_in(16,jk)
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirx_p15
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the y direction (second dimension of vec_in) with p=15
!! For a matrix-vector multiplication (vec_out = Mat_y vec_in), the passed variable of Mat_y should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_diry_p15( Mat_y_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_y_tr(16,16)
    real(rp), intent(in) :: vec_in(16,16,16)
    real(rp), intent(out) :: vec_out(16,16,16)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 16
    do j=1, 16
    do i=1, 16
        vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
                       + vec_in(i,2,k) * mat_y_tr(2,j) &
                       + vec_in(i,3,k) * mat_y_tr(3,j) &
                       + vec_in(i,4,k) * mat_y_tr(4,j) &
                       + vec_in(i,5,k) * mat_y_tr(5,j) &
                       + vec_in(i,6,k) * mat_y_tr(6,j) &
                       + vec_in(i,7,k) * mat_y_tr(7,j) &
                       + vec_in(i,8,k) * mat_y_tr(8,j) &
                       + vec_in(i,9,k) * mat_y_tr(9,j) &
                       + vec_in(i,10,k) * mat_y_tr(10,j) &
                       + vec_in(i,11,k) * mat_y_tr(11,j) &
                       + vec_in(i,12,k) * mat_y_tr(12,j) &
                       + vec_in(i,13,k) * mat_y_tr(13,j) &
                       + vec_in(i,14,k) * mat_y_tr(14,j) &
                       + vec_in(i,15,k) * mat_y_tr(15,j) &
                       + vec_in(i,16,k) * mat_y_tr(16,j) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_diry_p15
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the z direction (third dimension of vec_in) with p=15
!! For a matrix-vector multiplication (vec_out = Mat_z vec_in), the passed variable of Mat_z should be transposed.
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_dirz_p15( Mat_z_tr, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: mat_z_tr(16,16)
    real(rp), intent(in) :: vec_in(16,16,16)
    real(rp), intent(out) :: vec_out(16,16,16)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 16
    do j=1, 16
    do i=1, 16
        vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
                       + vec_in(i,j,2) * mat_z_tr(2,k) &
                       + vec_in(i,j,3) * mat_z_tr(3,k) &
                       + vec_in(i,j,4) * mat_z_tr(4,k) &
                       + vec_in(i,j,5) * mat_z_tr(5,k) &
                       + vec_in(i,j,6) * mat_z_tr(6,k) &
                       + vec_in(i,j,7) * mat_z_tr(7,k) &
                       + vec_in(i,j,8) * mat_z_tr(8,k) &
                       + vec_in(i,j,9) * mat_z_tr(9,k) &
                       + vec_in(i,j,10) * mat_z_tr(10,k) &
                       + vec_in(i,j,11) * mat_z_tr(11,k) &
                       + vec_in(i,j,12) * mat_z_tr(12,k) &
                       + vec_in(i,j,13) * mat_z_tr(13,k) &
                       + vec_in(i,j,14) * mat_z_tr(14,k) &
                       + vec_in(i,j,15) * mat_z_tr(15,k) &
                       + vec_in(i,j,16) * mat_z_tr(16,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_dirz_p15
 
!> Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=15
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_lift_hexahedral_p15( Lift, vec_in, vec_out )
    implicit none
    real(rp), intent(in) :: lift(16,16,16,6)
    real(rp), intent(in) :: vec_in(16,16,6)
    real(rp), intent(out) :: vec_out(16,16,16)
 
    integer :: i, j, k
    !----------------------------------------------------------
 
    do k=1, 16
    do j=1, 16
    do i=1, 16
        vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
                       + lift(i,j,k,2) * vec_in(j,k,2) &
                       + lift(i,j,k,3) * vec_in(i,k,3) &
                       + lift(i,j,k,4) * vec_in(j,k,4) &
                       + lift(i,j,k,5) * vec_in(i,j,5) &
                       + lift(i,j,k,6) * vec_in(i,j,6)
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_lift_hexahedral_p15
  
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=15
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_gradlike_dirxyz_p15( Mat, Mat_tr, vec_in, vec_in_, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(16,16)
    real(rp), intent(in) :: mat_tr(16,16)
    real(rp), intent(in) :: vec_in_(16,16**2)
    real(rp), intent(in) :: vec_in(16,16,16)
    real(rp), intent(out) :: vec_out_x(16,16**2)
    real(rp), intent(out) :: vec_out_y(16,16,16)
    real(rp), intent(out) :: vec_out_z(16,16,16)
 
    integer :: i, j, k, jk
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 16**2
    do i=1, 16
        vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
                        + mat(i,2) * vec_in_(2,jk) &
                        + mat(i,3) * vec_in_(3,jk) &
                        + mat(i,4) * vec_in_(4,jk) &
                        + mat(i,5) * vec_in_(5,jk) &
                        + mat(i,6) * vec_in_(6,jk) &
                        + mat(i,7) * vec_in_(7,jk) &
                        + mat(i,8) * vec_in_(8,jk) &
                        + mat(i,9) * vec_in_(9,jk) &
                        + mat(i,10) * vec_in_(10,jk) &
                        + mat(i,11) * vec_in_(11,jk) &
                        + mat(i,12) * vec_in_(12,jk) &
                        + mat(i,13) * vec_in_(13,jk) &
                        + mat(i,14) * vec_in_(14,jk) &
                        + mat(i,15) * vec_in_(15,jk) &
                        + mat(i,16) * vec_in_(16,jk)
    end do
    end do
 
    ! Y-dir
    do k=1, 16
    do j=1, 16
    do i=1, 16
        vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,2,k) * mat_tr(2,j) &
                         + vec_in(i,3,k) * mat_tr(3,j) &
                         + vec_in(i,4,k) * mat_tr(4,j) &
                         + vec_in(i,5,k) * mat_tr(5,j) &
                         + vec_in(i,6,k) * mat_tr(6,j) &
                         + vec_in(i,7,k) * mat_tr(7,j) &
                         + vec_in(i,8,k) * mat_tr(8,j) &
                         + vec_in(i,9,k) * mat_tr(9,j) &
                         + vec_in(i,10,k) * mat_tr(10,j) &
                         + vec_in(i,11,k) * mat_tr(11,j) &
                         + vec_in(i,12,k) * mat_tr(12,j) &
                         + vec_in(i,13,k) * mat_tr(13,j) &
                         + vec_in(i,14,k) * mat_tr(14,j) &
                         + vec_in(i,15,k) * mat_tr(15,j) &
                         + vec_in(i,16,k) * mat_tr(16,j) 
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 16
    do j=1, 16
    do i=1, 16
        vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
                         + vec_in(i,j,2) * mat_tr(2,k) &
                         + vec_in(i,j,3) * mat_tr(3,k) &
                         + vec_in(i,j,4) * mat_tr(4,k) &
                         + vec_in(i,j,5) * mat_tr(5,k) &
                         + vec_in(i,j,6) * mat_tr(6,k) &
                         + vec_in(i,j,7) * mat_tr(7,k) &
                         + vec_in(i,j,8) * mat_tr(8,k) &
                         + vec_in(i,j,9) * mat_tr(9,k) &
                         + vec_in(i,j,10) * mat_tr(10,k) &
                         + vec_in(i,j,11) * mat_tr(11,k) &
                         + vec_in(i,j,12) * mat_tr(12,k) &
                         + vec_in(i,j,13) * mat_tr(13,k) &
                         + vec_in(i,j,14) * mat_tr(14,k) &
                         + vec_in(i,j,15) * mat_tr(15,k) &
                         + vec_in(i,j,16) * mat_tr(16,k) 
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_gradlike_dirxyz_p15
 
!> Calculate a matrix-vector multiplication associated with mathematical operations in the x, y, and z direction (third dimension of vec_in) with p=15
!! For a matrix-vector multiplication (vec_d_out = Mat_d vec_d_in where d=x,y,z), the passed variables of Mat_y and Mat_z should be transposed.
!! Note that we assume that vec_in_ has same data as vec_in, but are reshaped via the call of this subroutine. 
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_p15( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(16,16)
    real(rp), intent(in) :: mat_tr(16,16)
    real(rp), intent(in) :: vec_in_x(16,16**2)
    real(rp), intent(in) :: vec_in_y(16,16,16)
    real(rp), intent(in) :: vec_in_z(16,16,16)
    real(rp), intent(out) :: vec_out_x(16,16**2)
    real(rp), intent(out) :: vec_out_y(16,16**2)
    real(rp), intent(out) :: vec_out_z(16,16**2)
 
    integer :: i, j, k, jk
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jk=1, 16**2
    do i=1, 16
      tmp1 = mat(i,1) * vec_in_x(1,jk) &
           + mat(i,2) * vec_in_x(2,jk) &
           + mat(i,3) * vec_in_x(3,jk) &
           + mat(i,4) * vec_in_x(4,jk) &
           + mat(i,5) * vec_in_x(5,jk)
      tmp2 = mat(i,6) * vec_in_x(6,jk) &
           + mat(i,7) * vec_in_x(7,jk) &
           + mat(i,8) * vec_in_x(8,jk) &
           + mat(i,9) * vec_in_x(9,jk) &
           + mat(i,10) * vec_in_x(10,jk)
      tmp3 = mat(i,11) * vec_in_x(11,jk) &
           + mat(i,12) * vec_in_x(12,jk) &
           + mat(i,13) * vec_in_x(13,jk) &
           + mat(i,14) * vec_in_x(14,jk) &
           + mat(i,15) * vec_in_x(15,jk) &
           + mat(i,16) * vec_in_x(16,jk)
      vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do k=1, 16
    do j=1, 16
      jk = j + (k-1)*16
      do i=1, 16
        tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
             + vec_in_y(i,2,k) * mat_tr(2,j) &
             + vec_in_y(i,3,k) * mat_tr(3,j) &
             + vec_in_y(i,4,k) * mat_tr(4,j) &
             + vec_in_y(i,5,k) * mat_tr(5,j) 
        tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
             + vec_in_y(i,7,k) * mat_tr(7,j) &
             + vec_in_y(i,8,k) * mat_tr(8,j) &
             + vec_in_y(i,9,k) * mat_tr(9,j) &
             + vec_in_y(i,10,k) * mat_tr(10,j) 
        tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
             + vec_in_y(i,12,k) * mat_tr(12,j) &
             + vec_in_y(i,13,k) * mat_tr(13,j) &
             + vec_in_y(i,14,k) * mat_tr(14,j) &
             + vec_in_y(i,15,k) * mat_tr(15,j) &
             + vec_in_y(i,16,k) * mat_tr(16,j) 
      vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do k=1, 16
    do j=1, 16
      jk = j + (k-1)*16
      do i=1, 16
        tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
             + vec_in_z(i,j,2) * mat_tr(2,k) &
             + vec_in_z(i,j,3) * mat_tr(3,k) &
             + vec_in_z(i,j,4) * mat_tr(4,k) &
             + vec_in_z(i,j,5) * mat_tr(5,k) 
        tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
             + vec_in_z(i,j,7) * mat_tr(7,k) &
             + vec_in_z(i,j,8) * mat_tr(8,k) &
             + vec_in_z(i,j,9) * mat_tr(9,k) &
             + vec_in_z(i,j,10) * mat_tr(10,k) 
        tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
             + vec_in_z(i,j,12) * mat_tr(12,k) &
             + vec_in_z(i,j,13) * mat_tr(13,k) &
             + vec_in_z(i,j,14) * mat_tr(14,k) &
             + vec_in_z(i,j,15) * mat_tr(15,k) &
             + vec_in_z(i,j,16) * mat_tr(16,k) 
      vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_p15
 
!OCL SERIAL
  subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p15( &
    Mat, Mat_tr, vec_in_x, vec_in_y, vec_in_z, &
    vec_out_x, vec_out_y, vec_out_z  )
    implicit none
    real(rp), intent(in) :: mat(16,16)
    real(rp), intent(in) :: mat_tr(16,16)
    real(rp), intent(in) :: vec_in_x(16,16**2*5)
    real(rp), intent(in) :: vec_in_y(16,16,16*5)
    real(rp), intent(in) :: vec_in_z(16,16,16,5)
    real(rp), intent(out) :: vec_out_x(16,16**2*5)
    real(rp), intent(out) :: vec_out_y(16,16**2*5)
    real(rp), intent(out) :: vec_out_z(16,16**2,5)
 
    integer :: i, j, k, jkv, jk, v, kv
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do jkv=1, 16**2*5
    do i=1, 16
      tmp1 = mat(i,1) * vec_in_x(1,jkv) &
           + mat(i,2) * vec_in_x(2,jkv) &
           + mat(i,3) * vec_in_x(3,jkv) &
           + mat(i,4) * vec_in_x(4,jkv) &
           + mat(i,5) * vec_in_x(5,jkv)
      tmp2 = mat(i,6) * vec_in_x(6,jkv) &
           + mat(i,7) * vec_in_x(7,jkv) &
           + mat(i,8) * vec_in_x(8,jkv) &
           + mat(i,9) * vec_in_x(9,jkv) &
           + mat(i,10) * vec_in_x(10,jkv)
      tmp3 = mat(i,11) * vec_in_x(11,jkv) &
           + mat(i,12) * vec_in_x(12,jkv) &
           + mat(i,13) * vec_in_x(13,jkv) &
           + mat(i,14) * vec_in_x(14,jkv) &
           + mat(i,15) * vec_in_x(15,jkv) &
           + mat(i,16) * vec_in_x(16,jkv)
      vec_out_x(i,jkv) = tmp1 + tmp2 + tmp3
    end do
    end do
 
    ! Y-dir
    do kv=1, 16*5
    do j=1, 16
      jkv = j + (kv-1)*80
      do i=1, 16
        tmp1 = vec_in_y(i,1,kv) * mat_tr(1,j) &
             + vec_in_y(i,2,kv) * mat_tr(2,j) &
             + vec_in_y(i,3,kv) * mat_tr(3,j) &
             + vec_in_y(i,4,kv) * mat_tr(4,j) &
             + vec_in_y(i,5,kv) * mat_tr(5,j) 
        tmp2 = vec_in_y(i,6,kv) * mat_tr(6,j) &
             + vec_in_y(i,7,kv) * mat_tr(7,j) &
             + vec_in_y(i,8,kv) * mat_tr(8,j) &
             + vec_in_y(i,9,kv) * mat_tr(9,j) &
             + vec_in_y(i,10,kv) * mat_tr(10,j) 
        tmp3 = vec_in_y(i,11,kv) * mat_tr(11,j) &
             + vec_in_y(i,12,kv) * mat_tr(12,j) &
             + vec_in_y(i,13,kv) * mat_tr(13,j) &
             + vec_in_y(i,14,kv) * mat_tr(14,j) &
             + vec_in_y(i,15,kv) * mat_tr(15,j) &
             + vec_in_y(i,16,kv) * mat_tr(16,j) 
      vec_out_y(i,jkv) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    
    ! Z-dir
    do v=1, 5
    do k=1, 16
    do j=1, 16
      jk = j + (k-1)*16
      do i=1, 16
        tmp1 = vec_in_z(i,j,1,v) * mat_tr(1,k) &
             + vec_in_z(i,j,2,v) * mat_tr(2,k) &
             + vec_in_z(i,j,3,v) * mat_tr(3,k) &
             + vec_in_z(i,j,4,v) * mat_tr(4,k) &
             + vec_in_z(i,j,5,v) * mat_tr(5,k) 
        tmp2 = vec_in_z(i,j,6,v) * mat_tr(6,k) &
             + vec_in_z(i,j,7,v) * mat_tr(7,k) &
             + vec_in_z(i,j,8,v) * mat_tr(8,k) &
             + vec_in_z(i,j,9,v) * mat_tr(9,k) &
             + vec_in_z(i,j,10,v) * mat_tr(10,k) 
        tmp3 = vec_in_z(i,j,11,v) * mat_tr(11,k) &
             + vec_in_z(i,j,12,v) * mat_tr(12,k) &
             + vec_in_z(i,j,13,v) * mat_tr(13,k) &
             + vec_in_z(i,j,14,v) * mat_tr(14,k) &
             + vec_in_z(i,j,15,v) * mat_tr(15,k) &
             + vec_in_z(i,j,16,v) * mat_tr(16,k) 
      vec_out_z(i,jk,v) = tmp1 + tmp2 + tmp3
      end do
    end do
    end do
    end do
    return
  end subroutine element_operation_kernel_matvec_divlike_dirxyz_var5_p15
 
!> Calculate a matrix-vector multiplication associated with 3D modal filtering with p=15
!!
!OCL SERIAL
  subroutine element_operation_kernel_matvec_modalfilter_p15( Mat_h1D, Mat_h1D_tr, Mat_v1D_tr, vec_in, vec_work, &
    vec_out  )
    implicit none
    real(rp), intent(in) :: mat_h1d(16,16)
    real(rp), intent(in) :: mat_h1d_tr(16,16)
    real(rp), intent(in) :: mat_v1d_tr(16,16)
    real(rp), intent(in) :: vec_in(16,16,16)
    real(rp), intent(out) :: vec_work(16,16,16)
    real(rp), intent(out) :: vec_out(16,16,16)
 
    integer :: i, j, k
    real(rp) :: tmp1, tmp2, tmp3
    !----------------------------------------------------------
 
    ! X-dir
 
    do k=1, 16
    do j=1, 16
    do i=1, 16
      tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
           + mat_h1d(i,2) * vec_in(2,j,k) &
           + mat_h1d(i,3) * vec_in(3,j,k) &
           + mat_h1d(i,4) * vec_in(4,j,k) &
           + mat_h1d(i,5) * vec_in(5,j,k)
      tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
           + mat_h1d(i,7) * vec_in(7,j,k) &
           + mat_h1d(i,8) * vec_in(8,j,k) &
           + mat_h1d(i,9) * vec_in(9,j,k) &
           + mat_h1d(i,10) * vec_in(10,j,k)
      tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
           + mat_h1d(i,12) * vec_in(12,j,k) &
           + mat_h1d(i,13) * vec_in(13,j,k) &
           + mat_h1d(i,14) * vec_in(14,j,k) &
           + mat_h1d(i,15) * vec_in(15,j,k) &
           + mat_h1d(i,16) * vec_in(16,j,k)
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Y-dir
    do k=1, 16
    do j=1, 16
    do i=1, 16
      tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
           + vec_out(i,2,k) * mat_h1d_tr(2,j) &
           + vec_out(i,3,k) * mat_h1d_tr(3,j) &
           + vec_out(i,4,k) * mat_h1d_tr(4,j) &
           + vec_out(i,5,k) * mat_h1d_tr(5,j) 
      tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
           + vec_out(i,7,k) * mat_h1d_tr(7,j) &
           + vec_out(i,8,k) * mat_h1d_tr(8,j) &
           + vec_out(i,9,k) * mat_h1d_tr(9,j) &
           + vec_out(i,10,k) * mat_h1d_tr(10,j) 
      tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
           + vec_out(i,12,k) * mat_h1d_tr(12,j) &
           + vec_out(i,13,k) * mat_h1d_tr(13,j) &
           + vec_out(i,14,k) * mat_h1d_tr(14,j) &
           + vec_out(i,15,k) * mat_h1d_tr(15,j) &
           + vec_out(i,16,k) * mat_h1d_tr(16,j) 
      vec_work(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
    
    ! Z-dir
    do k=1, 16
    do j=1, 16
    do i=1, 16
      tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
           + vec_work(i,j,2) * mat_v1d_tr(2,k) &
           + vec_work(i,j,3) * mat_v1d_tr(3,k) &
           + vec_work(i,j,4) * mat_v1d_tr(4,k) &
           + vec_work(i,j,5) * mat_v1d_tr(5,k) 
      tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
           + vec_work(i,j,7) * mat_v1d_tr(7,k) &
           + vec_work(i,j,8) * mat_v1d_tr(8,k) &
           + vec_work(i,j,9) * mat_v1d_tr(9,k) &
           + vec_work(i,j,10) * mat_v1d_tr(10,k) 
      tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
           + vec_work(i,j,12) * mat_v1d_tr(12,k) &
           + vec_work(i,j,13) * mat_v1d_tr(13,k) &
           + vec_work(i,j,14) * mat_v1d_tr(14,k) &
           + vec_work(i,j,15) * mat_v1d_tr(15,k) &
           + vec_work(i,j,16) * mat_v1d_tr(16,k) 
      vec_out(i,j,k) = tmp1 + tmp2 + tmp3
    end do
    end do
    end do
 
    return
  end subroutine element_operation_kernel_matvec_modalfilter_p15
 
 
end module scale_element_operation_tensorprod3d_kernel