FE-Project
Loading...
Searching...
No Matches
Functions/Subroutines
scale_element_operation_tensorprod3d_kernel Module Reference

module FElib / Element / Operation with 3D tensor product elements More...

Functions/Subroutines

subroutine, public element_operation_kernel_matvec_dirx_p1 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=1.
subroutine, public element_operation_kernel_matvec_diry_p1 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p1 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p1 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=1.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p1 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p1 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=1.
subroutine, public element_operation_kernel_matvec_dirx_p2 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=2.
subroutine, public element_operation_kernel_matvec_diry_p2 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p2 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p2 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=2.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p2 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p2 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=2.
subroutine, public element_operation_kernel_matvec_dirx_p3 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=3.
subroutine, public element_operation_kernel_matvec_diry_p3 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p3 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p3 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=3.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p3 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p3 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=3.
subroutine, public element_operation_kernel_matvec_dirx_p4 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=4.
subroutine, public element_operation_kernel_matvec_diry_p4 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p4 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p4 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=4.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p4 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p4 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=4.
subroutine, public element_operation_kernel_matvec_dirx_p5 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=5.
subroutine, public element_operation_kernel_matvec_diry_p5 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p5 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p5 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=5.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p5 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p5 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=5.
subroutine, public element_operation_kernel_matvec_dirx_p6 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=6.
subroutine, public element_operation_kernel_matvec_diry_p6 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p6 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p6 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=6.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p6 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p6 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=6.
subroutine, public element_operation_kernel_matvec_dirx_p7 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=7.
subroutine, public element_operation_kernel_matvec_diry_p7 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p7 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p7 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=7.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p7 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p7 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=7.
subroutine, public element_operation_kernel_matvec_dirx_p8 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=8.
subroutine, public element_operation_kernel_matvec_diry_p8 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p8 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p8 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=8.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p8 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p8 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=8.
subroutine, public element_operation_kernel_matvec_dirx_p9 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=9.
subroutine, public element_operation_kernel_matvec_diry_p9 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p9 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p9 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=9.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p9 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p9 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=9.
subroutine, public element_operation_kernel_matvec_dirx_p10 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=10.
subroutine, public element_operation_kernel_matvec_diry_p10 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p10 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p10 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=10.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p10 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p10 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=10.
subroutine, public element_operation_kernel_matvec_dirx_p11 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=11.
subroutine, public element_operation_kernel_matvec_diry_p11 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p11 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p11 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=11.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p11 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p11 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=11.
subroutine, public element_operation_kernel_matvec_dirx_p12 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=12.
subroutine, public element_operation_kernel_matvec_diry_p12 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p12 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p12 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=12.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p12 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p12 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=12.
subroutine, public element_operation_kernel_matvec_dirx_p13 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=13.
subroutine, public element_operation_kernel_matvec_diry_p13 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p13 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p13 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=13.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p13 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p13 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=13.
subroutine, public element_operation_kernel_matvec_dirx_p14 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=14.
subroutine, public element_operation_kernel_matvec_diry_p14 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p14 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p14 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=14.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p14 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p14 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=14.
subroutine, public element_operation_kernel_matvec_dirx_p15 (mat_x, vec_in, vec_out)
 Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=15.
subroutine, public element_operation_kernel_matvec_diry_p15 (mat_y_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_dirz_p15 (mat_z_tr, vec_in, vec_out)
 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.
subroutine, public element_operation_kernel_matvec_lift_hexahedral_p15 (lift, vec_in, vec_out)
 Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=15.
subroutine, public element_operation_kernel_matvec_gradlike_dirxyz_p15 (mat, mat_tr, vec_in, vec_in_, vec_out_x, vec_out_y, vec_out_z)
 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.
subroutine, public 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)
 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.
subroutine, public element_operation_kernel_matvec_modalfilter_p15 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, vec_out)
 Calculate a matrix-vector multiplication associated with 3D modal filtering with p=15.

Detailed Description

module FElib / Element / Operation with 3D tensor product elements

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

Function/Subroutine Documentation

◆ element_operation_kernel_matvec_dirx_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p1 ( real(rp), dimension(2,2), intent(in) mat_x,
real(rp), dimension(2,2**2), intent(in) vec_in,
real(rp), dimension(2,2**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=1.

Definition at line 147 of file scale_element_operation_tensorprod3D_kernel.F90.

148 implicit none
149 real(RP), intent(in) :: Mat_x(2,2)
150 real(RP), intent(in) :: vec_in(2,2**2)
151 real(RP), intent(out) :: vec_out(2,2**2)
152
153 integer :: i, jk
154 !----------------------------------------------------------
155
156 do jk=1, 2**2
157 do i=1, 2
158 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
159 + mat_x(i,2) * vec_in(2,jk)
160 end do
161 end do
162
163 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p1 ( real(rp), dimension(2,2), intent(in) mat_y_tr,
real(rp), dimension(2,2,2), intent(in) vec_in,
real(rp), dimension(2,2,2), intent(out) vec_out )

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.

Definition at line 170 of file scale_element_operation_tensorprod3D_kernel.F90.

171 implicit none
172 real(RP), intent(in) :: Mat_y_tr(2,2)
173 real(RP), intent(in) :: vec_in(2,2,2)
174 real(RP), intent(out) :: vec_out(2,2,2)
175
176 integer :: i, j, k
177 !----------------------------------------------------------
178
179 do k=1, 2
180 do j=1, 2
181 do i=1, 2
182 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
183 + vec_in(i,2,k) * mat_y_tr(2,j)
184 end do
185 end do
186 end do
187
188 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p1 ( real(rp), dimension(2,2), intent(in) mat_z_tr,
real(rp), dimension(2,2,2), intent(in) vec_in,
real(rp), dimension(2,2,2), intent(out) vec_out )

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.

Definition at line 195 of file scale_element_operation_tensorprod3D_kernel.F90.

196 implicit none
197 real(RP), intent(in) :: Mat_z_tr(2,2)
198 real(RP), intent(in) :: vec_in(2,2,2)
199 real(RP), intent(out) :: vec_out(2,2,2)
200
201 integer :: i, j, k
202 !----------------------------------------------------------
203
204 do k=1, 2
205 do j=1, 2
206 do i=1, 2
207 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
208 + vec_in(i,j,2) * mat_z_tr(2,k)
209 end do
210 end do
211 end do
212
213 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p1 ( real(rp), dimension(2,2,2,6), intent(in) lift,
real(rp), dimension(2,2,6), intent(in) vec_in,
real(rp), dimension(2,2,2), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=1.

Definition at line 219 of file scale_element_operation_tensorprod3D_kernel.F90.

220 implicit none
221 real(RP), intent(in) :: Lift(2,2,2,6)
222 real(RP), intent(in) :: vec_in(2,2,6)
223 real(RP), intent(out) :: vec_out(2,2,2)
224
225 integer :: i, j, k
226 !----------------------------------------------------------
227
228 do k=1, 2
229 do j=1, 2
230 do i=1, 2
231 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
232 + lift(i,j,k,2) * vec_in(j,k,2) &
233 + lift(i,j,k,3) * vec_in(i,k,3) &
234 + lift(i,j,k,4) * vec_in(j,k,4) &
235 + lift(i,j,k,5) * vec_in(i,j,5) &
236 + lift(i,j,k,6) * vec_in(i,j,6)
237 end do
238 end do
239 end do
240
241 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p1 ( real(rp), dimension(2,2), intent(in) mat,
real(rp), dimension(2,2), intent(in) mat_tr,
real(rp), dimension(2,2,2), intent(in) vec_in,
real(rp), dimension(2,2**2), intent(in) vec_in_,
real(rp), dimension(2,2**2), intent(out) vec_out_x,
real(rp), dimension(2,2,2), intent(out) vec_out_y,
real(rp), dimension(2,2,2), intent(out) vec_out_z )

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.

Definition at line 249 of file scale_element_operation_tensorprod3D_kernel.F90.

251 implicit none
252 real(RP), intent(in) :: Mat(2,2)
253 real(RP), intent(in) :: Mat_tr(2,2)
254 real(RP), intent(in) :: vec_in_(2,2**2)
255 real(RP), intent(in) :: vec_in(2,2,2)
256 real(RP), intent(out) :: vec_out_x(2,2**2)
257 real(RP), intent(out) :: vec_out_y(2,2,2)
258 real(RP), intent(out) :: vec_out_z(2,2,2)
259
260 integer :: i, j, k, jk
261 !----------------------------------------------------------
262
263 ! X-dir
264
265 do jk=1, 2**2
266 do i=1, 2
267 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
268 + mat(i,2) * vec_in_(2,jk)
269 end do
270 end do
271
272 ! Y-dir
273 do k=1, 2
274 do j=1, 2
275 do i=1, 2
276 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
277 + vec_in(i,2,k) * mat_tr(2,j)
278 end do
279 end do
280 end do
281
282 ! Z-dir
283 do k=1, 2
284 do j=1, 2
285 do i=1, 2
286 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
287 + vec_in(i,j,2) * mat_tr(2,k)
288 end do
289 end do
290 end do
291
292 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p1 ( real(rp), dimension(2,2), intent(in) mat,
real(rp), dimension(2,2), intent(in) mat_tr,
real(rp), dimension(2,2**2), intent(in) vec_in_x,
real(rp), dimension(2,2,2), intent(in) vec_in_y,
real(rp), dimension(2,2,2), intent(in) vec_in_z,
real(rp), dimension(2,2**2), intent(out) vec_out_x,
real(rp), dimension(2,2**2), intent(out) vec_out_y,
real(rp), dimension(2,2**2), intent(out) vec_out_z )

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.

Definition at line 300 of file scale_element_operation_tensorprod3D_kernel.F90.

303 implicit none
304 real(RP), intent(in) :: Mat(2,2)
305 real(RP), intent(in) :: Mat_tr(2,2)
306 real(RP), intent(in) :: vec_in_x(2,2**2)
307 real(RP), intent(in) :: vec_in_y(2,2,2)
308 real(RP), intent(in) :: vec_in_z(2,2,2)
309 real(RP), intent(out) :: vec_out_x(2,2**2)
310 real(RP), intent(out) :: vec_out_y(2,2**2)
311 real(RP), intent(out) :: vec_out_z(2,2**2)
312
313 integer :: i, j, k, jk
314 !----------------------------------------------------------
315
316 ! X-dir
317
318 do jk=1, 2**2
319 do i=1, 2
320 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
321 + mat(i,2) * vec_in_x(2,jk)
322 end do
323 end do
324
325 ! Y-dir
326 do k=1, 2
327 do j=1, 2
328 jk = j + (k-1)*2
329 do i=1, 2
330 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
331 + vec_in_y(i,2,k) * mat_tr(2,j)
332 end do
333 end do
334 end do
335
336 ! Z-dir
337 do k=1, 2
338 do j=1, 2
339 jk = j + (k-1)*2
340 do i=1, 2
341 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
342 + vec_in_z(i,j,2) * mat_tr(2,k)
343 end do
344 end do
345 end do
346 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p1()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p1 ( real(rp), dimension(2,2), intent(in) mat_h1d,
real(rp), dimension(2,2), intent(in) mat_h1d_tr,
real(rp), dimension(2,2), intent(in) mat_v1d_tr,
real(rp), dimension(2,2,2), intent(in) vec_in,
real(rp), dimension(2,2,2), intent(out) vec_work,
real(rp), dimension(2,2,2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=1.

Definition at line 404 of file scale_element_operation_tensorprod3D_kernel.F90.

406 implicit none
407 real(RP), intent(in) :: Mat_h1D(2,2)
408 real(RP), intent(in) :: Mat_h1D_tr(2,2)
409 real(RP), intent(in) :: Mat_v1D_tr(2,2)
410 real(RP), intent(in) :: vec_in(2,2,2)
411 real(RP), intent(out) :: vec_work(2,2,2)
412 real(RP), intent(out) :: vec_out(2,2,2)
413
414 integer :: i, j, k
415 !----------------------------------------------------------
416
417 ! X-dir
418
419 do k=1, 2
420 do j=1, 2
421 do i=1, 2
422 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
423 + mat_h1d(i,2) * vec_in(2,j,k)
424 end do
425 end do
426 end do
427
428 ! Y-dir
429 do k=1, 2
430 do j=1, 2
431 do i=1, 2
432 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
433 + vec_out(i,2,k) * mat_h1d_tr(2,j)
434 end do
435 end do
436 end do
437
438 ! Z-dir
439 do k=1, 2
440 do j=1, 2
441 do i=1, 2
442 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
443 + vec_work(i,j,2) * mat_v1d_tr(2,k)
444 end do
445 end do
446 end do
447
448 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p2 ( real(rp), dimension(3,3), intent(in) mat_x,
real(rp), dimension(3,3**2), intent(in) vec_in,
real(rp), dimension(3,3**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=2.

Definition at line 456 of file scale_element_operation_tensorprod3D_kernel.F90.

457 implicit none
458 real(RP), intent(in) :: Mat_x(3,3)
459 real(RP), intent(in) :: vec_in(3,3**2)
460 real(RP), intent(out) :: vec_out(3,3**2)
461
462 integer :: i, jk
463 !----------------------------------------------------------
464
465 do jk=1, 3**2
466 do i=1, 3
467 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
468 + mat_x(i,2) * vec_in(2,jk) &
469 + mat_x(i,3) * vec_in(3,jk)
470 end do
471 end do
472
473 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p2 ( real(rp), dimension(3,3), intent(in) mat_y_tr,
real(rp), dimension(3,3,3), intent(in) vec_in,
real(rp), dimension(3,3,3), intent(out) vec_out )

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.

Definition at line 480 of file scale_element_operation_tensorprod3D_kernel.F90.

481 implicit none
482 real(RP), intent(in) :: Mat_y_tr(3,3)
483 real(RP), intent(in) :: vec_in(3,3,3)
484 real(RP), intent(out) :: vec_out(3,3,3)
485
486 integer :: i, j, k
487 !----------------------------------------------------------
488
489 do k=1, 3
490 do j=1, 3
491 do i=1, 3
492 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
493 + vec_in(i,2,k) * mat_y_tr(2,j) &
494 + vec_in(i,3,k) * mat_y_tr(3,j)
495 end do
496 end do
497 end do
498
499 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p2 ( real(rp), dimension(3,3), intent(in) mat_z_tr,
real(rp), dimension(3,3,3), intent(in) vec_in,
real(rp), dimension(3,3,3), intent(out) vec_out )

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.

Definition at line 506 of file scale_element_operation_tensorprod3D_kernel.F90.

507 implicit none
508 real(RP), intent(in) :: Mat_z_tr(3,3)
509 real(RP), intent(in) :: vec_in(3,3,3)
510 real(RP), intent(out) :: vec_out(3,3,3)
511
512 integer :: i, j, k
513 !----------------------------------------------------------
514
515 do k=1, 3
516 do j=1, 3
517 do i=1, 3
518 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
519 + vec_in(i,j,2) * mat_z_tr(2,k) &
520 + vec_in(i,j,3) * mat_z_tr(3,k)
521 end do
522 end do
523 end do
524
525 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p2 ( real(rp), dimension(3,3,3,6), intent(in) lift,
real(rp), dimension(3,3,6), intent(in) vec_in,
real(rp), dimension(3,3,3), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=2.

Definition at line 531 of file scale_element_operation_tensorprod3D_kernel.F90.

532 implicit none
533 real(RP), intent(in) :: Lift(3,3,3,6)
534 real(RP), intent(in) :: vec_in(3,3,6)
535 real(RP), intent(out) :: vec_out(3,3,3)
536
537 integer :: i, j, k
538 !----------------------------------------------------------
539
540 do k=1, 3
541 do j=1, 3
542 do i=1, 3
543 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
544 + lift(i,j,k,2) * vec_in(j,k,2) &
545 + lift(i,j,k,3) * vec_in(i,k,3) &
546 + lift(i,j,k,4) * vec_in(j,k,4) &
547 + lift(i,j,k,5) * vec_in(i,j,5) &
548 + lift(i,j,k,6) * vec_in(i,j,6)
549 end do
550 end do
551 end do
552
553 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p2 ( real(rp), dimension(3,3), intent(in) mat,
real(rp), dimension(3,3), intent(in) mat_tr,
real(rp), dimension(3,3,3), intent(in) vec_in,
real(rp), dimension(3,3**2), intent(in) vec_in_,
real(rp), dimension(3,3**2), intent(out) vec_out_x,
real(rp), dimension(3,3,3), intent(out) vec_out_y,
real(rp), dimension(3,3,3), intent(out) vec_out_z )

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.

Definition at line 561 of file scale_element_operation_tensorprod3D_kernel.F90.

563 implicit none
564 real(RP), intent(in) :: Mat(3,3)
565 real(RP), intent(in) :: Mat_tr(3,3)
566 real(RP), intent(in) :: vec_in_(3,3**2)
567 real(RP), intent(in) :: vec_in(3,3,3)
568 real(RP), intent(out) :: vec_out_x(3,3**2)
569 real(RP), intent(out) :: vec_out_y(3,3,3)
570 real(RP), intent(out) :: vec_out_z(3,3,3)
571
572 integer :: i, j, k, jk
573 !----------------------------------------------------------
574
575 ! X-dir
576
577 do jk=1, 3**2
578 do i=1, 3
579 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
580 + mat(i,2) * vec_in_(2,jk) &
581 + mat(i,3) * vec_in_(3,jk)
582 end do
583 end do
584
585 ! Y-dir
586 do k=1, 3
587 do j=1, 3
588 do i=1, 3
589 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
590 + vec_in(i,2,k) * mat_tr(2,j) &
591 + vec_in(i,3,k) * mat_tr(3,j)
592 end do
593 end do
594 end do
595
596 ! Z-dir
597 do k=1, 3
598 do j=1, 3
599 do i=1, 3
600 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
601 + vec_in(i,j,2) * mat_tr(2,k) &
602 + vec_in(i,j,3) * mat_tr(3,k)
603 end do
604 end do
605 end do
606
607 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p2 ( real(rp), dimension(3,3), intent(in) mat,
real(rp), dimension(3,3), intent(in) mat_tr,
real(rp), dimension(3,3**2), intent(in) vec_in_x,
real(rp), dimension(3,3,3), intent(in) vec_in_y,
real(rp), dimension(3,3,3), intent(in) vec_in_z,
real(rp), dimension(3,3**2), intent(out) vec_out_x,
real(rp), dimension(3,3**2), intent(out) vec_out_y,
real(rp), dimension(3,3**2), intent(out) vec_out_z )

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.

Definition at line 615 of file scale_element_operation_tensorprod3D_kernel.F90.

618 implicit none
619 real(RP), intent(in) :: Mat(3,3)
620 real(RP), intent(in) :: Mat_tr(3,3)
621 real(RP), intent(in) :: vec_in_x(3,3**2)
622 real(RP), intent(in) :: vec_in_y(3,3,3)
623 real(RP), intent(in) :: vec_in_z(3,3,3)
624 real(RP), intent(out) :: vec_out_x(3,3**2)
625 real(RP), intent(out) :: vec_out_y(3,3**2)
626 real(RP), intent(out) :: vec_out_z(3,3**2)
627
628 integer :: i, j, k, jk
629 !----------------------------------------------------------
630
631 ! X-dir
632
633 do jk=1, 3**2
634 do i=1, 3
635 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
636 + mat(i,2) * vec_in_x(2,jk) &
637 + mat(i,3) * vec_in_x(3,jk)
638 end do
639 end do
640
641 ! Y-dir
642 do k=1, 3
643 do j=1, 3
644 jk = j + (k-1)*3
645 do i=1, 3
646 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
647 + vec_in_y(i,2,k) * mat_tr(2,j) &
648 + vec_in_y(i,3,k) * mat_tr(3,j)
649 end do
650 end do
651 end do
652
653 ! Z-dir
654 do k=1, 3
655 do j=1, 3
656 jk = j + (k-1)*3
657 do i=1, 3
658 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
659 + vec_in_z(i,j,2) * mat_tr(2,k) &
660 + vec_in_z(i,j,3) * mat_tr(3,k)
661 end do
662 end do
663 end do
664 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p2()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p2 ( real(rp), dimension(3,3), intent(in) mat_h1d,
real(rp), dimension(3,3), intent(in) mat_h1d_tr,
real(rp), dimension(3,3), intent(in) mat_v1d_tr,
real(rp), dimension(3,3,3), intent(in) vec_in,
real(rp), dimension(3,3,3), intent(out) vec_work,
real(rp), dimension(3,3,3), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=2.

Definition at line 725 of file scale_element_operation_tensorprod3D_kernel.F90.

727 implicit none
728 real(RP), intent(in) :: Mat_h1D(3,3)
729 real(RP), intent(in) :: Mat_h1D_tr(3,3)
730 real(RP), intent(in) :: Mat_v1D_tr(3,3)
731 real(RP), intent(in) :: vec_in(3,3,3)
732 real(RP), intent(out) :: vec_work(3,3,3)
733 real(RP), intent(out) :: vec_out(3,3,3)
734
735 integer :: i, j, k
736 !----------------------------------------------------------
737
738 ! X-dir
739
740 do k=1, 3
741 do j=1, 3
742 do i=1, 3
743 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
744 + mat_h1d(i,2) * vec_in(2,j,k) &
745 + mat_h1d(i,3) * vec_in(3,j,k)
746 end do
747 end do
748 end do
749
750 ! Y-dir
751 do k=1, 3
752 do j=1, 3
753 do i=1, 3
754 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
755 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
756 + vec_out(i,3,k) * mat_h1d_tr(3,j)
757 end do
758 end do
759 end do
760
761 ! Z-dir
762 do k=1, 3
763 do j=1, 3
764 do i=1, 3
765 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
766 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
767 + vec_work(i,j,3) * mat_v1d_tr(3,k)
768 end do
769 end do
770 end do
771
772 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p3 ( real(rp), dimension(4,4), intent(in) mat_x,
real(rp), dimension(4,4**2), intent(in) vec_in,
real(rp), dimension(4,4**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=3.

Definition at line 780 of file scale_element_operation_tensorprod3D_kernel.F90.

781 implicit none
782 real(RP), intent(in) :: Mat_x(4,4)
783 real(RP), intent(in) :: vec_in(4,4**2)
784 real(RP), intent(out) :: vec_out(4,4**2)
785
786 integer :: i, jk
787 !----------------------------------------------------------
788
789 do jk=1, 4**2
790 do i=1, 4
791 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
792 + mat_x(i,2) * vec_in(2,jk) &
793 + mat_x(i,3) * vec_in(3,jk) &
794 + mat_x(i,4) * vec_in(4,jk)
795 end do
796 end do
797
798 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p3 ( real(rp), dimension(4,4), intent(in) mat_y_tr,
real(rp), dimension(4,4,4), intent(in) vec_in,
real(rp), dimension(4,4,4), intent(out) vec_out )

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.

Definition at line 805 of file scale_element_operation_tensorprod3D_kernel.F90.

806 implicit none
807 real(RP), intent(in) :: Mat_y_tr(4,4)
808 real(RP), intent(in) :: vec_in(4,4,4)
809 real(RP), intent(out) :: vec_out(4,4,4)
810
811 integer :: i, j, k
812 !----------------------------------------------------------
813
814 do k=1, 4
815 do j=1, 4
816 do i=1, 4
817 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
818 + vec_in(i,2,k) * mat_y_tr(2,j) &
819 + vec_in(i,3,k) * mat_y_tr(3,j) &
820 + vec_in(i,4,k) * mat_y_tr(4,j)
821 end do
822 end do
823 end do
824
825 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p3 ( real(rp), dimension(4,4), intent(in) mat_z_tr,
real(rp), dimension(4,4,4), intent(in) vec_in,
real(rp), dimension(4,4,4), intent(out) vec_out )

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.

Definition at line 832 of file scale_element_operation_tensorprod3D_kernel.F90.

833 implicit none
834 real(RP), intent(in) :: Mat_z_tr(4,4)
835 real(RP), intent(in) :: vec_in(4,4,4)
836 real(RP), intent(out) :: vec_out(4,4,4)
837
838 integer :: i, j, k
839 !----------------------------------------------------------
840
841 do k=1, 4
842 do j=1, 4
843 do i=1, 4
844 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
845 + vec_in(i,j,2) * mat_z_tr(2,k) &
846 + vec_in(i,j,3) * mat_z_tr(3,k) &
847 + vec_in(i,j,4) * mat_z_tr(4,k)
848 end do
849 end do
850 end do
851
852 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p3 ( real(rp), dimension(4,4,4,6), intent(in) lift,
real(rp), dimension(4,4,6), intent(in) vec_in,
real(rp), dimension(4,4,4), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=3.

Definition at line 858 of file scale_element_operation_tensorprod3D_kernel.F90.

859 implicit none
860 real(RP), intent(in) :: Lift(4,4,4,6)
861 real(RP), intent(in) :: vec_in(4,4,6)
862 real(RP), intent(out) :: vec_out(4,4,4)
863
864 integer :: i, j, k
865 !----------------------------------------------------------
866
867 do k=1, 4
868 do j=1, 4
869 do i=1, 4
870 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
871 + lift(i,j,k,2) * vec_in(j,k,2) &
872 + lift(i,j,k,3) * vec_in(i,k,3) &
873 + lift(i,j,k,4) * vec_in(j,k,4) &
874 + lift(i,j,k,5) * vec_in(i,j,5) &
875 + lift(i,j,k,6) * vec_in(i,j,6)
876 end do
877 end do
878 end do
879
880 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p3 ( real(rp), dimension(4,4), intent(in) mat,
real(rp), dimension(4,4), intent(in) mat_tr,
real(rp), dimension(4,4,4), intent(in) vec_in,
real(rp), dimension(4,4**2), intent(in) vec_in_,
real(rp), dimension(4,4**2), intent(out) vec_out_x,
real(rp), dimension(4,4,4), intent(out) vec_out_y,
real(rp), dimension(4,4,4), intent(out) vec_out_z )

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.

Definition at line 888 of file scale_element_operation_tensorprod3D_kernel.F90.

890 implicit none
891 real(RP), intent(in) :: Mat(4,4)
892 real(RP), intent(in) :: Mat_tr(4,4)
893 real(RP), intent(in) :: vec_in_(4,4**2)
894 real(RP), intent(in) :: vec_in(4,4,4)
895 real(RP), intent(out) :: vec_out_x(4,4**2)
896 real(RP), intent(out) :: vec_out_y(4,4,4)
897 real(RP), intent(out) :: vec_out_z(4,4,4)
898
899 integer :: i, j, k, jk
900 !----------------------------------------------------------
901
902 ! X-dir
903
904 do jk=1, 4**2
905 do i=1, 4
906 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
907 + mat(i,2) * vec_in_(2,jk) &
908 + mat(i,3) * vec_in_(3,jk) &
909 + mat(i,4) * vec_in_(4,jk)
910 end do
911 end do
912
913 ! Y-dir
914 do k=1, 4
915 do j=1, 4
916 do i=1, 4
917 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
918 + vec_in(i,2,k) * mat_tr(2,j) &
919 + vec_in(i,3,k) * mat_tr(3,j) &
920 + vec_in(i,4,k) * mat_tr(4,j)
921 end do
922 end do
923 end do
924
925 ! Z-dir
926 do k=1, 4
927 do j=1, 4
928 do i=1, 4
929 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
930 + vec_in(i,j,2) * mat_tr(2,k) &
931 + vec_in(i,j,3) * mat_tr(3,k) &
932 + vec_in(i,j,4) * mat_tr(4,k)
933 end do
934 end do
935 end do
936
937 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p3 ( real(rp), dimension(4,4), intent(in) mat,
real(rp), dimension(4,4), intent(in) mat_tr,
real(rp), dimension(4,4**2), intent(in) vec_in_x,
real(rp), dimension(4,4,4), intent(in) vec_in_y,
real(rp), dimension(4,4,4), intent(in) vec_in_z,
real(rp), dimension(4,4**2), intent(out) vec_out_x,
real(rp), dimension(4,4**2), intent(out) vec_out_y,
real(rp), dimension(4,4**2), intent(out) vec_out_z )

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.

Definition at line 945 of file scale_element_operation_tensorprod3D_kernel.F90.

948 implicit none
949 real(RP), intent(in) :: Mat(4,4)
950 real(RP), intent(in) :: Mat_tr(4,4)
951 real(RP), intent(in) :: vec_in_x(4,4**2)
952 real(RP), intent(in) :: vec_in_y(4,4,4)
953 real(RP), intent(in) :: vec_in_z(4,4,4)
954 real(RP), intent(out) :: vec_out_x(4,4**2)
955 real(RP), intent(out) :: vec_out_y(4,4**2)
956 real(RP), intent(out) :: vec_out_z(4,4**2)
957
958 integer :: i, j, k, jk
959 !----------------------------------------------------------
960
961 ! X-dir
962
963 do jk=1, 4**2
964 do i=1, 4
965 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
966 + mat(i,2) * vec_in_x(2,jk) &
967 + mat(i,3) * vec_in_x(3,jk) &
968 + mat(i,4) * vec_in_x(4,jk)
969 end do
970 end do
971
972 ! Y-dir
973 do k=1, 4
974 do j=1, 4
975 jk = j + (k-1)*4
976 do i=1, 4
977 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
978 + vec_in_y(i,2,k) * mat_tr(2,j) &
979 + vec_in_y(i,3,k) * mat_tr(3,j) &
980 + vec_in_y(i,4,k) * mat_tr(4,j)
981 end do
982 end do
983 end do
984
985 ! Z-dir
986 do k=1, 4
987 do j=1, 4
988 jk = j + (k-1)*4
989 do i=1, 4
990 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
991 + vec_in_z(i,j,2) * mat_tr(2,k) &
992 + vec_in_z(i,j,3) * mat_tr(3,k) &
993 + vec_in_z(i,j,4) * mat_tr(4,k)
994 end do
995 end do
996 end do
997 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p3()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p3 ( real(rp), dimension(4,4), intent(in) mat_h1d,
real(rp), dimension(4,4), intent(in) mat_h1d_tr,
real(rp), dimension(4,4), intent(in) mat_v1d_tr,
real(rp), dimension(4,4,4), intent(in) vec_in,
real(rp), dimension(4,4,4), intent(out) vec_work,
real(rp), dimension(4,4,4), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=3.

Definition at line 1061 of file scale_element_operation_tensorprod3D_kernel.F90.

1063 implicit none
1064 real(RP), intent(in) :: Mat_h1D(4,4)
1065 real(RP), intent(in) :: Mat_h1D_tr(4,4)
1066 real(RP), intent(in) :: Mat_v1D_tr(4,4)
1067 real(RP), intent(in) :: vec_in(4,4,4)
1068 real(RP), intent(out) :: vec_work(4,4,4)
1069 real(RP), intent(out) :: vec_out(4,4,4)
1070
1071 integer :: i, j, k
1072 !----------------------------------------------------------
1073
1074 ! X-dir
1075
1076 do k=1, 4
1077 do j=1, 4
1078 do i=1, 4
1079 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
1080 + mat_h1d(i,2) * vec_in(2,j,k) &
1081 + mat_h1d(i,3) * vec_in(3,j,k) &
1082 + mat_h1d(i,4) * vec_in(4,j,k)
1083 end do
1084 end do
1085 end do
1086
1087 ! Y-dir
1088 do k=1, 4
1089 do j=1, 4
1090 do i=1, 4
1091 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
1092 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
1093 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
1094 + vec_out(i,4,k) * mat_h1d_tr(4,j)
1095 end do
1096 end do
1097 end do
1098
1099 ! Z-dir
1100 do k=1, 4
1101 do j=1, 4
1102 do i=1, 4
1103 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
1104 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
1105 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
1106 + vec_work(i,j,4) * mat_v1d_tr(4,k)
1107 end do
1108 end do
1109 end do
1110
1111 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p4 ( real(rp), dimension(5,5), intent(in) mat_x,
real(rp), dimension(5,5**2), intent(in) vec_in,
real(rp), dimension(5,5**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=4.

Definition at line 1119 of file scale_element_operation_tensorprod3D_kernel.F90.

1120 implicit none
1121 real(RP), intent(in) :: Mat_x(5,5)
1122 real(RP), intent(in) :: vec_in(5,5**2)
1123 real(RP), intent(out) :: vec_out(5,5**2)
1124
1125 integer :: i, jk
1126 !----------------------------------------------------------
1127
1128 do jk=1, 5**2
1129 do i=1, 5
1130 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
1131 + mat_x(i,2) * vec_in(2,jk) &
1132 + mat_x(i,3) * vec_in(3,jk) &
1133 + mat_x(i,4) * vec_in(4,jk) &
1134 + mat_x(i,5) * vec_in(5,jk)
1135 end do
1136 end do
1137
1138 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p4 ( real(rp), dimension(5,5), intent(in) mat_y_tr,
real(rp), dimension(5,5,5), intent(in) vec_in,
real(rp), dimension(5,5,5), intent(out) vec_out )

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.

Definition at line 1145 of file scale_element_operation_tensorprod3D_kernel.F90.

1146 implicit none
1147 real(RP), intent(in) :: Mat_y_tr(5,5)
1148 real(RP), intent(in) :: vec_in(5,5,5)
1149 real(RP), intent(out) :: vec_out(5,5,5)
1150
1151 integer :: i, j, k
1152 !----------------------------------------------------------
1153
1154 do k=1, 5
1155 do j=1, 5
1156 do i=1, 5
1157 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
1158 + vec_in(i,2,k) * mat_y_tr(2,j) &
1159 + vec_in(i,3,k) * mat_y_tr(3,j) &
1160 + vec_in(i,4,k) * mat_y_tr(4,j) &
1161 + vec_in(i,5,k) * mat_y_tr(5,j)
1162 end do
1163 end do
1164 end do
1165
1166 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p4 ( real(rp), dimension(5,5), intent(in) mat_z_tr,
real(rp), dimension(5,5,5), intent(in) vec_in,
real(rp), dimension(5,5,5), intent(out) vec_out )

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.

Definition at line 1173 of file scale_element_operation_tensorprod3D_kernel.F90.

1174 implicit none
1175 real(RP), intent(in) :: Mat_z_tr(5,5)
1176 real(RP), intent(in) :: vec_in(5,5,5)
1177 real(RP), intent(out) :: vec_out(5,5,5)
1178
1179 integer :: i, j, k
1180 !----------------------------------------------------------
1181
1182 do k=1, 5
1183 do j=1, 5
1184 do i=1, 5
1185 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1186 + vec_in(i,j,2) * mat_z_tr(2,k) &
1187 + vec_in(i,j,3) * mat_z_tr(3,k) &
1188 + vec_in(i,j,4) * mat_z_tr(4,k) &
1189 + vec_in(i,j,5) * mat_z_tr(5,k)
1190 end do
1191 end do
1192 end do
1193
1194 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p4 ( real(rp), dimension(5,5,5,6), intent(in) lift,
real(rp), dimension(5,5,6), intent(in) vec_in,
real(rp), dimension(5,5,5), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=4.

Definition at line 1200 of file scale_element_operation_tensorprod3D_kernel.F90.

1201 implicit none
1202 real(RP), intent(in) :: Lift(5,5,5,6)
1203 real(RP), intent(in) :: vec_in(5,5,6)
1204 real(RP), intent(out) :: vec_out(5,5,5)
1205
1206 integer :: i, j, k
1207 !----------------------------------------------------------
1208
1209 do k=1, 5
1210 do j=1, 5
1211 do i=1, 5
1212 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1213 + lift(i,j,k,2) * vec_in(j,k,2) &
1214 + lift(i,j,k,3) * vec_in(i,k,3) &
1215 + lift(i,j,k,4) * vec_in(j,k,4) &
1216 + lift(i,j,k,5) * vec_in(i,j,5) &
1217 + lift(i,j,k,6) * vec_in(i,j,6)
1218 end do
1219 end do
1220 end do
1221
1222 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p4 ( real(rp), dimension(5,5), intent(in) mat,
real(rp), dimension(5,5), intent(in) mat_tr,
real(rp), dimension(5,5,5), intent(in) vec_in,
real(rp), dimension(5,5**2), intent(in) vec_in_,
real(rp), dimension(5,5**2), intent(out) vec_out_x,
real(rp), dimension(5,5,5), intent(out) vec_out_y,
real(rp), dimension(5,5,5), intent(out) vec_out_z )

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.

Definition at line 1230 of file scale_element_operation_tensorprod3D_kernel.F90.

1232 implicit none
1233 real(RP), intent(in) :: Mat(5,5)
1234 real(RP), intent(in) :: Mat_tr(5,5)
1235 real(RP), intent(in) :: vec_in_(5,5**2)
1236 real(RP), intent(in) :: vec_in(5,5,5)
1237 real(RP), intent(out) :: vec_out_x(5,5**2)
1238 real(RP), intent(out) :: vec_out_y(5,5,5)
1239 real(RP), intent(out) :: vec_out_z(5,5,5)
1240
1241 integer :: i, j, k, jk
1242 !----------------------------------------------------------
1243
1244 ! X-dir
1245
1246 do jk=1, 5**2
1247 do i=1, 5
1248 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
1249 + mat(i,2) * vec_in_(2,jk) &
1250 + mat(i,3) * vec_in_(3,jk) &
1251 + mat(i,4) * vec_in_(4,jk) &
1252 + mat(i,5) * vec_in_(5,jk)
1253 end do
1254 end do
1255
1256 ! Y-dir
1257 do k=1, 5
1258 do j=1, 5
1259 do i=1, 5
1260 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1261 + vec_in(i,2,k) * mat_tr(2,j) &
1262 + vec_in(i,3,k) * mat_tr(3,j) &
1263 + vec_in(i,4,k) * mat_tr(4,j) &
1264 + vec_in(i,5,k) * mat_tr(5,j)
1265 end do
1266 end do
1267 end do
1268
1269 ! Z-dir
1270 do k=1, 5
1271 do j=1, 5
1272 do i=1, 5
1273 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1274 + vec_in(i,j,2) * mat_tr(2,k) &
1275 + vec_in(i,j,3) * mat_tr(3,k) &
1276 + vec_in(i,j,4) * mat_tr(4,k) &
1277 + vec_in(i,j,5) * mat_tr(5,k)
1278 end do
1279 end do
1280 end do
1281
1282 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p4 ( real(rp), dimension(5,5), intent(in) mat,
real(rp), dimension(5,5), intent(in) mat_tr,
real(rp), dimension(5,5**2), intent(in) vec_in_x,
real(rp), dimension(5,5,5), intent(in) vec_in_y,
real(rp), dimension(5,5,5), intent(in) vec_in_z,
real(rp), dimension(5,5**2), intent(out) vec_out_x,
real(rp), dimension(5,5**2), intent(out) vec_out_y,
real(rp), dimension(5,5**2), intent(out) vec_out_z )

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.

Definition at line 1290 of file scale_element_operation_tensorprod3D_kernel.F90.

1293 implicit none
1294 real(RP), intent(in) :: Mat(5,5)
1295 real(RP), intent(in) :: Mat_tr(5,5)
1296 real(RP), intent(in) :: vec_in_x(5,5**2)
1297 real(RP), intent(in) :: vec_in_y(5,5,5)
1298 real(RP), intent(in) :: vec_in_z(5,5,5)
1299 real(RP), intent(out) :: vec_out_x(5,5**2)
1300 real(RP), intent(out) :: vec_out_y(5,5**2)
1301 real(RP), intent(out) :: vec_out_z(5,5**2)
1302
1303 integer :: i, j, k, jk
1304 !----------------------------------------------------------
1305
1306 ! X-dir
1307
1308 do jk=1, 5**2
1309 do i=1, 5
1310 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
1311 + mat(i,2) * vec_in_x(2,jk) &
1312 + mat(i,3) * vec_in_x(3,jk) &
1313 + mat(i,4) * vec_in_x(4,jk) &
1314 + mat(i,5) * vec_in_x(5,jk)
1315 end do
1316 end do
1317
1318 ! Y-dir
1319 do k=1, 5
1320 do j=1, 5
1321 jk = j + (k-1)*5
1322 do i=1, 5
1323 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
1324 + vec_in_y(i,2,k) * mat_tr(2,j) &
1325 + vec_in_y(i,3,k) * mat_tr(3,j) &
1326 + vec_in_y(i,4,k) * mat_tr(4,j) &
1327 + vec_in_y(i,5,k) * mat_tr(5,j)
1328 end do
1329 end do
1330 end do
1331
1332 ! Z-dir
1333 do k=1, 5
1334 do j=1, 5
1335 jk = j + (k-1)*5
1336 do i=1, 5
1337 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
1338 + vec_in_z(i,j,2) * mat_tr(2,k) &
1339 + vec_in_z(i,j,3) * mat_tr(3,k) &
1340 + vec_in_z(i,j,4) * mat_tr(4,k) &
1341 + vec_in_z(i,j,5) * mat_tr(5,k)
1342 end do
1343 end do
1344 end do
1345 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p4()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p4 ( real(rp), dimension(5,5), intent(in) mat_h1d,
real(rp), dimension(5,5), intent(in) mat_h1d_tr,
real(rp), dimension(5,5), intent(in) mat_v1d_tr,
real(rp), dimension(5,5,5), intent(in) vec_in,
real(rp), dimension(5,5,5), intent(out) vec_work,
real(rp), dimension(5,5,5), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=4.

Definition at line 1412 of file scale_element_operation_tensorprod3D_kernel.F90.

1414 implicit none
1415 real(RP), intent(in) :: Mat_h1D(5,5)
1416 real(RP), intent(in) :: Mat_h1D_tr(5,5)
1417 real(RP), intent(in) :: Mat_v1D_tr(5,5)
1418 real(RP), intent(in) :: vec_in(5,5,5)
1419 real(RP), intent(out) :: vec_work(5,5,5)
1420 real(RP), intent(out) :: vec_out(5,5,5)
1421
1422 integer :: i, j, k
1423 !----------------------------------------------------------
1424
1425 ! X-dir
1426
1427 do k=1, 5
1428 do j=1, 5
1429 do i=1, 5
1430 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
1431 + mat_h1d(i,2) * vec_in(2,j,k) &
1432 + mat_h1d(i,3) * vec_in(3,j,k) &
1433 + mat_h1d(i,4) * vec_in(4,j,k) &
1434 + mat_h1d(i,5) * vec_in(5,j,k)
1435 end do
1436 end do
1437 end do
1438
1439 ! Y-dir
1440 do k=1, 5
1441 do j=1, 5
1442 do i=1, 5
1443 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
1444 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
1445 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
1446 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
1447 + vec_out(i,5,k) * mat_h1d_tr(5,j)
1448 end do
1449 end do
1450 end do
1451
1452 ! Z-dir
1453 do k=1, 5
1454 do j=1, 5
1455 do i=1, 5
1456 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
1457 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
1458 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
1459 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
1460 + vec_work(i,j,5) * mat_v1d_tr(5,k)
1461 end do
1462 end do
1463 end do
1464
1465 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p5 ( real(rp), dimension(6,6), intent(in) mat_x,
real(rp), dimension(6,6**2), intent(in) vec_in,
real(rp), dimension(6,6**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=5.

Definition at line 1473 of file scale_element_operation_tensorprod3D_kernel.F90.

1474 implicit none
1475 real(RP), intent(in) :: Mat_x(6,6)
1476 real(RP), intent(in) :: vec_in(6,6**2)
1477 real(RP), intent(out) :: vec_out(6,6**2)
1478
1479 integer :: i, jk
1480 !----------------------------------------------------------
1481
1482 do jk=1, 6**2
1483 do i=1, 6
1484 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
1485 + mat_x(i,2) * vec_in(2,jk) &
1486 + mat_x(i,3) * vec_in(3,jk) &
1487 + mat_x(i,4) * vec_in(4,jk) &
1488 + mat_x(i,5) * vec_in(5,jk) &
1489 + mat_x(i,6) * vec_in(6,jk)
1490 end do
1491 end do
1492
1493 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p5 ( real(rp), dimension(6,6), intent(in) mat_y_tr,
real(rp), dimension(6,6,6), intent(in) vec_in,
real(rp), dimension(6,6,6), intent(out) vec_out )

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.

Definition at line 1500 of file scale_element_operation_tensorprod3D_kernel.F90.

1501 implicit none
1502 real(RP), intent(in) :: Mat_y_tr(6,6)
1503 real(RP), intent(in) :: vec_in(6,6,6)
1504 real(RP), intent(out) :: vec_out(6,6,6)
1505
1506 integer :: i, j, k
1507 !----------------------------------------------------------
1508
1509 do k=1, 6
1510 do j=1, 6
1511 do i=1, 6
1512 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
1513 + vec_in(i,2,k) * mat_y_tr(2,j) &
1514 + vec_in(i,3,k) * mat_y_tr(3,j) &
1515 + vec_in(i,4,k) * mat_y_tr(4,j) &
1516 + vec_in(i,5,k) * mat_y_tr(5,j) &
1517 + vec_in(i,6,k) * mat_y_tr(6,j)
1518 end do
1519 end do
1520 end do
1521
1522 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p5 ( real(rp), dimension(6,6), intent(in) mat_z_tr,
real(rp), dimension(6,6,6), intent(in) vec_in,
real(rp), dimension(6,6,6), intent(out) vec_out )

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.

Definition at line 1529 of file scale_element_operation_tensorprod3D_kernel.F90.

1530 implicit none
1531 real(RP), intent(in) :: Mat_z_tr(6,6)
1532 real(RP), intent(in) :: vec_in(6,6,6)
1533 real(RP), intent(out) :: vec_out(6,6,6)
1534
1535 integer :: i, j, k
1536 !----------------------------------------------------------
1537
1538 do k=1, 6
1539 do j=1, 6
1540 do i=1, 6
1541 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1542 + vec_in(i,j,2) * mat_z_tr(2,k) &
1543 + vec_in(i,j,3) * mat_z_tr(3,k) &
1544 + vec_in(i,j,4) * mat_z_tr(4,k) &
1545 + vec_in(i,j,5) * mat_z_tr(5,k) &
1546 + vec_in(i,j,6) * mat_z_tr(6,k)
1547 end do
1548 end do
1549 end do
1550
1551 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p5 ( real(rp), dimension(6,6,6,6), intent(in) lift,
real(rp), dimension(6,6,6), intent(in) vec_in,
real(rp), dimension(6,6,6), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=5.

Definition at line 1557 of file scale_element_operation_tensorprod3D_kernel.F90.

1558 implicit none
1559 real(RP), intent(in) :: Lift(6,6,6,6)
1560 real(RP), intent(in) :: vec_in(6,6,6)
1561 real(RP), intent(out) :: vec_out(6,6,6)
1562
1563 integer :: i, j, k
1564 !----------------------------------------------------------
1565
1566 do k=1, 6
1567 do j=1, 6
1568 do i=1, 6
1569 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1570 + lift(i,j,k,2) * vec_in(j,k,2) &
1571 + lift(i,j,k,3) * vec_in(i,k,3) &
1572 + lift(i,j,k,4) * vec_in(j,k,4) &
1573 + lift(i,j,k,5) * vec_in(i,j,5) &
1574 + lift(i,j,k,6) * vec_in(i,j,6)
1575 end do
1576 end do
1577 end do
1578
1579 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p5 ( real(rp), dimension(6,6), intent(in) mat,
real(rp), dimension(6,6), intent(in) mat_tr,
real(rp), dimension(6,6,6), intent(in) vec_in,
real(rp), dimension(6,6**2), intent(in) vec_in_,
real(rp), dimension(6,6**2), intent(out) vec_out_x,
real(rp), dimension(6,6,6), intent(out) vec_out_y,
real(rp), dimension(6,6,6), intent(out) vec_out_z )

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.

Definition at line 1587 of file scale_element_operation_tensorprod3D_kernel.F90.

1589 implicit none
1590 real(RP), intent(in) :: Mat(6,6)
1591 real(RP), intent(in) :: Mat_tr(6,6)
1592 real(RP), intent(in) :: vec_in_(6,6**2)
1593 real(RP), intent(in) :: vec_in(6,6,6)
1594 real(RP), intent(out) :: vec_out_x(6,6**2)
1595 real(RP), intent(out) :: vec_out_y(6,6,6)
1596 real(RP), intent(out) :: vec_out_z(6,6,6)
1597
1598 integer :: i, j, k, jk
1599 !----------------------------------------------------------
1600
1601 ! X-dir
1602
1603 do jk=1, 6**2
1604 do i=1, 6
1605 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
1606 + mat(i,2) * vec_in_(2,jk) &
1607 + mat(i,3) * vec_in_(3,jk) &
1608 + mat(i,4) * vec_in_(4,jk) &
1609 + mat(i,5) * vec_in_(5,jk) &
1610 + mat(i,6) * vec_in_(6,jk)
1611 end do
1612 end do
1613
1614 ! Y-dir
1615 do k=1, 6
1616 do j=1, 6
1617 do i=1, 6
1618 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1619 + vec_in(i,2,k) * mat_tr(2,j) &
1620 + vec_in(i,3,k) * mat_tr(3,j) &
1621 + vec_in(i,4,k) * mat_tr(4,j) &
1622 + vec_in(i,5,k) * mat_tr(5,j) &
1623 + vec_in(i,6,k) * mat_tr(6,j)
1624 end do
1625 end do
1626 end do
1627
1628 ! Z-dir
1629 do k=1, 6
1630 do j=1, 6
1631 do i=1, 6
1632 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1633 + vec_in(i,j,2) * mat_tr(2,k) &
1634 + vec_in(i,j,3) * mat_tr(3,k) &
1635 + vec_in(i,j,4) * mat_tr(4,k) &
1636 + vec_in(i,j,5) * mat_tr(5,k) &
1637 + vec_in(i,j,6) * mat_tr(6,k)
1638 end do
1639 end do
1640 end do
1641
1642 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p5 ( real(rp), dimension(6,6), intent(in) mat,
real(rp), dimension(6,6), intent(in) mat_tr,
real(rp), dimension(6,6**2), intent(in) vec_in_x,
real(rp), dimension(6,6,6), intent(in) vec_in_y,
real(rp), dimension(6,6,6), intent(in) vec_in_z,
real(rp), dimension(6,6**2), intent(out) vec_out_x,
real(rp), dimension(6,6**2), intent(out) vec_out_y,
real(rp), dimension(6,6**2), intent(out) vec_out_z )

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.

Definition at line 1650 of file scale_element_operation_tensorprod3D_kernel.F90.

1653 implicit none
1654 real(RP), intent(in) :: Mat(6,6)
1655 real(RP), intent(in) :: Mat_tr(6,6)
1656 real(RP), intent(in) :: vec_in_x(6,6**2)
1657 real(RP), intent(in) :: vec_in_y(6,6,6)
1658 real(RP), intent(in) :: vec_in_z(6,6,6)
1659 real(RP), intent(out) :: vec_out_x(6,6**2)
1660 real(RP), intent(out) :: vec_out_y(6,6**2)
1661 real(RP), intent(out) :: vec_out_z(6,6**2)
1662
1663 integer :: i, j, k, jk
1664 !----------------------------------------------------------
1665
1666 ! X-dir
1667
1668 do jk=1, 6**2
1669 do i=1, 6
1670 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
1671 + mat(i,2) * vec_in_x(2,jk) &
1672 + mat(i,3) * vec_in_x(3,jk) &
1673 + mat(i,4) * vec_in_x(4,jk) &
1674 + mat(i,5) * vec_in_x(5,jk) &
1675 + mat(i,6) * vec_in_x(6,jk)
1676 end do
1677 end do
1678
1679 ! Y-dir
1680 do k=1, 6
1681 do j=1, 6
1682 jk = j + (k-1)*6
1683 do i=1, 6
1684 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
1685 + vec_in_y(i,2,k) * mat_tr(2,j) &
1686 + vec_in_y(i,3,k) * mat_tr(3,j) &
1687 + vec_in_y(i,4,k) * mat_tr(4,j) &
1688 + vec_in_y(i,5,k) * mat_tr(5,j) &
1689 + vec_in_y(i,6,k) * mat_tr(6,j)
1690 end do
1691 end do
1692 end do
1693
1694 ! Z-dir
1695 do k=1, 6
1696 do j=1, 6
1697 jk = j + (k-1)*6
1698 do i=1, 6
1699 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
1700 + vec_in_z(i,j,2) * mat_tr(2,k) &
1701 + vec_in_z(i,j,3) * mat_tr(3,k) &
1702 + vec_in_z(i,j,4) * mat_tr(4,k) &
1703 + vec_in_z(i,j,5) * mat_tr(5,k) &
1704 + vec_in_z(i,j,6) * mat_tr(6,k)
1705 end do
1706 end do
1707 end do
1708 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p5()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p5 ( real(rp), dimension(6,6), intent(in) mat_h1d,
real(rp), dimension(6,6), intent(in) mat_h1d_tr,
real(rp), dimension(6,6), intent(in) mat_v1d_tr,
real(rp), dimension(6,6,6), intent(in) vec_in,
real(rp), dimension(6,6,6), intent(out) vec_work,
real(rp), dimension(6,6,6), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=5.

Definition at line 1778 of file scale_element_operation_tensorprod3D_kernel.F90.

1780 implicit none
1781 real(RP), intent(in) :: Mat_h1D(6,6)
1782 real(RP), intent(in) :: Mat_h1D_tr(6,6)
1783 real(RP), intent(in) :: Mat_v1D_tr(6,6)
1784 real(RP), intent(in) :: vec_in(6,6,6)
1785 real(RP), intent(out) :: vec_work(6,6,6)
1786 real(RP), intent(out) :: vec_out(6,6,6)
1787
1788 integer :: i, j, k
1789 !----------------------------------------------------------
1790
1791 ! X-dir
1792
1793 do k=1, 6
1794 do j=1, 6
1795 do i=1, 6
1796 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
1797 + mat_h1d(i,2) * vec_in(2,j,k) &
1798 + mat_h1d(i,3) * vec_in(3,j,k) &
1799 + mat_h1d(i,4) * vec_in(4,j,k) &
1800 + mat_h1d(i,5) * vec_in(5,j,k) &
1801 + mat_h1d(i,6) * vec_in(6,j,k)
1802 end do
1803 end do
1804 end do
1805
1806 ! Y-dir
1807 do k=1, 6
1808 do j=1, 6
1809 do i=1, 6
1810 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
1811 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
1812 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
1813 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
1814 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
1815 + vec_out(i,6,k) * mat_h1d_tr(6,j)
1816 end do
1817 end do
1818 end do
1819
1820 ! Z-dir
1821 do k=1, 6
1822 do j=1, 6
1823 do i=1, 6
1824 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
1825 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
1826 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
1827 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
1828 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
1829 + vec_work(i,j,6) * mat_v1d_tr(6,k)
1830 end do
1831 end do
1832 end do
1833
1834 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p6 ( real(rp), dimension(7,7), intent(in) mat_x,
real(rp), dimension(7,7**2), intent(in) vec_in,
real(rp), dimension(7,7**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=6.

Definition at line 1842 of file scale_element_operation_tensorprod3D_kernel.F90.

1843 implicit none
1844 real(RP), intent(in) :: Mat_x(7,7)
1845 real(RP), intent(in) :: vec_in(7,7**2)
1846 real(RP), intent(out) :: vec_out(7,7**2)
1847
1848 integer :: i, jk
1849 !----------------------------------------------------------
1850
1851 do jk=1, 7**2
1852 do i=1, 7
1853 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
1854 + mat_x(i,2) * vec_in(2,jk) &
1855 + mat_x(i,3) * vec_in(3,jk) &
1856 + mat_x(i,4) * vec_in(4,jk) &
1857 + mat_x(i,5) * vec_in(5,jk) &
1858 + mat_x(i,6) * vec_in(6,jk) &
1859 + mat_x(i,7) * vec_in(7,jk)
1860 end do
1861 end do
1862
1863 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p6 ( real(rp), dimension(7,7), intent(in) mat_y_tr,
real(rp), dimension(7,7,7), intent(in) vec_in,
real(rp), dimension(7,7,7), intent(out) vec_out )

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.

Definition at line 1870 of file scale_element_operation_tensorprod3D_kernel.F90.

1871 implicit none
1872 real(RP), intent(in) :: Mat_y_tr(7,7)
1873 real(RP), intent(in) :: vec_in(7,7,7)
1874 real(RP), intent(out) :: vec_out(7,7,7)
1875
1876 integer :: i, j, k
1877 !----------------------------------------------------------
1878
1879 do k=1, 7
1880 do j=1, 7
1881 do i=1, 7
1882 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
1883 + vec_in(i,2,k) * mat_y_tr(2,j) &
1884 + vec_in(i,3,k) * mat_y_tr(3,j) &
1885 + vec_in(i,4,k) * mat_y_tr(4,j) &
1886 + vec_in(i,5,k) * mat_y_tr(5,j) &
1887 + vec_in(i,6,k) * mat_y_tr(6,j) &
1888 + vec_in(i,7,k) * mat_y_tr(7,j)
1889 end do
1890 end do
1891 end do
1892
1893 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p6 ( real(rp), dimension(7,7), intent(in) mat_z_tr,
real(rp), dimension(7,7,7), intent(in) vec_in,
real(rp), dimension(7,7,7), intent(out) vec_out )

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.

Definition at line 1900 of file scale_element_operation_tensorprod3D_kernel.F90.

1901 implicit none
1902 real(RP), intent(in) :: Mat_z_tr(7,7)
1903 real(RP), intent(in) :: vec_in(7,7,7)
1904 real(RP), intent(out) :: vec_out(7,7,7)
1905
1906 integer :: i, j, k
1907 !----------------------------------------------------------
1908
1909 do k=1, 7
1910 do j=1, 7
1911 do i=1, 7
1912 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1913 + vec_in(i,j,2) * mat_z_tr(2,k) &
1914 + vec_in(i,j,3) * mat_z_tr(3,k) &
1915 + vec_in(i,j,4) * mat_z_tr(4,k) &
1916 + vec_in(i,j,5) * mat_z_tr(5,k) &
1917 + vec_in(i,j,6) * mat_z_tr(6,k) &
1918 + vec_in(i,j,7) * mat_z_tr(7,k)
1919 end do
1920 end do
1921 end do
1922
1923 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p6 ( real(rp), dimension(7,7,7,6), intent(in) lift,
real(rp), dimension(7,7,6), intent(in) vec_in,
real(rp), dimension(7,7,7), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=6.

Definition at line 1929 of file scale_element_operation_tensorprod3D_kernel.F90.

1930 implicit none
1931 real(RP), intent(in) :: Lift(7,7,7,6)
1932 real(RP), intent(in) :: vec_in(7,7,6)
1933 real(RP), intent(out) :: vec_out(7,7,7)
1934
1935 integer :: i, j, k
1936 !----------------------------------------------------------
1937
1938 do k=1, 7
1939 do j=1, 7
1940 do i=1, 7
1941 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1942 + lift(i,j,k,2) * vec_in(j,k,2) &
1943 + lift(i,j,k,3) * vec_in(i,k,3) &
1944 + lift(i,j,k,4) * vec_in(j,k,4) &
1945 + lift(i,j,k,5) * vec_in(i,j,5) &
1946 + lift(i,j,k,6) * vec_in(i,j,6)
1947 end do
1948 end do
1949 end do
1950
1951 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p6 ( real(rp), dimension(7,7), intent(in) mat,
real(rp), dimension(7,7), intent(in) mat_tr,
real(rp), dimension(7,7,7), intent(in) vec_in,
real(rp), dimension(7,7**2), intent(in) vec_in_,
real(rp), dimension(7,7**2), intent(out) vec_out_x,
real(rp), dimension(7,7,7), intent(out) vec_out_y,
real(rp), dimension(7,7,7), intent(out) vec_out_z )

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.

Definition at line 1959 of file scale_element_operation_tensorprod3D_kernel.F90.

1961 implicit none
1962 real(RP), intent(in) :: Mat(7,7)
1963 real(RP), intent(in) :: Mat_tr(7,7)
1964 real(RP), intent(in) :: vec_in_(7,7**2)
1965 real(RP), intent(in) :: vec_in(7,7,7)
1966 real(RP), intent(out) :: vec_out_x(7,7**2)
1967 real(RP), intent(out) :: vec_out_y(7,7,7)
1968 real(RP), intent(out) :: vec_out_z(7,7,7)
1969
1970 integer :: i, j, k, jk
1971 !----------------------------------------------------------
1972
1973 ! X-dir
1974
1975 do jk=1, 7**2
1976 do i=1, 7
1977 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
1978 + mat(i,2) * vec_in_(2,jk) &
1979 + mat(i,3) * vec_in_(3,jk) &
1980 + mat(i,4) * vec_in_(4,jk) &
1981 + mat(i,5) * vec_in_(5,jk) &
1982 + mat(i,6) * vec_in_(6,jk) &
1983 + mat(i,7) * vec_in_(7,jk)
1984 end do
1985 end do
1986
1987 ! Y-dir
1988 do k=1, 7
1989 do j=1, 7
1990 do i=1, 7
1991 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1992 + vec_in(i,2,k) * mat_tr(2,j) &
1993 + vec_in(i,3,k) * mat_tr(3,j) &
1994 + vec_in(i,4,k) * mat_tr(4,j) &
1995 + vec_in(i,5,k) * mat_tr(5,j) &
1996 + vec_in(i,6,k) * mat_tr(6,j) &
1997 + vec_in(i,7,k) * mat_tr(7,j)
1998 end do
1999 end do
2000 end do
2001
2002 ! Z-dir
2003 do k=1, 7
2004 do j=1, 7
2005 do i=1, 7
2006 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2007 + vec_in(i,j,2) * mat_tr(2,k) &
2008 + vec_in(i,j,3) * mat_tr(3,k) &
2009 + vec_in(i,j,4) * mat_tr(4,k) &
2010 + vec_in(i,j,5) * mat_tr(5,k) &
2011 + vec_in(i,j,6) * mat_tr(6,k) &
2012 + vec_in(i,j,7) * mat_tr(7,k)
2013 end do
2014 end do
2015 end do
2016
2017 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p6 ( real(rp), dimension(7,7), intent(in) mat,
real(rp), dimension(7,7), intent(in) mat_tr,
real(rp), dimension(7,7**2), intent(in) vec_in_x,
real(rp), dimension(7,7,7), intent(in) vec_in_y,
real(rp), dimension(7,7,7), intent(in) vec_in_z,
real(rp), dimension(7,7**2), intent(out) vec_out_x,
real(rp), dimension(7,7**2), intent(out) vec_out_y,
real(rp), dimension(7,7**2), intent(out) vec_out_z )

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.

Definition at line 2025 of file scale_element_operation_tensorprod3D_kernel.F90.

2028 implicit none
2029 real(RP), intent(in) :: Mat(7,7)
2030 real(RP), intent(in) :: Mat_tr(7,7)
2031 real(RP), intent(in) :: vec_in_x(7,7**2)
2032 real(RP), intent(in) :: vec_in_y(7,7,7)
2033 real(RP), intent(in) :: vec_in_z(7,7,7)
2034 real(RP), intent(out) :: vec_out_x(7,7**2)
2035 real(RP), intent(out) :: vec_out_y(7,7**2)
2036 real(RP), intent(out) :: vec_out_z(7,7**2)
2037
2038 integer :: i, j, k, jk
2039 !----------------------------------------------------------
2040
2041 ! X-dir
2042
2043 do jk=1, 7**2
2044 do i=1, 7
2045 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
2046 + mat(i,2) * vec_in_x(2,jk) &
2047 + mat(i,3) * vec_in_x(3,jk) &
2048 + mat(i,4) * vec_in_x(4,jk) &
2049 + mat(i,5) * vec_in_x(5,jk) &
2050 + mat(i,6) * vec_in_x(6,jk) &
2051 + mat(i,7) * vec_in_x(7,jk)
2052 end do
2053 end do
2054
2055 ! Y-dir
2056 do k=1, 7
2057 do j=1, 7
2058 jk = j + (k-1)*7
2059 do i=1, 7
2060 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
2061 + vec_in_y(i,2,k) * mat_tr(2,j) &
2062 + vec_in_y(i,3,k) * mat_tr(3,j) &
2063 + vec_in_y(i,4,k) * mat_tr(4,j) &
2064 + vec_in_y(i,5,k) * mat_tr(5,j) &
2065 + vec_in_y(i,6,k) * mat_tr(6,j) &
2066 + vec_in_y(i,7,k) * mat_tr(7,j)
2067 end do
2068 end do
2069 end do
2070
2071 ! Z-dir
2072 do k=1, 7
2073 do j=1, 7
2074 jk = j + (k-1)*7
2075 do i=1, 7
2076 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
2077 + vec_in_z(i,j,2) * mat_tr(2,k) &
2078 + vec_in_z(i,j,3) * mat_tr(3,k) &
2079 + vec_in_z(i,j,4) * mat_tr(4,k) &
2080 + vec_in_z(i,j,5) * mat_tr(5,k) &
2081 + vec_in_z(i,j,6) * mat_tr(6,k) &
2082 + vec_in_z(i,j,7) * mat_tr(7,k)
2083 end do
2084 end do
2085 end do
2086 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p6()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p6 ( real(rp), dimension(7,7), intent(in) mat_h1d,
real(rp), dimension(7,7), intent(in) mat_h1d_tr,
real(rp), dimension(7,7), intent(in) mat_v1d_tr,
real(rp), dimension(7,7,7), intent(in) vec_in,
real(rp), dimension(7,7,7), intent(out) vec_work,
real(rp), dimension(7,7,7), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=6.

Definition at line 2159 of file scale_element_operation_tensorprod3D_kernel.F90.

2161 implicit none
2162 real(RP), intent(in) :: Mat_h1D(7,7)
2163 real(RP), intent(in) :: Mat_h1D_tr(7,7)
2164 real(RP), intent(in) :: Mat_v1D_tr(7,7)
2165 real(RP), intent(in) :: vec_in(7,7,7)
2166 real(RP), intent(out) :: vec_work(7,7,7)
2167 real(RP), intent(out) :: vec_out(7,7,7)
2168
2169 integer :: i, j, k
2170 !----------------------------------------------------------
2171
2172 ! X-dir
2173
2174 do k=1, 7
2175 do j=1, 7
2176 do i=1, 7
2177 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
2178 + mat_h1d(i,2) * vec_in(2,j,k) &
2179 + mat_h1d(i,3) * vec_in(3,j,k) &
2180 + mat_h1d(i,4) * vec_in(4,j,k) &
2181 + mat_h1d(i,5) * vec_in(5,j,k) &
2182 + mat_h1d(i,6) * vec_in(6,j,k) &
2183 + mat_h1d(i,7) * vec_in(7,j,k)
2184 end do
2185 end do
2186 end do
2187
2188 ! Y-dir
2189 do k=1, 7
2190 do j=1, 7
2191 do i=1, 7
2192 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
2193 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
2194 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
2195 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
2196 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
2197 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
2198 + vec_out(i,7,k) * mat_h1d_tr(7,j)
2199 end do
2200 end do
2201 end do
2202
2203 ! Z-dir
2204 do k=1, 7
2205 do j=1, 7
2206 do i=1, 7
2207 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
2208 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
2209 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
2210 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
2211 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
2212 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
2213 + vec_work(i,j,7) * mat_v1d_tr(7,k)
2214 end do
2215 end do
2216 end do
2217
2218 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p7 ( real(rp), dimension(8,8), intent(in) mat_x,
real(rp), dimension(8,8**2), intent(in) vec_in,
real(rp), dimension(8,8**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=7.

Definition at line 2226 of file scale_element_operation_tensorprod3D_kernel.F90.

2227 implicit none
2228 real(RP), intent(in) :: Mat_x(8,8)
2229 real(RP), intent(in) :: vec_in(8,8**2)
2230 real(RP), intent(out) :: vec_out(8,8**2)
2231
2232 integer :: i, jk
2233 !----------------------------------------------------------
2234
2235 do jk=1, 8**2
2236 do i=1, 8
2237 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
2238 + mat_x(i,2) * vec_in(2,jk) &
2239 + mat_x(i,3) * vec_in(3,jk) &
2240 + mat_x(i,4) * vec_in(4,jk) &
2241 + mat_x(i,5) * vec_in(5,jk) &
2242 + mat_x(i,6) * vec_in(6,jk) &
2243 + mat_x(i,7) * vec_in(7,jk) &
2244 + mat_x(i,8) * vec_in(8,jk)
2245 end do
2246 end do
2247
2248 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p7 ( real(rp), dimension(8,8), intent(in) mat_y_tr,
real(rp), dimension(8,8,8), intent(in) vec_in,
real(rp), dimension(8,8,8), intent(out) vec_out )

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.

Definition at line 2255 of file scale_element_operation_tensorprod3D_kernel.F90.

2256 implicit none
2257 real(RP), intent(in) :: Mat_y_tr(8,8)
2258 real(RP), intent(in) :: vec_in(8,8,8)
2259 real(RP), intent(out) :: vec_out(8,8,8)
2260
2261 integer :: i, j, k
2262 !----------------------------------------------------------
2263
2264 do k=1, 8
2265 do j=1, 8
2266 do i=1, 8
2267 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
2268 + vec_in(i,2,k) * mat_y_tr(2,j) &
2269 + vec_in(i,3,k) * mat_y_tr(3,j) &
2270 + vec_in(i,4,k) * mat_y_tr(4,j) &
2271 + vec_in(i,5,k) * mat_y_tr(5,j) &
2272 + vec_in(i,6,k) * mat_y_tr(6,j) &
2273 + vec_in(i,7,k) * mat_y_tr(7,j) &
2274 + vec_in(i,8,k) * mat_y_tr(8,j)
2275 end do
2276 end do
2277 end do
2278
2279 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p7 ( real(rp), dimension(8,8), intent(in) mat_z_tr,
real(rp), dimension(8,8,8), intent(in) vec_in,
real(rp), dimension(8,8,8), intent(out) vec_out )

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.

Definition at line 2286 of file scale_element_operation_tensorprod3D_kernel.F90.

2287 implicit none
2288 real(RP), intent(in) :: Mat_z_tr(8,8)
2289 real(RP), intent(in) :: vec_in(8,8,8)
2290 real(RP), intent(out) :: vec_out(8,8,8)
2291
2292 integer :: i, j, k
2293 !----------------------------------------------------------
2294
2295 do k=1, 8
2296 do j=1, 8
2297 do i=1, 8
2298 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
2299 + vec_in(i,j,2) * mat_z_tr(2,k) &
2300 + vec_in(i,j,3) * mat_z_tr(3,k) &
2301 + vec_in(i,j,4) * mat_z_tr(4,k) &
2302 + vec_in(i,j,5) * mat_z_tr(5,k) &
2303 + vec_in(i,j,6) * mat_z_tr(6,k) &
2304 + vec_in(i,j,7) * mat_z_tr(7,k) &
2305 + vec_in(i,j,8) * mat_z_tr(8,k)
2306 end do
2307 end do
2308 end do
2309
2310 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p7 ( real(rp), dimension(8,8,8,6), intent(in) lift,
real(rp), dimension(8,8,6), intent(in) vec_in,
real(rp), dimension(8,8,8), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=7.

Definition at line 2316 of file scale_element_operation_tensorprod3D_kernel.F90.

2317 implicit none
2318 real(RP), intent(in) :: Lift(8,8,8,6)
2319 real(RP), intent(in) :: vec_in(8,8,6)
2320 real(RP), intent(out) :: vec_out(8,8,8)
2321
2322 integer :: i, j, k
2323 !----------------------------------------------------------
2324
2325 do k=1, 8
2326 do j=1, 8
2327 do i=1, 8
2328 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
2329 + lift(i,j,k,2) * vec_in(j,k,2) &
2330 + lift(i,j,k,3) * vec_in(i,k,3) &
2331 + lift(i,j,k,4) * vec_in(j,k,4) &
2332 + lift(i,j,k,5) * vec_in(i,j,5) &
2333 + lift(i,j,k,6) * vec_in(i,j,6)
2334 end do
2335 end do
2336 end do
2337
2338 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p7 ( real(rp), dimension(8,8), intent(in) mat,
real(rp), dimension(8,8), intent(in) mat_tr,
real(rp), dimension(8,8,8), intent(in) vec_in,
real(rp), dimension(8,8**2), intent(in) vec_in_,
real(rp), dimension(8,8**2), intent(out) vec_out_x,
real(rp), dimension(8,8,8), intent(out) vec_out_y,
real(rp), dimension(8,8,8), intent(out) vec_out_z )

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.

Definition at line 2346 of file scale_element_operation_tensorprod3D_kernel.F90.

2348 implicit none
2349 real(RP), intent(in) :: Mat(8,8)
2350 real(RP), intent(in) :: Mat_tr(8,8)
2351 real(RP), intent(in) :: vec_in_(8,8**2)
2352 real(RP), intent(in) :: vec_in(8,8,8)
2353 real(RP), intent(out) :: vec_out_x(8,8**2)
2354 real(RP), intent(out) :: vec_out_y(8,8,8)
2355 real(RP), intent(out) :: vec_out_z(8,8,8)
2356
2357 integer :: i, j, k, jk
2358 !----------------------------------------------------------
2359
2360 ! X-dir
2361
2362 do jk=1, 8**2
2363 do i=1, 8
2364 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
2365 + mat(i,2) * vec_in_(2,jk) &
2366 + mat(i,3) * vec_in_(3,jk) &
2367 + mat(i,4) * vec_in_(4,jk) &
2368 + mat(i,5) * vec_in_(5,jk) &
2369 + mat(i,6) * vec_in_(6,jk) &
2370 + mat(i,7) * vec_in_(7,jk) &
2371 + mat(i,8) * vec_in_(8,jk)
2372 end do
2373 end do
2374
2375 ! Y-dir
2376 do k=1, 8
2377 do j=1, 8
2378 do i=1, 8
2379 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2380 + vec_in(i,2,k) * mat_tr(2,j) &
2381 + vec_in(i,3,k) * mat_tr(3,j) &
2382 + vec_in(i,4,k) * mat_tr(4,j) &
2383 + vec_in(i,5,k) * mat_tr(5,j) &
2384 + vec_in(i,6,k) * mat_tr(6,j) &
2385 + vec_in(i,7,k) * mat_tr(7,j) &
2386 + vec_in(i,8,k) * mat_tr(8,j)
2387 end do
2388 end do
2389 end do
2390
2391 ! Z-dir
2392 do k=1, 8
2393 do j=1, 8
2394 do i=1, 8
2395 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2396 + vec_in(i,j,2) * mat_tr(2,k) &
2397 + vec_in(i,j,3) * mat_tr(3,k) &
2398 + vec_in(i,j,4) * mat_tr(4,k) &
2399 + vec_in(i,j,5) * mat_tr(5,k) &
2400 + vec_in(i,j,6) * mat_tr(6,k) &
2401 + vec_in(i,j,7) * mat_tr(7,k) &
2402 + vec_in(i,j,8) * mat_tr(8,k)
2403 end do
2404 end do
2405 end do
2406
2407 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p7 ( real(rp), dimension(8,8), intent(in) mat,
real(rp), dimension(8,8), intent(in) mat_tr,
real(rp), dimension(8,8**2), intent(in) vec_in_x,
real(rp), dimension(8,8,8), intent(in) vec_in_y,
real(rp), dimension(8,8,8), intent(in) vec_in_z,
real(rp), dimension(8,8**2), intent(out) vec_out_x,
real(rp), dimension(8,8**2), intent(out) vec_out_y,
real(rp), dimension(8,8**2), intent(out) vec_out_z )

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.

Definition at line 2415 of file scale_element_operation_tensorprod3D_kernel.F90.

2418 implicit none
2419 real(RP), intent(in) :: Mat(8,8)
2420 real(RP), intent(in) :: Mat_tr(8,8)
2421 real(RP), intent(in) :: vec_in_x(8,8**2)
2422 real(RP), intent(in) :: vec_in_y(8,8,8)
2423 real(RP), intent(in) :: vec_in_z(8,8,8)
2424 real(RP), intent(out) :: vec_out_x(8,8**2)
2425 real(RP), intent(out) :: vec_out_y(8,8**2)
2426 real(RP), intent(out) :: vec_out_z(8,8**2)
2427
2428 integer :: i, j, k, jk
2429 !----------------------------------------------------------
2430
2431 ! X-dir
2432
2433 do jk=1, 8**2
2434 do i=1, 8
2435 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
2436 + mat(i,2) * vec_in_x(2,jk) &
2437 + mat(i,3) * vec_in_x(3,jk) &
2438 + mat(i,4) * vec_in_x(4,jk) &
2439 + mat(i,5) * vec_in_x(5,jk) &
2440 + mat(i,6) * vec_in_x(6,jk) &
2441 + mat(i,7) * vec_in_x(7,jk) &
2442 + mat(i,8) * vec_in_x(8,jk)
2443 end do
2444 end do
2445
2446 ! Y-dir
2447 do k=1, 8
2448 do j=1, 8
2449 jk = j + (k-1)*8
2450 do i=1, 8
2451 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
2452 + vec_in_y(i,2,k) * mat_tr(2,j) &
2453 + vec_in_y(i,3,k) * mat_tr(3,j) &
2454 + vec_in_y(i,4,k) * mat_tr(4,j) &
2455 + vec_in_y(i,5,k) * mat_tr(5,j) &
2456 + vec_in_y(i,6,k) * mat_tr(6,j) &
2457 + vec_in_y(i,7,k) * mat_tr(7,j) &
2458 + vec_in_y(i,8,k) * mat_tr(8,j)
2459 end do
2460 end do
2461 end do
2462
2463 ! Z-dir
2464 do k=1, 8
2465 do j=1, 8
2466 jk = j + (k-1)*8
2467 do i=1, 8
2468 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
2469 + vec_in_z(i,j,2) * mat_tr(2,k) &
2470 + vec_in_z(i,j,3) * mat_tr(3,k) &
2471 + vec_in_z(i,j,4) * mat_tr(4,k) &
2472 + vec_in_z(i,j,5) * mat_tr(5,k) &
2473 + vec_in_z(i,j,6) * mat_tr(6,k) &
2474 + vec_in_z(i,j,7) * mat_tr(7,k) &
2475 + vec_in_z(i,j,8) * mat_tr(8,k)
2476 end do
2477 end do
2478 end do
2479 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p7()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p7 ( real(rp), dimension(8,8), intent(in) mat_h1d,
real(rp), dimension(8,8), intent(in) mat_h1d_tr,
real(rp), dimension(8,8), intent(in) mat_v1d_tr,
real(rp), dimension(8,8,8), intent(in) vec_in,
real(rp), dimension(8,8,8), intent(out) vec_work,
real(rp), dimension(8,8,8), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=7.

Definition at line 2555 of file scale_element_operation_tensorprod3D_kernel.F90.

2557 implicit none
2558 real(RP), intent(in) :: Mat_h1D(8,8)
2559 real(RP), intent(in) :: Mat_h1D_tr(8,8)
2560 real(RP), intent(in) :: Mat_v1D_tr(8,8)
2561 real(RP), intent(in) :: vec_in(8,8,8)
2562 real(RP), intent(out) :: vec_work(8,8,8)
2563 real(RP), intent(out) :: vec_out(8,8,8)
2564
2565 integer :: i, j, k
2566 !----------------------------------------------------------
2567
2568 ! X-dir
2569
2570 do k=1, 8
2571 do j=1, 8
2572 do i=1, 8
2573 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
2574 + mat_h1d(i,2) * vec_in(2,j,k) &
2575 + mat_h1d(i,3) * vec_in(3,j,k) &
2576 + mat_h1d(i,4) * vec_in(4,j,k) &
2577 + mat_h1d(i,5) * vec_in(5,j,k) &
2578 + mat_h1d(i,6) * vec_in(6,j,k) &
2579 + mat_h1d(i,7) * vec_in(7,j,k) &
2580 + mat_h1d(i,8) * vec_in(8,j,k)
2581 end do
2582 end do
2583 end do
2584
2585 ! Y-dir
2586 do k=1, 8
2587 do j=1, 8
2588 do i=1, 8
2589 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
2590 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
2591 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
2592 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
2593 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
2594 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
2595 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
2596 + vec_out(i,8,k) * mat_h1d_tr(8,j)
2597 end do
2598 end do
2599 end do
2600
2601 ! Z-dir
2602 do k=1, 8
2603 do j=1, 8
2604 do i=1, 8
2605 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
2606 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
2607 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
2608 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
2609 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
2610 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
2611 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
2612 + vec_work(i,j,8) * mat_v1d_tr(8,k)
2613 end do
2614 end do
2615 end do
2616
2617 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p8 ( real(rp), dimension(9,9), intent(in) mat_x,
real(rp), dimension(9,9**2), intent(in) vec_in,
real(rp), dimension(9,9**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=8.

Definition at line 2625 of file scale_element_operation_tensorprod3D_kernel.F90.

2626 implicit none
2627 real(RP), intent(in) :: Mat_x(9,9)
2628 real(RP), intent(in) :: vec_in(9,9**2)
2629 real(RP), intent(out) :: vec_out(9,9**2)
2630
2631 integer :: i, jk
2632 !----------------------------------------------------------
2633
2634 do jk=1, 9**2
2635 do i=1, 9
2636 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
2637 + mat_x(i,2) * vec_in(2,jk) &
2638 + mat_x(i,3) * vec_in(3,jk) &
2639 + mat_x(i,4) * vec_in(4,jk) &
2640 + mat_x(i,5) * vec_in(5,jk) &
2641 + mat_x(i,6) * vec_in(6,jk) &
2642 + mat_x(i,7) * vec_in(7,jk) &
2643 + mat_x(i,8) * vec_in(8,jk) &
2644 + mat_x(i,9) * vec_in(9,jk)
2645 end do
2646 end do
2647
2648 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p8 ( real(rp), dimension(9,9), intent(in) mat_y_tr,
real(rp), dimension(9,9,9), intent(in) vec_in,
real(rp), dimension(9,9,9), intent(out) vec_out )

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.

Definition at line 2655 of file scale_element_operation_tensorprod3D_kernel.F90.

2656 implicit none
2657 real(RP), intent(in) :: Mat_y_tr(9,9)
2658 real(RP), intent(in) :: vec_in(9,9,9)
2659 real(RP), intent(out) :: vec_out(9,9,9)
2660
2661 integer :: i, j, k
2662 !----------------------------------------------------------
2663
2664 do k=1, 9
2665 do j=1, 9
2666 do i=1, 9
2667 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
2668 + vec_in(i,2,k) * mat_y_tr(2,j) &
2669 + vec_in(i,3,k) * mat_y_tr(3,j) &
2670 + vec_in(i,4,k) * mat_y_tr(4,j) &
2671 + vec_in(i,5,k) * mat_y_tr(5,j) &
2672 + vec_in(i,6,k) * mat_y_tr(6,j) &
2673 + vec_in(i,7,k) * mat_y_tr(7,j) &
2674 + vec_in(i,8,k) * mat_y_tr(8,j) &
2675 + vec_in(i,9,k) * mat_y_tr(9,j)
2676 end do
2677 end do
2678 end do
2679
2680 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p8 ( real(rp), dimension(9,9), intent(in) mat_z_tr,
real(rp), dimension(9,9,9), intent(in) vec_in,
real(rp), dimension(9,9,9), intent(out) vec_out )

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.

Definition at line 2687 of file scale_element_operation_tensorprod3D_kernel.F90.

2688 implicit none
2689 real(RP), intent(in) :: Mat_z_tr(9,9)
2690 real(RP), intent(in) :: vec_in(9,9,9)
2691 real(RP), intent(out) :: vec_out(9,9,9)
2692
2693 integer :: i, j, k
2694 !----------------------------------------------------------
2695
2696 do k=1, 9
2697 do j=1, 9
2698 do i=1, 9
2699 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
2700 + vec_in(i,j,2) * mat_z_tr(2,k) &
2701 + vec_in(i,j,3) * mat_z_tr(3,k) &
2702 + vec_in(i,j,4) * mat_z_tr(4,k) &
2703 + vec_in(i,j,5) * mat_z_tr(5,k) &
2704 + vec_in(i,j,6) * mat_z_tr(6,k) &
2705 + vec_in(i,j,7) * mat_z_tr(7,k) &
2706 + vec_in(i,j,8) * mat_z_tr(8,k) &
2707 + vec_in(i,j,9) * mat_z_tr(9,k)
2708 end do
2709 end do
2710 end do
2711
2712 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p8 ( real(rp), dimension(9,9,9,6), intent(in) lift,
real(rp), dimension(9,9,6), intent(in) vec_in,
real(rp), dimension(9,9,9), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=8.

Definition at line 2718 of file scale_element_operation_tensorprod3D_kernel.F90.

2719 implicit none
2720 real(RP), intent(in) :: Lift(9,9,9,6)
2721 real(RP), intent(in) :: vec_in(9,9,6)
2722 real(RP), intent(out) :: vec_out(9,9,9)
2723
2724 integer :: i, j, k
2725 !----------------------------------------------------------
2726
2727 do k=1, 9
2728 do j=1, 9
2729 do i=1, 9
2730 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
2731 + lift(i,j,k,2) * vec_in(j,k,2) &
2732 + lift(i,j,k,3) * vec_in(i,k,3) &
2733 + lift(i,j,k,4) * vec_in(j,k,4) &
2734 + lift(i,j,k,5) * vec_in(i,j,5) &
2735 + lift(i,j,k,6) * vec_in(i,j,6)
2736 end do
2737 end do
2738 end do
2739
2740 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p8 ( real(rp), dimension(9,9), intent(in) mat,
real(rp), dimension(9,9), intent(in) mat_tr,
real(rp), dimension(9,9,9), intent(in) vec_in,
real(rp), dimension(9,9**2), intent(in) vec_in_,
real(rp), dimension(9,9**2), intent(out) vec_out_x,
real(rp), dimension(9,9,9), intent(out) vec_out_y,
real(rp), dimension(9,9,9), intent(out) vec_out_z )

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.

Definition at line 2748 of file scale_element_operation_tensorprod3D_kernel.F90.

2750 implicit none
2751 real(RP), intent(in) :: Mat(9,9)
2752 real(RP), intent(in) :: Mat_tr(9,9)
2753 real(RP), intent(in) :: vec_in_(9,9**2)
2754 real(RP), intent(in) :: vec_in(9,9,9)
2755 real(RP), intent(out) :: vec_out_x(9,9**2)
2756 real(RP), intent(out) :: vec_out_y(9,9,9)
2757 real(RP), intent(out) :: vec_out_z(9,9,9)
2758
2759 integer :: i, j, k, jk
2760 !----------------------------------------------------------
2761
2762 ! X-dir
2763
2764 do jk=1, 9**2
2765 do i=1, 9
2766 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
2767 + mat(i,2) * vec_in_(2,jk) &
2768 + mat(i,3) * vec_in_(3,jk) &
2769 + mat(i,4) * vec_in_(4,jk) &
2770 + mat(i,5) * vec_in_(5,jk) &
2771 + mat(i,6) * vec_in_(6,jk) &
2772 + mat(i,7) * vec_in_(7,jk) &
2773 + mat(i,8) * vec_in_(8,jk) &
2774 + mat(i,9) * vec_in_(9,jk)
2775 end do
2776 end do
2777
2778 ! Y-dir
2779 do k=1, 9
2780 do j=1, 9
2781 do i=1, 9
2782 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2783 + vec_in(i,2,k) * mat_tr(2,j) &
2784 + vec_in(i,3,k) * mat_tr(3,j) &
2785 + vec_in(i,4,k) * mat_tr(4,j) &
2786 + vec_in(i,5,k) * mat_tr(5,j) &
2787 + vec_in(i,6,k) * mat_tr(6,j) &
2788 + vec_in(i,7,k) * mat_tr(7,j) &
2789 + vec_in(i,8,k) * mat_tr(8,j) &
2790 + vec_in(i,9,k) * mat_tr(9,j)
2791 end do
2792 end do
2793 end do
2794
2795 ! Z-dir
2796 do k=1, 9
2797 do j=1, 9
2798 do i=1, 9
2799 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2800 + vec_in(i,j,2) * mat_tr(2,k) &
2801 + vec_in(i,j,3) * mat_tr(3,k) &
2802 + vec_in(i,j,4) * mat_tr(4,k) &
2803 + vec_in(i,j,5) * mat_tr(5,k) &
2804 + vec_in(i,j,6) * mat_tr(6,k) &
2805 + vec_in(i,j,7) * mat_tr(7,k) &
2806 + vec_in(i,j,8) * mat_tr(8,k) &
2807 + vec_in(i,j,9) * mat_tr(9,k)
2808 end do
2809 end do
2810 end do
2811
2812 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p8 ( real(rp), dimension(9,9), intent(in) mat,
real(rp), dimension(9,9), intent(in) mat_tr,
real(rp), dimension(9,9**2), intent(in) vec_in_x,
real(rp), dimension(9,9,9), intent(in) vec_in_y,
real(rp), dimension(9,9,9), intent(in) vec_in_z,
real(rp), dimension(9,9**2), intent(out) vec_out_x,
real(rp), dimension(9,9**2), intent(out) vec_out_y,
real(rp), dimension(9,9**2), intent(out) vec_out_z )

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.

Definition at line 2820 of file scale_element_operation_tensorprod3D_kernel.F90.

2823 implicit none
2824 real(RP), intent(in) :: Mat(9,9)
2825 real(RP), intent(in) :: Mat_tr(9,9)
2826 real(RP), intent(in) :: vec_in_x(9,9**2)
2827 real(RP), intent(in) :: vec_in_y(9,9,9)
2828 real(RP), intent(in) :: vec_in_z(9,9,9)
2829 real(RP), intent(out) :: vec_out_x(9,9**2)
2830 real(RP), intent(out) :: vec_out_y(9,9**2)
2831 real(RP), intent(out) :: vec_out_z(9,9**2)
2832
2833 integer :: i, j, k, jk
2834 real(RP) :: tmp1, tmp2, tmp3
2835 !----------------------------------------------------------
2836
2837 ! X-dir
2838
2839 do jk=1, 9**2
2840 do i=1, 9
2841 tmp1 = mat(i,1) * vec_in_x(1,jk) &
2842 + mat(i,2) * vec_in_x(2,jk) &
2843 + mat(i,3) * vec_in_x(3,jk)
2844 tmp2 = mat(i,4) * vec_in_x(4,jk) &
2845 + mat(i,5) * vec_in_x(5,jk) &
2846 + mat(i,6) * vec_in_x(6,jk)
2847 tmp3 = mat(i,7) * vec_in_x(7,jk) &
2848 + mat(i,8) * vec_in_x(8,jk) &
2849 + mat(i,9) * vec_in_x(9,jk)
2850 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
2851 end do
2852 end do
2853
2854 ! Y-dir
2855 do k=1, 9
2856 do j=1, 9
2857 jk = j + (k-1)*9
2858 do i=1, 9
2859 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
2860 + vec_in_y(i,2,k) * mat_tr(2,j) &
2861 + vec_in_y(i,3,k) * mat_tr(3,j)
2862 tmp2 = vec_in_y(i,4,k) * mat_tr(4,j) &
2863 + vec_in_y(i,5,k) * mat_tr(5,j) &
2864 + vec_in_y(i,6,k) * mat_tr(6,j)
2865 tmp3 = vec_in_y(i,7,k) * mat_tr(7,j) &
2866 + vec_in_y(i,8,k) * mat_tr(8,j) &
2867 + vec_in_y(i,9,k) * mat_tr(9,j)
2868 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
2869 end do
2870 end do
2871 end do
2872
2873 ! Z-dir
2874 do k=1, 9
2875 do j=1, 9
2876 jk = j + (k-1)*9
2877 do i=1, 9
2878 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
2879 + vec_in_z(i,j,2) * mat_tr(2,k) &
2880 + vec_in_z(i,j,3) * mat_tr(3,k)
2881 tmp2 = vec_in_z(i,j,4) * mat_tr(4,k) &
2882 + vec_in_z(i,j,5) * mat_tr(5,k) &
2883 + vec_in_z(i,j,6) * mat_tr(6,k)
2884 tmp3 = vec_in_z(i,j,7) * mat_tr(7,k) &
2885 + vec_in_z(i,j,8) * mat_tr(8,k) &
2886 + vec_in_z(i,j,9) * mat_tr(9,k)
2887 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
2888 end do
2889 end do
2890 end do
2891 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p8()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p8 ( real(rp), dimension(9,9), intent(in) mat_h1d,
real(rp), dimension(9,9), intent(in) mat_h1d_tr,
real(rp), dimension(9,9), intent(in) mat_v1d_tr,
real(rp), dimension(9,9,9), intent(in) vec_in,
real(rp), dimension(9,9,9), intent(out) vec_work,
real(rp), dimension(9,9,9), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=8.

Definition at line 2974 of file scale_element_operation_tensorprod3D_kernel.F90.

2976 implicit none
2977 real(RP), intent(in) :: Mat_h1D(9,9)
2978 real(RP), intent(in) :: Mat_h1D_tr(9,9)
2979 real(RP), intent(in) :: Mat_v1D_tr(9,9)
2980 real(RP), intent(in) :: vec_in(9,9,9)
2981 real(RP), intent(out) :: vec_work(9,9,9)
2982 real(RP), intent(out) :: vec_out(9,9,9)
2983
2984 integer :: i, j, k
2985 real(RP) :: tmp1, tmp2, tmp3
2986 !----------------------------------------------------------
2987
2988 ! X-dir
2989
2990 do k=1, 9
2991 do j=1, 9
2992 do i=1, 9
2993 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
2994 + mat_h1d(i,2) * vec_in(2,j,k) &
2995 + mat_h1d(i,3) * vec_in(3,j,k)
2996 tmp2 = mat_h1d(i,4) * vec_in(4,j,k) &
2997 + mat_h1d(i,5) * vec_in(5,j,k) &
2998 + mat_h1d(i,6) * vec_in(6,j,k)
2999 tmp3 = mat_h1d(i,7) * vec_in(7,j,k) &
3000 + mat_h1d(i,8) * vec_in(8,j,k) &
3001 + mat_h1d(i,9) * vec_in(9,j,k)
3002 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3003 end do
3004 end do
3005 end do
3006
3007 ! Y-dir
3008 do k=1, 9
3009 do j=1, 9
3010 do i=1, 9
3011 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
3012 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
3013 + vec_out(i,3,k) * mat_h1d_tr(3,j)
3014 tmp2 = vec_out(i,4,k) * mat_h1d_tr(4,j) &
3015 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
3016 + vec_out(i,6,k) * mat_h1d_tr(6,j)
3017 tmp3 = vec_out(i,7,k) * mat_h1d_tr(7,j) &
3018 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
3019 + vec_out(i,9,k) * mat_h1d_tr(9,j)
3020 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
3021 end do
3022 end do
3023 end do
3024
3025 ! Z-dir
3026 do k=1, 9
3027 do j=1, 9
3028 do i=1, 9
3029 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
3030 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
3031 + vec_work(i,j,3) * mat_v1d_tr(3,k)
3032 tmp2 = vec_work(i,j,4) * mat_v1d_tr(4,k) &
3033 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
3034 + vec_work(i,j,6) * mat_v1d_tr(6,k)
3035 tmp3 = vec_work(i,j,7) * mat_v1d_tr(7,k) &
3036 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
3037 + vec_work(i,j,9) * mat_v1d_tr(9,k)
3038 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3039 end do
3040 end do
3041 end do
3042
3043 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p9 ( real(rp), dimension(10,10), intent(in) mat_x,
real(rp), dimension(10,10**2), intent(in) vec_in,
real(rp), dimension(10,10**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=9.

Definition at line 3051 of file scale_element_operation_tensorprod3D_kernel.F90.

3052 implicit none
3053 real(RP), intent(in) :: Mat_x(10,10)
3054 real(RP), intent(in) :: vec_in(10,10**2)
3055 real(RP), intent(out) :: vec_out(10,10**2)
3056
3057 integer :: i, jk
3058 !----------------------------------------------------------
3059
3060 do jk=1, 10**2
3061 do i=1, 10
3062 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
3063 + mat_x(i,2) * vec_in(2,jk) &
3064 + mat_x(i,3) * vec_in(3,jk) &
3065 + mat_x(i,4) * vec_in(4,jk) &
3066 + mat_x(i,5) * vec_in(5,jk) &
3067 + mat_x(i,6) * vec_in(6,jk) &
3068 + mat_x(i,7) * vec_in(7,jk) &
3069 + mat_x(i,8) * vec_in(8,jk) &
3070 + mat_x(i,9) * vec_in(9,jk) &
3071 + mat_x(i,10) * vec_in(10,jk)
3072 end do
3073 end do
3074
3075 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p9 ( real(rp), dimension(10,10), intent(in) mat_y_tr,
real(rp), dimension(10,10,10), intent(in) vec_in,
real(rp), dimension(10,10,10), intent(out) vec_out )

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.

Definition at line 3082 of file scale_element_operation_tensorprod3D_kernel.F90.

3083 implicit none
3084 real(RP), intent(in) :: Mat_y_tr(10,10)
3085 real(RP), intent(in) :: vec_in(10,10,10)
3086 real(RP), intent(out) :: vec_out(10,10,10)
3087
3088 integer :: i, j, k
3089 !----------------------------------------------------------
3090
3091 do k=1, 10
3092 do j=1, 10
3093 do i=1, 10
3094 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
3095 + vec_in(i,2,k) * mat_y_tr(2,j) &
3096 + vec_in(i,3,k) * mat_y_tr(3,j) &
3097 + vec_in(i,4,k) * mat_y_tr(4,j) &
3098 + vec_in(i,5,k) * mat_y_tr(5,j) &
3099 + vec_in(i,6,k) * mat_y_tr(6,j) &
3100 + vec_in(i,7,k) * mat_y_tr(7,j) &
3101 + vec_in(i,8,k) * mat_y_tr(8,j) &
3102 + vec_in(i,9,k) * mat_y_tr(9,j) &
3103 + vec_in(i,10,k) * mat_y_tr(10,j)
3104 end do
3105 end do
3106 end do
3107
3108 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p9 ( real(rp), dimension(10,10), intent(in) mat_z_tr,
real(rp), dimension(10,10,10), intent(in) vec_in,
real(rp), dimension(10,10,10), intent(out) vec_out )

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.

Definition at line 3115 of file scale_element_operation_tensorprod3D_kernel.F90.

3116 implicit none
3117 real(RP), intent(in) :: Mat_z_tr(10,10)
3118 real(RP), intent(in) :: vec_in(10,10,10)
3119 real(RP), intent(out) :: vec_out(10,10,10)
3120
3121 integer :: i, j, k
3122 !----------------------------------------------------------
3123
3124 do k=1, 10
3125 do j=1, 10
3126 do i=1, 10
3127 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
3128 + vec_in(i,j,2) * mat_z_tr(2,k) &
3129 + vec_in(i,j,3) * mat_z_tr(3,k) &
3130 + vec_in(i,j,4) * mat_z_tr(4,k) &
3131 + vec_in(i,j,5) * mat_z_tr(5,k) &
3132 + vec_in(i,j,6) * mat_z_tr(6,k) &
3133 + vec_in(i,j,7) * mat_z_tr(7,k) &
3134 + vec_in(i,j,8) * mat_z_tr(8,k) &
3135 + vec_in(i,j,9) * mat_z_tr(9,k) &
3136 + vec_in(i,j,10) * mat_z_tr(10,k)
3137 end do
3138 end do
3139 end do
3140
3141 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p9 ( real(rp), dimension(10,10,10,6), intent(in) lift,
real(rp), dimension(10,10,6), intent(in) vec_in,
real(rp), dimension(10,10,10), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=9.

Definition at line 3147 of file scale_element_operation_tensorprod3D_kernel.F90.

3148 implicit none
3149 real(RP), intent(in) :: Lift(10,10,10,6)
3150 real(RP), intent(in) :: vec_in(10,10,6)
3151 real(RP), intent(out) :: vec_out(10,10,10)
3152
3153 integer :: i, j, k
3154 !----------------------------------------------------------
3155
3156 do k=1, 10
3157 do j=1, 10
3158 do i=1, 10
3159 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
3160 + lift(i,j,k,2) * vec_in(j,k,2) &
3161 + lift(i,j,k,3) * vec_in(i,k,3) &
3162 + lift(i,j,k,4) * vec_in(j,k,4) &
3163 + lift(i,j,k,5) * vec_in(i,j,5) &
3164 + lift(i,j,k,6) * vec_in(i,j,6)
3165 end do
3166 end do
3167 end do
3168
3169 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p9 ( real(rp), dimension(10,10), intent(in) mat,
real(rp), dimension(10,10), intent(in) mat_tr,
real(rp), dimension(10,10,10), intent(in) vec_in,
real(rp), dimension(10,10**2), intent(in) vec_in_,
real(rp), dimension(10,10**2), intent(out) vec_out_x,
real(rp), dimension(10,10,10), intent(out) vec_out_y,
real(rp), dimension(10,10,10), intent(out) vec_out_z )

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.

Definition at line 3177 of file scale_element_operation_tensorprod3D_kernel.F90.

3179 implicit none
3180 real(RP), intent(in) :: Mat(10,10)
3181 real(RP), intent(in) :: Mat_tr(10,10)
3182 real(RP), intent(in) :: vec_in_(10,10**2)
3183 real(RP), intent(in) :: vec_in(10,10,10)
3184 real(RP), intent(out) :: vec_out_x(10,10**2)
3185 real(RP), intent(out) :: vec_out_y(10,10,10)
3186 real(RP), intent(out) :: vec_out_z(10,10,10)
3187
3188 integer :: i, j, k, jk
3189 !----------------------------------------------------------
3190
3191 ! X-dir
3192
3193 do jk=1, 10**2
3194 do i=1, 10
3195 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
3196 + mat(i,2) * vec_in_(2,jk) &
3197 + mat(i,3) * vec_in_(3,jk) &
3198 + mat(i,4) * vec_in_(4,jk) &
3199 + mat(i,5) * vec_in_(5,jk) &
3200 + mat(i,6) * vec_in_(6,jk) &
3201 + mat(i,7) * vec_in_(7,jk) &
3202 + mat(i,8) * vec_in_(8,jk) &
3203 + mat(i,9) * vec_in_(9,jk) &
3204 + mat(i,10) * vec_in_(10,jk)
3205 end do
3206 end do
3207
3208 ! Y-dir
3209 do k=1, 10
3210 do j=1, 10
3211 do i=1, 10
3212 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3213 + vec_in(i,2,k) * mat_tr(2,j) &
3214 + vec_in(i,3,k) * mat_tr(3,j) &
3215 + vec_in(i,4,k) * mat_tr(4,j) &
3216 + vec_in(i,5,k) * mat_tr(5,j) &
3217 + vec_in(i,6,k) * mat_tr(6,j) &
3218 + vec_in(i,7,k) * mat_tr(7,j) &
3219 + vec_in(i,8,k) * mat_tr(8,j) &
3220 + vec_in(i,9,k) * mat_tr(9,j) &
3221 + vec_in(i,10,k) * mat_tr(10,j)
3222 end do
3223 end do
3224 end do
3225
3226 ! Z-dir
3227 do k=1, 10
3228 do j=1, 10
3229 do i=1, 10
3230 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3231 + vec_in(i,j,2) * mat_tr(2,k) &
3232 + vec_in(i,j,3) * mat_tr(3,k) &
3233 + vec_in(i,j,4) * mat_tr(4,k) &
3234 + vec_in(i,j,5) * mat_tr(5,k) &
3235 + vec_in(i,j,6) * mat_tr(6,k) &
3236 + vec_in(i,j,7) * mat_tr(7,k) &
3237 + vec_in(i,j,8) * mat_tr(8,k) &
3238 + vec_in(i,j,9) * mat_tr(9,k) &
3239 + vec_in(i,j,10) * mat_tr(10,k)
3240 end do
3241 end do
3242 end do
3243
3244 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p9 ( real(rp), dimension(10,10), intent(in) mat,
real(rp), dimension(10,10), intent(in) mat_tr,
real(rp), dimension(10,10**2), intent(in) vec_in_x,
real(rp), dimension(10,10,10), intent(in) vec_in_y,
real(rp), dimension(10,10,10), intent(in) vec_in_z,
real(rp), dimension(10,10**2), intent(out) vec_out_x,
real(rp), dimension(10,10**2), intent(out) vec_out_y,
real(rp), dimension(10,10**2), intent(out) vec_out_z )

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.

Definition at line 3252 of file scale_element_operation_tensorprod3D_kernel.F90.

3255 implicit none
3256 real(RP), intent(in) :: Mat(10,10)
3257 real(RP), intent(in) :: Mat_tr(10,10)
3258 real(RP), intent(in) :: vec_in_x(10,10**2)
3259 real(RP), intent(in) :: vec_in_y(10,10,10)
3260 real(RP), intent(in) :: vec_in_z(10,10,10)
3261 real(RP), intent(out) :: vec_out_x(10,10**2)
3262 real(RP), intent(out) :: vec_out_y(10,10**2)
3263 real(RP), intent(out) :: vec_out_z(10,10**2)
3264
3265 integer :: i, j, k, jk
3266 real(RP) :: tmp1, tmp2, tmp3
3267 !----------------------------------------------------------
3268
3269 ! X-dir
3270
3271 do jk=1, 10**2
3272 do i=1, 10
3273 tmp1 = mat(i,1) * vec_in_x(1,jk) &
3274 + mat(i,2) * vec_in_x(2,jk) &
3275 + mat(i,3) * vec_in_x(3,jk)
3276 tmp2 = mat(i,4) * vec_in_x(4,jk) &
3277 + mat(i,5) * vec_in_x(5,jk) &
3278 + mat(i,6) * vec_in_x(6,jk)
3279 tmp3 = mat(i,7) * vec_in_x(7,jk) &
3280 + mat(i,8) * vec_in_x(8,jk) &
3281 + mat(i,9) * vec_in_x(9,jk) &
3282 + mat(i,10) * vec_in_x(10,jk)
3283 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
3284 end do
3285 end do
3286
3287 ! Y-dir
3288 do k=1, 10
3289 do j=1, 10
3290 jk = j + (k-1)*10
3291 do i=1, 10
3292 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
3293 + vec_in_y(i,2,k) * mat_tr(2,j) &
3294 + vec_in_y(i,3,k) * mat_tr(3,j)
3295 tmp2 = vec_in_y(i,4,k) * mat_tr(4,j) &
3296 + vec_in_y(i,5,k) * mat_tr(5,j) &
3297 + vec_in_y(i,6,k) * mat_tr(6,j)
3298 tmp3 = vec_in_y(i,7,k) * mat_tr(7,j) &
3299 + vec_in_y(i,8,k) * mat_tr(8,j) &
3300 + vec_in_y(i,9,k) * mat_tr(9,j) &
3301 + vec_in_y(i,10,k) * mat_tr(10,j)
3302 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
3303 end do
3304 end do
3305 end do
3306
3307 ! Z-dir
3308 do k=1, 10
3309 do j=1, 10
3310 jk = j + (k-1)*10
3311 do i=1, 10
3312 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
3313 + vec_in_z(i,j,2) * mat_tr(2,k) &
3314 + vec_in_z(i,j,3) * mat_tr(3,k)
3315 tmp2 = vec_in_z(i,j,4) * mat_tr(4,k) &
3316 + vec_in_z(i,j,5) * mat_tr(5,k) &
3317 + vec_in_z(i,j,6) * mat_tr(6,k)
3318 tmp3 = vec_in_z(i,j,7) * mat_tr(7,k) &
3319 + vec_in_z(i,j,8) * mat_tr(8,k) &
3320 + vec_in_z(i,j,9) * mat_tr(9,k) &
3321 + vec_in_z(i,j,10) * mat_tr(10,k)
3322 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
3323 end do
3324 end do
3325 end do
3326 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p9()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p9 ( real(rp), dimension(10,10), intent(in) mat_h1d,
real(rp), dimension(10,10), intent(in) mat_h1d_tr,
real(rp), dimension(10,10), intent(in) mat_v1d_tr,
real(rp), dimension(10,10,10), intent(in) vec_in,
real(rp), dimension(10,10,10), intent(out) vec_work,
real(rp), dimension(10,10,10), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=9.

Definition at line 3412 of file scale_element_operation_tensorprod3D_kernel.F90.

3414 implicit none
3415 real(RP), intent(in) :: Mat_h1D(10,10)
3416 real(RP), intent(in) :: Mat_h1D_tr(10,10)
3417 real(RP), intent(in) :: Mat_v1D_tr(10,10)
3418 real(RP), intent(in) :: vec_in(10,10,10)
3419 real(RP), intent(out) :: vec_work(10,10,10)
3420 real(RP), intent(out) :: vec_out(10,10,10)
3421
3422 integer :: i, j, k
3423 real(RP) :: tmp1, tmp2, tmp3
3424 !----------------------------------------------------------
3425
3426 ! X-dir
3427
3428 do k=1, 10
3429 do j=1, 10
3430 do i=1, 10
3431 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
3432 + mat_h1d(i,2) * vec_in(2,j,k) &
3433 + mat_h1d(i,3) * vec_in(3,j,k)
3434 tmp2 = mat_h1d(i,4) * vec_in(4,j,k) &
3435 + mat_h1d(i,5) * vec_in(5,j,k) &
3436 + mat_h1d(i,6) * vec_in(6,j,k)
3437 tmp3 = mat_h1d(i,7) * vec_in(7,j,k) &
3438 + mat_h1d(i,8) * vec_in(8,j,k) &
3439 + mat_h1d(i,9) * vec_in(9,j,k) &
3440 + mat_h1d(i,10) * vec_in(10,j,k)
3441 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3442 end do
3443 end do
3444 end do
3445
3446 ! Y-dir
3447 do k=1, 10
3448 do j=1, 10
3449 do i=1, 10
3450 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
3451 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
3452 + vec_out(i,3,k) * mat_h1d_tr(3,j)
3453 tmp2 = vec_out(i,4,k) * mat_h1d_tr(4,j) &
3454 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
3455 + vec_out(i,6,k) * mat_h1d_tr(6,j)
3456 tmp3 = vec_out(i,7,k) * mat_h1d_tr(7,j) &
3457 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
3458 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
3459 + vec_out(i,10,k) * mat_h1d_tr(10,j)
3460 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
3461 end do
3462 end do
3463 end do
3464
3465 ! Z-dir
3466 do k=1, 10
3467 do j=1, 10
3468 do i=1, 10
3469 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
3470 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
3471 + vec_work(i,j,3) * mat_v1d_tr(3,k)
3472 tmp2 = vec_work(i,j,4) * mat_v1d_tr(4,k) &
3473 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
3474 + vec_work(i,j,6) * mat_v1d_tr(6,k)
3475 tmp3 = vec_work(i,j,7) * mat_v1d_tr(7,k) &
3476 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
3477 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
3478 + vec_work(i,j,10) * mat_v1d_tr(10,k)
3479 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3480 end do
3481 end do
3482 end do
3483
3484 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p10 ( real(rp), dimension(11,11), intent(in) mat_x,
real(rp), dimension(11,11**2), intent(in) vec_in,
real(rp), dimension(11,11**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=10.

Definition at line 3492 of file scale_element_operation_tensorprod3D_kernel.F90.

3493 implicit none
3494 real(RP), intent(in) :: Mat_x(11,11)
3495 real(RP), intent(in) :: vec_in(11,11**2)
3496 real(RP), intent(out) :: vec_out(11,11**2)
3497
3498 integer :: i, jk
3499 !----------------------------------------------------------
3500
3501 do jk=1, 11**2
3502 do i=1, 11
3503 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
3504 + mat_x(i,2) * vec_in(2,jk) &
3505 + mat_x(i,3) * vec_in(3,jk) &
3506 + mat_x(i,4) * vec_in(4,jk) &
3507 + mat_x(i,5) * vec_in(5,jk) &
3508 + mat_x(i,6) * vec_in(6,jk) &
3509 + mat_x(i,7) * vec_in(7,jk) &
3510 + mat_x(i,8) * vec_in(8,jk) &
3511 + mat_x(i,9) * vec_in(9,jk) &
3512 + mat_x(i,10) * vec_in(10,jk) &
3513 + mat_x(i,11) * vec_in(11,jk)
3514 end do
3515 end do
3516
3517 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p10 ( real(rp), dimension(11,11), intent(in) mat_y_tr,
real(rp), dimension(11,11,11), intent(in) vec_in,
real(rp), dimension(11,11,11), intent(out) vec_out )

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.

Definition at line 3524 of file scale_element_operation_tensorprod3D_kernel.F90.

3525 implicit none
3526 real(RP), intent(in) :: Mat_y_tr(11,11)
3527 real(RP), intent(in) :: vec_in(11,11,11)
3528 real(RP), intent(out) :: vec_out(11,11,11)
3529
3530 integer :: i, j, k
3531 !----------------------------------------------------------
3532
3533 do k=1, 11
3534 do j=1, 11
3535 do i=1, 11
3536 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
3537 + vec_in(i,2,k) * mat_y_tr(2,j) &
3538 + vec_in(i,3,k) * mat_y_tr(3,j) &
3539 + vec_in(i,4,k) * mat_y_tr(4,j) &
3540 + vec_in(i,5,k) * mat_y_tr(5,j) &
3541 + vec_in(i,6,k) * mat_y_tr(6,j) &
3542 + vec_in(i,7,k) * mat_y_tr(7,j) &
3543 + vec_in(i,8,k) * mat_y_tr(8,j) &
3544 + vec_in(i,9,k) * mat_y_tr(9,j) &
3545 + vec_in(i,10,k) * mat_y_tr(10,j) &
3546 + vec_in(i,11,k) * mat_y_tr(11,j)
3547 end do
3548 end do
3549 end do
3550
3551 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p10 ( real(rp), dimension(11,11), intent(in) mat_z_tr,
real(rp), dimension(11,11,11), intent(in) vec_in,
real(rp), dimension(11,11,11), intent(out) vec_out )

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.

Definition at line 3558 of file scale_element_operation_tensorprod3D_kernel.F90.

3559 implicit none
3560 real(RP), intent(in) :: Mat_z_tr(11,11)
3561 real(RP), intent(in) :: vec_in(11,11,11)
3562 real(RP), intent(out) :: vec_out(11,11,11)
3563
3564 integer :: i, j, k
3565 !----------------------------------------------------------
3566
3567 do k=1, 11
3568 do j=1, 11
3569 do i=1, 11
3570 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
3571 + vec_in(i,j,2) * mat_z_tr(2,k) &
3572 + vec_in(i,j,3) * mat_z_tr(3,k) &
3573 + vec_in(i,j,4) * mat_z_tr(4,k) &
3574 + vec_in(i,j,5) * mat_z_tr(5,k) &
3575 + vec_in(i,j,6) * mat_z_tr(6,k) &
3576 + vec_in(i,j,7) * mat_z_tr(7,k) &
3577 + vec_in(i,j,8) * mat_z_tr(8,k) &
3578 + vec_in(i,j,9) * mat_z_tr(9,k) &
3579 + vec_in(i,j,10) * mat_z_tr(10,k) &
3580 + vec_in(i,j,11) * mat_z_tr(11,k)
3581 end do
3582 end do
3583 end do
3584
3585 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p10 ( real(rp), dimension(11,11,11,6), intent(in) lift,
real(rp), dimension(11,11,6), intent(in) vec_in,
real(rp), dimension(11,11,11), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=10.

Definition at line 3591 of file scale_element_operation_tensorprod3D_kernel.F90.

3592 implicit none
3593 real(RP), intent(in) :: Lift(11,11,11,6)
3594 real(RP), intent(in) :: vec_in(11,11,6)
3595 real(RP), intent(out) :: vec_out(11,11,11)
3596
3597 integer :: i, j, k
3598 !----------------------------------------------------------
3599
3600 do k=1, 11
3601 do j=1, 11
3602 do i=1, 11
3603 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
3604 + lift(i,j,k,2) * vec_in(j,k,2) &
3605 + lift(i,j,k,3) * vec_in(i,k,3) &
3606 + lift(i,j,k,4) * vec_in(j,k,4) &
3607 + lift(i,j,k,5) * vec_in(i,j,5) &
3608 + lift(i,j,k,6) * vec_in(i,j,6)
3609 end do
3610 end do
3611 end do
3612
3613 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p10 ( real(rp), dimension(11,11), intent(in) mat,
real(rp), dimension(11,11), intent(in) mat_tr,
real(rp), dimension(11,11,11), intent(in) vec_in,
real(rp), dimension(11,11**2), intent(in) vec_in_,
real(rp), dimension(11,11**2), intent(out) vec_out_x,
real(rp), dimension(11,11,11), intent(out) vec_out_y,
real(rp), dimension(11,11,11), intent(out) vec_out_z )

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.

Definition at line 3621 of file scale_element_operation_tensorprod3D_kernel.F90.

3623 implicit none
3624 real(RP), intent(in) :: Mat(11,11)
3625 real(RP), intent(in) :: Mat_tr(11,11)
3626 real(RP), intent(in) :: vec_in_(11,11**2)
3627 real(RP), intent(in) :: vec_in(11,11,11)
3628 real(RP), intent(out) :: vec_out_x(11,11**2)
3629 real(RP), intent(out) :: vec_out_y(11,11,11)
3630 real(RP), intent(out) :: vec_out_z(11,11,11)
3631
3632 integer :: i, j, k, jk
3633 !----------------------------------------------------------
3634
3635 ! X-dir
3636
3637 do jk=1, 11**2
3638 do i=1, 11
3639 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
3640 + mat(i,2) * vec_in_(2,jk) &
3641 + mat(i,3) * vec_in_(3,jk) &
3642 + mat(i,4) * vec_in_(4,jk) &
3643 + mat(i,5) * vec_in_(5,jk) &
3644 + mat(i,6) * vec_in_(6,jk) &
3645 + mat(i,7) * vec_in_(7,jk) &
3646 + mat(i,8) * vec_in_(8,jk) &
3647 + mat(i,9) * vec_in_(9,jk) &
3648 + mat(i,10) * vec_in_(10,jk) &
3649 + mat(i,11) * vec_in_(11,jk)
3650 end do
3651 end do
3652
3653 ! Y-dir
3654 do k=1, 11
3655 do j=1, 11
3656 do i=1, 11
3657 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3658 + vec_in(i,2,k) * mat_tr(2,j) &
3659 + vec_in(i,3,k) * mat_tr(3,j) &
3660 + vec_in(i,4,k) * mat_tr(4,j) &
3661 + vec_in(i,5,k) * mat_tr(5,j) &
3662 + vec_in(i,6,k) * mat_tr(6,j) &
3663 + vec_in(i,7,k) * mat_tr(7,j) &
3664 + vec_in(i,8,k) * mat_tr(8,j) &
3665 + vec_in(i,9,k) * mat_tr(9,j) &
3666 + vec_in(i,10,k) * mat_tr(10,j) &
3667 + vec_in(i,11,k) * mat_tr(11,j)
3668 end do
3669 end do
3670 end do
3671
3672 ! Z-dir
3673 do k=1, 11
3674 do j=1, 11
3675 do i=1, 11
3676 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3677 + vec_in(i,j,2) * mat_tr(2,k) &
3678 + vec_in(i,j,3) * mat_tr(3,k) &
3679 + vec_in(i,j,4) * mat_tr(4,k) &
3680 + vec_in(i,j,5) * mat_tr(5,k) &
3681 + vec_in(i,j,6) * mat_tr(6,k) &
3682 + vec_in(i,j,7) * mat_tr(7,k) &
3683 + vec_in(i,j,8) * mat_tr(8,k) &
3684 + vec_in(i,j,9) * mat_tr(9,k) &
3685 + vec_in(i,j,10) * mat_tr(10,k) &
3686 + vec_in(i,j,11) * mat_tr(11,k)
3687 end do
3688 end do
3689 end do
3690
3691 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p10 ( real(rp), dimension(11,11), intent(in) mat,
real(rp), dimension(11,11), intent(in) mat_tr,
real(rp), dimension(11,11**2), intent(in) vec_in_x,
real(rp), dimension(11,11,11), intent(in) vec_in_y,
real(rp), dimension(11,11,11), intent(in) vec_in_z,
real(rp), dimension(11,11**2), intent(out) vec_out_x,
real(rp), dimension(11,11**2), intent(out) vec_out_y,
real(rp), dimension(11,11**2), intent(out) vec_out_z )

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.

Definition at line 3699 of file scale_element_operation_tensorprod3D_kernel.F90.

3702 implicit none
3703 real(RP), intent(in) :: Mat(11,11)
3704 real(RP), intent(in) :: Mat_tr(11,11)
3705 real(RP), intent(in) :: vec_in_x(11,11**2)
3706 real(RP), intent(in) :: vec_in_y(11,11,11)
3707 real(RP), intent(in) :: vec_in_z(11,11,11)
3708 real(RP), intent(out) :: vec_out_x(11,11**2)
3709 real(RP), intent(out) :: vec_out_y(11,11**2)
3710 real(RP), intent(out) :: vec_out_z(11,11**2)
3711
3712 integer :: i, j, k, jk
3713 real(RP) :: tmp1, tmp2, tmp3
3714 !----------------------------------------------------------
3715
3716 ! X-dir
3717
3718 do jk=1, 11**2
3719 do i=1, 11
3720 tmp1 = mat(i,1) * vec_in_x(1,jk) &
3721 + mat(i,2) * vec_in_x(2,jk) &
3722 + mat(i,3) * vec_in_x(3,jk) &
3723 + mat(i,4) * vec_in_x(4,jk)
3724 tmp2 = mat(i,5) * vec_in_x(5,jk) &
3725 + mat(i,6) * vec_in_x(6,jk) &
3726 + mat(i,7) * vec_in_x(7,jk) &
3727 + mat(i,8) * vec_in_x(8,jk)
3728 tmp3 = mat(i,9) * vec_in_x(9,jk) &
3729 + mat(i,10) * vec_in_x(10,jk) &
3730 + mat(i,11) * vec_in_x(11,jk)
3731 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
3732 end do
3733 end do
3734
3735 ! Y-dir
3736 do k=1, 11
3737 do j=1, 11
3738 jk = j + (k-1)*11
3739 do i=1, 11
3740 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
3741 + vec_in_y(i,2,k) * mat_tr(2,j) &
3742 + vec_in_y(i,3,k) * mat_tr(3,j) &
3743 + vec_in_y(i,4,k) * mat_tr(4,j)
3744 tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
3745 + vec_in_y(i,6,k) * mat_tr(6,j) &
3746 + vec_in_y(i,7,k) * mat_tr(7,j) &
3747 + vec_in_y(i,8,k) * mat_tr(8,j)
3748 tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
3749 + vec_in_y(i,10,k) * mat_tr(10,j) &
3750 + vec_in_y(i,11,k) * mat_tr(11,j)
3751 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
3752 end do
3753 end do
3754 end do
3755
3756 ! Z-dir
3757 do k=1, 11
3758 do j=1, 11
3759 jk = j + (k-1)*11
3760 do i=1, 11
3761 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
3762 + vec_in_z(i,j,2) * mat_tr(2,k) &
3763 + vec_in_z(i,j,3) * mat_tr(3,k) &
3764 + vec_in_z(i,j,4) * mat_tr(4,k)
3765 tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
3766 + vec_in_z(i,j,6) * mat_tr(6,k) &
3767 + vec_in_z(i,j,7) * mat_tr(7,k) &
3768 + vec_in_z(i,j,8) * mat_tr(8,k)
3769 tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
3770 + vec_in_z(i,j,10) * mat_tr(10,k) &
3771 + vec_in_z(i,j,11) * mat_tr(11,k)
3772 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
3773 end do
3774 end do
3775 end do
3776 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p10()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p10 ( real(rp), dimension(11,11), intent(in) mat_h1d,
real(rp), dimension(11,11), intent(in) mat_h1d_tr,
real(rp), dimension(11,11), intent(in) mat_v1d_tr,
real(rp), dimension(11,11,11), intent(in) vec_in,
real(rp), dimension(11,11,11), intent(out) vec_work,
real(rp), dimension(11,11,11), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=10.

Definition at line 3865 of file scale_element_operation_tensorprod3D_kernel.F90.

3867 implicit none
3868 real(RP), intent(in) :: Mat_h1D(11,11)
3869 real(RP), intent(in) :: Mat_h1D_tr(11,11)
3870 real(RP), intent(in) :: Mat_v1D_tr(11,11)
3871 real(RP), intent(in) :: vec_in(11,11,11)
3872 real(RP), intent(out) :: vec_work(11,11,11)
3873 real(RP), intent(out) :: vec_out(11,11,11)
3874
3875 integer :: i, j, k
3876 real(RP) :: tmp1, tmp2, tmp3
3877 !----------------------------------------------------------
3878
3879 ! X-dir
3880
3881 do k=1, 11
3882 do j=1, 11
3883 do i=1, 11
3884 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
3885 + mat_h1d(i,2) * vec_in(2,j,k) &
3886 + mat_h1d(i,3) * vec_in(3,j,k) &
3887 + mat_h1d(i,4) * vec_in(4,j,k)
3888 tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
3889 + mat_h1d(i,6) * vec_in(6,j,k) &
3890 + mat_h1d(i,7) * vec_in(7,j,k) &
3891 + mat_h1d(i,8) * vec_in(8,j,k)
3892 tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
3893 + mat_h1d(i,10) * vec_in(10,j,k) &
3894 + mat_h1d(i,11) * vec_in(11,j,k)
3895 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3896 end do
3897 end do
3898 end do
3899
3900 ! Y-dir
3901 do k=1, 11
3902 do j=1, 11
3903 do i=1, 11
3904 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
3905 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
3906 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
3907 + vec_out(i,4,k) * mat_h1d_tr(4,j)
3908 tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
3909 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
3910 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
3911 + vec_out(i,8,k) * mat_h1d_tr(8,j)
3912 tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
3913 + vec_out(i,10,k) * mat_h1d_tr(10,j) &
3914 + vec_out(i,11,k) * mat_h1d_tr(11,j)
3915 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
3916 end do
3917 end do
3918 end do
3919
3920 ! Z-dir
3921 do k=1, 11
3922 do j=1, 11
3923 do i=1, 11
3924 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
3925 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
3926 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
3927 + vec_work(i,j,4) * mat_v1d_tr(4,k)
3928 tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
3929 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
3930 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
3931 + vec_work(i,j,8) * mat_v1d_tr(8,k)
3932 tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
3933 + vec_work(i,j,10) * mat_v1d_tr(10,k) &
3934 + vec_work(i,j,11) * mat_v1d_tr(11,k)
3935 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3936 end do
3937 end do
3938 end do
3939
3940 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p11 ( real(rp), dimension(12,12), intent(in) mat_x,
real(rp), dimension(12,12**2), intent(in) vec_in,
real(rp), dimension(12,12**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=11.

Definition at line 3948 of file scale_element_operation_tensorprod3D_kernel.F90.

3949 implicit none
3950 real(RP), intent(in) :: Mat_x(12,12)
3951 real(RP), intent(in) :: vec_in(12,12**2)
3952 real(RP), intent(out) :: vec_out(12,12**2)
3953
3954 integer :: i, jk
3955 !----------------------------------------------------------
3956
3957 do jk=1, 12**2
3958 do i=1, 12
3959 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
3960 + mat_x(i,2) * vec_in(2,jk) &
3961 + mat_x(i,3) * vec_in(3,jk) &
3962 + mat_x(i,4) * vec_in(4,jk) &
3963 + mat_x(i,5) * vec_in(5,jk) &
3964 + mat_x(i,6) * vec_in(6,jk) &
3965 + mat_x(i,7) * vec_in(7,jk) &
3966 + mat_x(i,8) * vec_in(8,jk) &
3967 + mat_x(i,9) * vec_in(9,jk) &
3968 + mat_x(i,10) * vec_in(10,jk) &
3969 + mat_x(i,11) * vec_in(11,jk) &
3970 + mat_x(i,12) * vec_in(12,jk)
3971 end do
3972 end do
3973
3974 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p11 ( real(rp), dimension(12,12), intent(in) mat_y_tr,
real(rp), dimension(12,12,12), intent(in) vec_in,
real(rp), dimension(12,12,12), intent(out) vec_out )

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.

Definition at line 3981 of file scale_element_operation_tensorprod3D_kernel.F90.

3982 implicit none
3983 real(RP), intent(in) :: Mat_y_tr(12,12)
3984 real(RP), intent(in) :: vec_in(12,12,12)
3985 real(RP), intent(out) :: vec_out(12,12,12)
3986
3987 integer :: i, j, k
3988 !----------------------------------------------------------
3989
3990 do k=1, 12
3991 do j=1, 12
3992 do i=1, 12
3993 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
3994 + vec_in(i,2,k) * mat_y_tr(2,j) &
3995 + vec_in(i,3,k) * mat_y_tr(3,j) &
3996 + vec_in(i,4,k) * mat_y_tr(4,j) &
3997 + vec_in(i,5,k) * mat_y_tr(5,j) &
3998 + vec_in(i,6,k) * mat_y_tr(6,j) &
3999 + vec_in(i,7,k) * mat_y_tr(7,j) &
4000 + vec_in(i,8,k) * mat_y_tr(8,j) &
4001 + vec_in(i,9,k) * mat_y_tr(9,j) &
4002 + vec_in(i,10,k) * mat_y_tr(10,j) &
4003 + vec_in(i,11,k) * mat_y_tr(11,j) &
4004 + vec_in(i,12,k) * mat_y_tr(12,j)
4005 end do
4006 end do
4007 end do
4008
4009 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p11 ( real(rp), dimension(12,12), intent(in) mat_z_tr,
real(rp), dimension(12,12,12), intent(in) vec_in,
real(rp), dimension(12,12,12), intent(out) vec_out )

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.

Definition at line 4016 of file scale_element_operation_tensorprod3D_kernel.F90.

4017 implicit none
4018 real(RP), intent(in) :: Mat_z_tr(12,12)
4019 real(RP), intent(in) :: vec_in(12,12,12)
4020 real(RP), intent(out) :: vec_out(12,12,12)
4021
4022 integer :: i, j, k
4023 !----------------------------------------------------------
4024
4025 do k=1, 12
4026 do j=1, 12
4027 do i=1, 12
4028 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
4029 + vec_in(i,j,2) * mat_z_tr(2,k) &
4030 + vec_in(i,j,3) * mat_z_tr(3,k) &
4031 + vec_in(i,j,4) * mat_z_tr(4,k) &
4032 + vec_in(i,j,5) * mat_z_tr(5,k) &
4033 + vec_in(i,j,6) * mat_z_tr(6,k) &
4034 + vec_in(i,j,7) * mat_z_tr(7,k) &
4035 + vec_in(i,j,8) * mat_z_tr(8,k) &
4036 + vec_in(i,j,9) * mat_z_tr(9,k) &
4037 + vec_in(i,j,10) * mat_z_tr(10,k) &
4038 + vec_in(i,j,11) * mat_z_tr(11,k) &
4039 + vec_in(i,j,12) * mat_z_tr(12,k)
4040 end do
4041 end do
4042 end do
4043
4044 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p11 ( real(rp), dimension(12,12,12,6), intent(in) lift,
real(rp), dimension(12,12,6), intent(in) vec_in,
real(rp), dimension(12,12,12), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=11.

Definition at line 4050 of file scale_element_operation_tensorprod3D_kernel.F90.

4051 implicit none
4052 real(RP), intent(in) :: Lift(12,12,12,6)
4053 real(RP), intent(in) :: vec_in(12,12,6)
4054 real(RP), intent(out) :: vec_out(12,12,12)
4055
4056 integer :: i, j, k
4057 !----------------------------------------------------------
4058
4059 do k=1, 12
4060 do j=1, 12
4061 do i=1, 12
4062 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
4063 + lift(i,j,k,2) * vec_in(j,k,2) &
4064 + lift(i,j,k,3) * vec_in(i,k,3) &
4065 + lift(i,j,k,4) * vec_in(j,k,4) &
4066 + lift(i,j,k,5) * vec_in(i,j,5) &
4067 + lift(i,j,k,6) * vec_in(i,j,6)
4068 end do
4069 end do
4070 end do
4071
4072 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p11 ( real(rp), dimension(12,12), intent(in) mat,
real(rp), dimension(12,12), intent(in) mat_tr,
real(rp), dimension(12,12,12), intent(in) vec_in,
real(rp), dimension(12,12**2), intent(in) vec_in_,
real(rp), dimension(12,12**2), intent(out) vec_out_x,
real(rp), dimension(12,12,12), intent(out) vec_out_y,
real(rp), dimension(12,12,12), intent(out) vec_out_z )

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.

Definition at line 4080 of file scale_element_operation_tensorprod3D_kernel.F90.

4082 implicit none
4083 real(RP), intent(in) :: Mat(12,12)
4084 real(RP), intent(in) :: Mat_tr(12,12)
4085 real(RP), intent(in) :: vec_in_(12,12**2)
4086 real(RP), intent(in) :: vec_in(12,12,12)
4087 real(RP), intent(out) :: vec_out_x(12,12**2)
4088 real(RP), intent(out) :: vec_out_y(12,12,12)
4089 real(RP), intent(out) :: vec_out_z(12,12,12)
4090
4091 integer :: i, j, k, jk
4092 !----------------------------------------------------------
4093
4094 ! X-dir
4095
4096 do jk=1, 12**2
4097 do i=1, 12
4098 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
4099 + mat(i,2) * vec_in_(2,jk) &
4100 + mat(i,3) * vec_in_(3,jk) &
4101 + mat(i,4) * vec_in_(4,jk) &
4102 + mat(i,5) * vec_in_(5,jk) &
4103 + mat(i,6) * vec_in_(6,jk) &
4104 + mat(i,7) * vec_in_(7,jk) &
4105 + mat(i,8) * vec_in_(8,jk) &
4106 + mat(i,9) * vec_in_(9,jk) &
4107 + mat(i,10) * vec_in_(10,jk) &
4108 + mat(i,11) * vec_in_(11,jk) &
4109 + mat(i,12) * vec_in_(12,jk)
4110 end do
4111 end do
4112
4113 ! Y-dir
4114 do k=1, 12
4115 do j=1, 12
4116 do i=1, 12
4117 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4118 + vec_in(i,2,k) * mat_tr(2,j) &
4119 + vec_in(i,3,k) * mat_tr(3,j) &
4120 + vec_in(i,4,k) * mat_tr(4,j) &
4121 + vec_in(i,5,k) * mat_tr(5,j) &
4122 + vec_in(i,6,k) * mat_tr(6,j) &
4123 + vec_in(i,7,k) * mat_tr(7,j) &
4124 + vec_in(i,8,k) * mat_tr(8,j) &
4125 + vec_in(i,9,k) * mat_tr(9,j) &
4126 + vec_in(i,10,k) * mat_tr(10,j) &
4127 + vec_in(i,11,k) * mat_tr(11,j) &
4128 + vec_in(i,12,k) * mat_tr(12,j)
4129 end do
4130 end do
4131 end do
4132
4133 ! Z-dir
4134 do k=1, 12
4135 do j=1, 12
4136 do i=1, 12
4137 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4138 + vec_in(i,j,2) * mat_tr(2,k) &
4139 + vec_in(i,j,3) * mat_tr(3,k) &
4140 + vec_in(i,j,4) * mat_tr(4,k) &
4141 + vec_in(i,j,5) * mat_tr(5,k) &
4142 + vec_in(i,j,6) * mat_tr(6,k) &
4143 + vec_in(i,j,7) * mat_tr(7,k) &
4144 + vec_in(i,j,8) * mat_tr(8,k) &
4145 + vec_in(i,j,9) * mat_tr(9,k) &
4146 + vec_in(i,j,10) * mat_tr(10,k) &
4147 + vec_in(i,j,11) * mat_tr(11,k) &
4148 + vec_in(i,j,12) * mat_tr(12,k)
4149 end do
4150 end do
4151 end do
4152
4153 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p11 ( real(rp), dimension(12,12), intent(in) mat,
real(rp), dimension(12,12), intent(in) mat_tr,
real(rp), dimension(12,12**2), intent(in) vec_in_x,
real(rp), dimension(12,12,12), intent(in) vec_in_y,
real(rp), dimension(12,12,12), intent(in) vec_in_z,
real(rp), dimension(12,12**2), intent(out) vec_out_x,
real(rp), dimension(12,12**2), intent(out) vec_out_y,
real(rp), dimension(12,12**2), intent(out) vec_out_z )

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.

Definition at line 4161 of file scale_element_operation_tensorprod3D_kernel.F90.

4164 implicit none
4165 real(RP), intent(in) :: Mat(12,12)
4166 real(RP), intent(in) :: Mat_tr(12,12)
4167 real(RP), intent(in) :: vec_in_x(12,12**2)
4168 real(RP), intent(in) :: vec_in_y(12,12,12)
4169 real(RP), intent(in) :: vec_in_z(12,12,12)
4170 real(RP), intent(out) :: vec_out_x(12,12**2)
4171 real(RP), intent(out) :: vec_out_y(12,12**2)
4172 real(RP), intent(out) :: vec_out_z(12,12**2)
4173
4174 integer :: i, j, k, jk
4175 real(RP) :: tmp1, tmp2, tmp3
4176 !----------------------------------------------------------
4177
4178 ! X-dir
4179
4180 do jk=1, 12**2
4181 do i=1, 12
4182 tmp1 = mat(i,1) * vec_in_x(1,jk) &
4183 + mat(i,2) * vec_in_x(2,jk) &
4184 + mat(i,3) * vec_in_x(3,jk) &
4185 + mat(i,4) * vec_in_x(4,jk)
4186 tmp2 = mat(i,5) * vec_in_x(5,jk) &
4187 + mat(i,6) * vec_in_x(6,jk) &
4188 + mat(i,7) * vec_in_x(7,jk) &
4189 + mat(i,8) * vec_in_x(8,jk)
4190 tmp3 = mat(i,9) * vec_in_x(9,jk) &
4191 + mat(i,10) * vec_in_x(10,jk) &
4192 + mat(i,11) * vec_in_x(11,jk) &
4193 + mat(i,12) * vec_in_x(12,jk)
4194 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
4195 end do
4196 end do
4197
4198 ! Y-dir
4199 do k=1, 12
4200 do j=1, 12
4201 jk = j + (k-1)*12
4202 do i=1, 12
4203 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
4204 + vec_in_y(i,2,k) * mat_tr(2,j) &
4205 + vec_in_y(i,3,k) * mat_tr(3,j) &
4206 + vec_in_y(i,4,k) * mat_tr(4,j)
4207 tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
4208 + vec_in_y(i,6,k) * mat_tr(6,j) &
4209 + vec_in_y(i,7,k) * mat_tr(7,j) &
4210 + vec_in_y(i,8,k) * mat_tr(8,j)
4211 tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
4212 + vec_in_y(i,10,k) * mat_tr(10,j) &
4213 + vec_in_y(i,11,k) * mat_tr(11,j) &
4214 + vec_in_y(i,12,k) * mat_tr(12,j)
4215 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
4216 end do
4217 end do
4218 end do
4219
4220 ! Z-dir
4221 do k=1, 12
4222 do j=1, 12
4223 jk = j + (k-1)*12
4224 do i=1, 12
4225 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
4226 + vec_in_z(i,j,2) * mat_tr(2,k) &
4227 + vec_in_z(i,j,3) * mat_tr(3,k) &
4228 + vec_in_z(i,j,4) * mat_tr(4,k)
4229 tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
4230 + vec_in_z(i,j,6) * mat_tr(6,k) &
4231 + vec_in_z(i,j,7) * mat_tr(7,k) &
4232 + vec_in_z(i,j,8) * mat_tr(8,k)
4233 tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
4234 + vec_in_z(i,j,10) * mat_tr(10,k) &
4235 + vec_in_z(i,j,11) * mat_tr(11,k) &
4236 + vec_in_z(i,j,12) * mat_tr(12,k)
4237 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
4238 end do
4239 end do
4240 end do
4241 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p11()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p11 ( real(rp), dimension(12,12), intent(in) mat_h1d,
real(rp), dimension(12,12), intent(in) mat_h1d_tr,
real(rp), dimension(12,12), intent(in) mat_v1d_tr,
real(rp), dimension(12,12,12), intent(in) vec_in,
real(rp), dimension(12,12,12), intent(out) vec_work,
real(rp), dimension(12,12,12), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=11.

Definition at line 4333 of file scale_element_operation_tensorprod3D_kernel.F90.

4335 implicit none
4336 real(RP), intent(in) :: Mat_h1D(12,12)
4337 real(RP), intent(in) :: Mat_h1D_tr(12,12)
4338 real(RP), intent(in) :: Mat_v1D_tr(12,12)
4339 real(RP), intent(in) :: vec_in(12,12,12)
4340 real(RP), intent(out) :: vec_work(12,12,12)
4341 real(RP), intent(out) :: vec_out(12,12,12)
4342
4343 integer :: i, j, k
4344 real(RP) :: tmp1, tmp2, tmp3
4345 !----------------------------------------------------------
4346
4347 ! X-dir
4348
4349 do k=1, 12
4350 do j=1, 12
4351 do i=1, 12
4352 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
4353 + mat_h1d(i,2) * vec_in(2,j,k) &
4354 + mat_h1d(i,3) * vec_in(3,j,k) &
4355 + mat_h1d(i,4) * vec_in(4,j,k)
4356 tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
4357 + mat_h1d(i,6) * vec_in(6,j,k) &
4358 + mat_h1d(i,7) * vec_in(7,j,k) &
4359 + mat_h1d(i,8) * vec_in(8,j,k)
4360 tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
4361 + mat_h1d(i,10) * vec_in(10,j,k) &
4362 + mat_h1d(i,11) * vec_in(11,j,k) &
4363 + mat_h1d(i,12) * vec_in(12,j,k)
4364 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4365 end do
4366 end do
4367 end do
4368
4369 ! Y-dir
4370 do k=1, 12
4371 do j=1, 12
4372 do i=1, 12
4373 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
4374 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
4375 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
4376 + vec_out(i,4,k) * mat_h1d_tr(4,j)
4377 tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
4378 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
4379 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
4380 + vec_out(i,8,k) * mat_h1d_tr(8,j)
4381 tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
4382 + vec_out(i,10,k) * mat_h1d_tr(10,j) &
4383 + vec_out(i,11,k) * mat_h1d_tr(11,j) &
4384 + vec_out(i,12,k) * mat_h1d_tr(12,j)
4385 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
4386 end do
4387 end do
4388 end do
4389
4390 ! Z-dir
4391 do k=1, 12
4392 do j=1, 12
4393 do i=1, 12
4394 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
4395 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
4396 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
4397 + vec_work(i,j,4) * mat_v1d_tr(4,k)
4398 tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
4399 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
4400 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
4401 + vec_work(i,j,8) * mat_v1d_tr(8,k)
4402 tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
4403 + vec_work(i,j,10) * mat_v1d_tr(10,k) &
4404 + vec_work(i,j,11) * mat_v1d_tr(11,k) &
4405 + vec_work(i,j,12) * mat_v1d_tr(12,k)
4406 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4407 end do
4408 end do
4409 end do
4410
4411 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p12 ( real(rp), dimension(13,13), intent(in) mat_x,
real(rp), dimension(13,13**2), intent(in) vec_in,
real(rp), dimension(13,13**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=12.

Definition at line 4419 of file scale_element_operation_tensorprod3D_kernel.F90.

4420 implicit none
4421 real(RP), intent(in) :: Mat_x(13,13)
4422 real(RP), intent(in) :: vec_in(13,13**2)
4423 real(RP), intent(out) :: vec_out(13,13**2)
4424
4425 integer :: i, jk
4426 !----------------------------------------------------------
4427
4428 do jk=1, 13**2
4429 do i=1, 13
4430 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
4431 + mat_x(i,2) * vec_in(2,jk) &
4432 + mat_x(i,3) * vec_in(3,jk) &
4433 + mat_x(i,4) * vec_in(4,jk) &
4434 + mat_x(i,5) * vec_in(5,jk) &
4435 + mat_x(i,6) * vec_in(6,jk) &
4436 + mat_x(i,7) * vec_in(7,jk) &
4437 + mat_x(i,8) * vec_in(8,jk) &
4438 + mat_x(i,9) * vec_in(9,jk) &
4439 + mat_x(i,10) * vec_in(10,jk) &
4440 + mat_x(i,11) * vec_in(11,jk) &
4441 + mat_x(i,12) * vec_in(12,jk) &
4442 + mat_x(i,13) * vec_in(13,jk)
4443 end do
4444 end do
4445
4446 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p12 ( real(rp), dimension(13,13), intent(in) mat_y_tr,
real(rp), dimension(13,13,13), intent(in) vec_in,
real(rp), dimension(13,13,13), intent(out) vec_out )

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.

Definition at line 4453 of file scale_element_operation_tensorprod3D_kernel.F90.

4454 implicit none
4455 real(RP), intent(in) :: Mat_y_tr(13,13)
4456 real(RP), intent(in) :: vec_in(13,13,13)
4457 real(RP), intent(out) :: vec_out(13,13,13)
4458
4459 integer :: i, j, k
4460 !----------------------------------------------------------
4461
4462 do k=1, 13
4463 do j=1, 13
4464 do i=1, 13
4465 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
4466 + vec_in(i,2,k) * mat_y_tr(2,j) &
4467 + vec_in(i,3,k) * mat_y_tr(3,j) &
4468 + vec_in(i,4,k) * mat_y_tr(4,j) &
4469 + vec_in(i,5,k) * mat_y_tr(5,j) &
4470 + vec_in(i,6,k) * mat_y_tr(6,j) &
4471 + vec_in(i,7,k) * mat_y_tr(7,j) &
4472 + vec_in(i,8,k) * mat_y_tr(8,j) &
4473 + vec_in(i,9,k) * mat_y_tr(9,j) &
4474 + vec_in(i,10,k) * mat_y_tr(10,j) &
4475 + vec_in(i,11,k) * mat_y_tr(11,j) &
4476 + vec_in(i,12,k) * mat_y_tr(12,j) &
4477 + vec_in(i,13,k) * mat_y_tr(13,j)
4478 end do
4479 end do
4480 end do
4481
4482 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p12 ( real(rp), dimension(13,13), intent(in) mat_z_tr,
real(rp), dimension(13,13,13), intent(in) vec_in,
real(rp), dimension(13,13,13), intent(out) vec_out )

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.

Definition at line 4489 of file scale_element_operation_tensorprod3D_kernel.F90.

4490 implicit none
4491 real(RP), intent(in) :: Mat_z_tr(13,13)
4492 real(RP), intent(in) :: vec_in(13,13,13)
4493 real(RP), intent(out) :: vec_out(13,13,13)
4494
4495 integer :: i, j, k
4496 !----------------------------------------------------------
4497
4498 do k=1, 13
4499 do j=1, 13
4500 do i=1, 13
4501 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
4502 + vec_in(i,j,2) * mat_z_tr(2,k) &
4503 + vec_in(i,j,3) * mat_z_tr(3,k) &
4504 + vec_in(i,j,4) * mat_z_tr(4,k) &
4505 + vec_in(i,j,5) * mat_z_tr(5,k) &
4506 + vec_in(i,j,6) * mat_z_tr(6,k) &
4507 + vec_in(i,j,7) * mat_z_tr(7,k) &
4508 + vec_in(i,j,8) * mat_z_tr(8,k) &
4509 + vec_in(i,j,9) * mat_z_tr(9,k) &
4510 + vec_in(i,j,10) * mat_z_tr(10,k) &
4511 + vec_in(i,j,11) * mat_z_tr(11,k) &
4512 + vec_in(i,j,12) * mat_z_tr(12,k) &
4513 + vec_in(i,j,13) * mat_z_tr(13,k)
4514 end do
4515 end do
4516 end do
4517
4518 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p12 ( real(rp), dimension(13,13,13,6), intent(in) lift,
real(rp), dimension(13,13,6), intent(in) vec_in,
real(rp), dimension(13,13,13), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=12.

Definition at line 4524 of file scale_element_operation_tensorprod3D_kernel.F90.

4525 implicit none
4526 real(RP), intent(in) :: Lift(13,13,13,6)
4527 real(RP), intent(in) :: vec_in(13,13,6)
4528 real(RP), intent(out) :: vec_out(13,13,13)
4529
4530 integer :: i, j, k
4531 !----------------------------------------------------------
4532
4533 do k=1, 13
4534 do j=1, 13
4535 do i=1, 13
4536 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
4537 + lift(i,j,k,2) * vec_in(j,k,2) &
4538 + lift(i,j,k,3) * vec_in(i,k,3) &
4539 + lift(i,j,k,4) * vec_in(j,k,4) &
4540 + lift(i,j,k,5) * vec_in(i,j,5) &
4541 + lift(i,j,k,6) * vec_in(i,j,6)
4542 end do
4543 end do
4544 end do
4545
4546 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p12 ( real(rp), dimension(13,13), intent(in) mat,
real(rp), dimension(13,13), intent(in) mat_tr,
real(rp), dimension(13,13,13), intent(in) vec_in,
real(rp), dimension(13,13**2), intent(in) vec_in_,
real(rp), dimension(13,13**2), intent(out) vec_out_x,
real(rp), dimension(13,13,13), intent(out) vec_out_y,
real(rp), dimension(13,13,13), intent(out) vec_out_z )

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.

Definition at line 4554 of file scale_element_operation_tensorprod3D_kernel.F90.

4556 implicit none
4557 real(RP), intent(in) :: Mat(13,13)
4558 real(RP), intent(in) :: Mat_tr(13,13)
4559 real(RP), intent(in) :: vec_in_(13,13**2)
4560 real(RP), intent(in) :: vec_in(13,13,13)
4561 real(RP), intent(out) :: vec_out_x(13,13**2)
4562 real(RP), intent(out) :: vec_out_y(13,13,13)
4563 real(RP), intent(out) :: vec_out_z(13,13,13)
4564
4565 integer :: i, j, k, jk
4566 !----------------------------------------------------------
4567
4568 ! X-dir
4569
4570 do jk=1, 13**2
4571 do i=1, 13
4572 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
4573 + mat(i,2) * vec_in_(2,jk) &
4574 + mat(i,3) * vec_in_(3,jk) &
4575 + mat(i,4) * vec_in_(4,jk) &
4576 + mat(i,5) * vec_in_(5,jk) &
4577 + mat(i,6) * vec_in_(6,jk) &
4578 + mat(i,7) * vec_in_(7,jk) &
4579 + mat(i,8) * vec_in_(8,jk) &
4580 + mat(i,9) * vec_in_(9,jk) &
4581 + mat(i,10) * vec_in_(10,jk) &
4582 + mat(i,11) * vec_in_(11,jk) &
4583 + mat(i,12) * vec_in_(12,jk) &
4584 + mat(i,13) * vec_in_(13,jk)
4585 end do
4586 end do
4587
4588 ! Y-dir
4589 do k=1, 13
4590 do j=1, 13
4591 do i=1, 13
4592 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4593 + vec_in(i,2,k) * mat_tr(2,j) &
4594 + vec_in(i,3,k) * mat_tr(3,j) &
4595 + vec_in(i,4,k) * mat_tr(4,j) &
4596 + vec_in(i,5,k) * mat_tr(5,j) &
4597 + vec_in(i,6,k) * mat_tr(6,j) &
4598 + vec_in(i,7,k) * mat_tr(7,j) &
4599 + vec_in(i,8,k) * mat_tr(8,j) &
4600 + vec_in(i,9,k) * mat_tr(9,j) &
4601 + vec_in(i,10,k) * mat_tr(10,j) &
4602 + vec_in(i,11,k) * mat_tr(11,j) &
4603 + vec_in(i,12,k) * mat_tr(12,j) &
4604 + vec_in(i,13,k) * mat_tr(13,j)
4605 end do
4606 end do
4607 end do
4608
4609 ! Z-dir
4610 do k=1, 13
4611 do j=1, 13
4612 do i=1, 13
4613 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4614 + vec_in(i,j,2) * mat_tr(2,k) &
4615 + vec_in(i,j,3) * mat_tr(3,k) &
4616 + vec_in(i,j,4) * mat_tr(4,k) &
4617 + vec_in(i,j,5) * mat_tr(5,k) &
4618 + vec_in(i,j,6) * mat_tr(6,k) &
4619 + vec_in(i,j,7) * mat_tr(7,k) &
4620 + vec_in(i,j,8) * mat_tr(8,k) &
4621 + vec_in(i,j,9) * mat_tr(9,k) &
4622 + vec_in(i,j,10) * mat_tr(10,k) &
4623 + vec_in(i,j,11) * mat_tr(11,k) &
4624 + vec_in(i,j,12) * mat_tr(12,k) &
4625 + vec_in(i,j,13) * mat_tr(13,k)
4626 end do
4627 end do
4628 end do
4629
4630 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p12 ( real(rp), dimension(13,13), intent(in) mat,
real(rp), dimension(13,13), intent(in) mat_tr,
real(rp), dimension(13,13**2), intent(in) vec_in_x,
real(rp), dimension(13,13,13), intent(in) vec_in_y,
real(rp), dimension(13,13,13), intent(in) vec_in_z,
real(rp), dimension(13,13**2), intent(out) vec_out_x,
real(rp), dimension(13,13**2), intent(out) vec_out_y,
real(rp), dimension(13,13**2), intent(out) vec_out_z )

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.

Definition at line 4638 of file scale_element_operation_tensorprod3D_kernel.F90.

4641 implicit none
4642 real(RP), intent(in) :: Mat(13,13)
4643 real(RP), intent(in) :: Mat_tr(13,13)
4644 real(RP), intent(in) :: vec_in_x(13,13**2)
4645 real(RP), intent(in) :: vec_in_y(13,13,13)
4646 real(RP), intent(in) :: vec_in_z(13,13,13)
4647 real(RP), intent(out) :: vec_out_x(13,13**2)
4648 real(RP), intent(out) :: vec_out_y(13,13**2)
4649 real(RP), intent(out) :: vec_out_z(13,13**2)
4650
4651 integer :: i, j, k, jk
4652 real(RP) :: tmp1, tmp2, tmp3
4653 !----------------------------------------------------------
4654
4655 ! X-dir
4656
4657 do jk=1, 13**2
4658 do i=1, 13
4659 tmp1 = mat(i,1) * vec_in_x(1,jk) &
4660 + mat(i,2) * vec_in_x(2,jk) &
4661 + mat(i,3) * vec_in_x(3,jk) &
4662 + mat(i,4) * vec_in_x(4,jk)
4663 tmp2 = mat(i,5) * vec_in_x(5,jk) &
4664 + mat(i,6) * vec_in_x(6,jk) &
4665 + mat(i,7) * vec_in_x(7,jk) &
4666 + mat(i,8) * vec_in_x(8,jk)
4667 tmp3 = mat(i,9) * vec_in_x(9,jk) &
4668 + mat(i,10) * vec_in_x(10,jk) &
4669 + mat(i,11) * vec_in_x(11,jk) &
4670 + mat(i,12) * vec_in_x(12,jk) &
4671 + mat(i,13) * vec_in_x(13,jk)
4672 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
4673 end do
4674 end do
4675
4676 ! Y-dir
4677 do k=1, 13
4678 do j=1, 13
4679 jk = j + (k-1)*13
4680 do i=1, 13
4681 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
4682 + vec_in_y(i,2,k) * mat_tr(2,j) &
4683 + vec_in_y(i,3,k) * mat_tr(3,j) &
4684 + vec_in_y(i,4,k) * mat_tr(4,j)
4685 tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
4686 + vec_in_y(i,6,k) * mat_tr(6,j) &
4687 + vec_in_y(i,7,k) * mat_tr(7,j) &
4688 + vec_in_y(i,8,k) * mat_tr(8,j)
4689 tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
4690 + vec_in_y(i,10,k) * mat_tr(10,j) &
4691 + vec_in_y(i,11,k) * mat_tr(11,j) &
4692 + vec_in_y(i,12,k) * mat_tr(12,j) &
4693 + vec_in_y(i,13,k) * mat_tr(13,j)
4694 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
4695 end do
4696 end do
4697 end do
4698
4699 ! Z-dir
4700 do k=1, 13
4701 do j=1, 13
4702 jk = j + (k-1)*13
4703 do i=1, 13
4704 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
4705 + vec_in_z(i,j,2) * mat_tr(2,k) &
4706 + vec_in_z(i,j,3) * mat_tr(3,k) &
4707 + vec_in_z(i,j,4) * mat_tr(4,k)
4708 tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
4709 + vec_in_z(i,j,6) * mat_tr(6,k) &
4710 + vec_in_z(i,j,7) * mat_tr(7,k) &
4711 + vec_in_z(i,j,8) * mat_tr(8,k)
4712 tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
4713 + vec_in_z(i,j,10) * mat_tr(10,k) &
4714 + vec_in_z(i,j,11) * mat_tr(11,k) &
4715 + vec_in_z(i,j,12) * mat_tr(12,k) &
4716 + vec_in_z(i,j,13) * mat_tr(13,k)
4717 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
4718 end do
4719 end do
4720 end do
4721 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p12()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p12 ( real(rp), dimension(13,13), intent(in) mat_h1d,
real(rp), dimension(13,13), intent(in) mat_h1d_tr,
real(rp), dimension(13,13), intent(in) mat_v1d_tr,
real(rp), dimension(13,13,13), intent(in) vec_in,
real(rp), dimension(13,13,13), intent(out) vec_work,
real(rp), dimension(13,13,13), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=12.

Definition at line 4816 of file scale_element_operation_tensorprod3D_kernel.F90.

4818 implicit none
4819 real(RP), intent(in) :: Mat_h1D(13,13)
4820 real(RP), intent(in) :: Mat_h1D_tr(13,13)
4821 real(RP), intent(in) :: Mat_v1D_tr(13,13)
4822 real(RP), intent(in) :: vec_in(13,13,13)
4823 real(RP), intent(out) :: vec_work(13,13,13)
4824 real(RP), intent(out) :: vec_out(13,13,13)
4825
4826 integer :: i, j, k
4827 real(RP) :: tmp1, tmp2, tmp3
4828 !----------------------------------------------------------
4829
4830 ! X-dir
4831
4832 do k=1, 13
4833 do j=1, 13
4834 do i=1, 13
4835 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
4836 + mat_h1d(i,2) * vec_in(2,j,k) &
4837 + mat_h1d(i,3) * vec_in(3,j,k) &
4838 + mat_h1d(i,4) * vec_in(4,j,k)
4839 tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
4840 + mat_h1d(i,6) * vec_in(6,j,k) &
4841 + mat_h1d(i,7) * vec_in(7,j,k) &
4842 + mat_h1d(i,8) * vec_in(8,j,k)
4843 tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
4844 + mat_h1d(i,10) * vec_in(10,j,k) &
4845 + mat_h1d(i,11) * vec_in(11,j,k) &
4846 + mat_h1d(i,12) * vec_in(12,j,k) &
4847 + mat_h1d(i,13) * vec_in(13,j,k)
4848 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4849 end do
4850 end do
4851 end do
4852
4853 ! Y-dir
4854 do k=1, 13
4855 do j=1, 13
4856 do i=1, 13
4857 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
4858 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
4859 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
4860 + vec_out(i,4,k) * mat_h1d_tr(4,j)
4861 tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
4862 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
4863 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
4864 + vec_out(i,8,k) * mat_h1d_tr(8,j)
4865 tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
4866 + vec_out(i,10,k) * mat_h1d_tr(10,j) &
4867 + vec_out(i,11,k) * mat_h1d_tr(11,j) &
4868 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
4869 + vec_out(i,13,k) * mat_h1d_tr(13,j)
4870 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
4871 end do
4872 end do
4873 end do
4874
4875 ! Z-dir
4876 do k=1, 13
4877 do j=1, 13
4878 do i=1, 13
4879 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
4880 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
4881 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
4882 + vec_work(i,j,4) * mat_v1d_tr(4,k)
4883 tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
4884 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
4885 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
4886 + vec_work(i,j,8) * mat_v1d_tr(8,k)
4887 tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
4888 + vec_work(i,j,10) * mat_v1d_tr(10,k) &
4889 + vec_work(i,j,11) * mat_v1d_tr(11,k) &
4890 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
4891 + vec_work(i,j,13) * mat_v1d_tr(13,k)
4892 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4893 end do
4894 end do
4895 end do
4896
4897 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p13 ( real(rp), dimension(14,14), intent(in) mat_x,
real(rp), dimension(14,14**2), intent(in) vec_in,
real(rp), dimension(14,14**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=13.

Definition at line 4905 of file scale_element_operation_tensorprod3D_kernel.F90.

4906 implicit none
4907 real(RP), intent(in) :: Mat_x(14,14)
4908 real(RP), intent(in) :: vec_in(14,14**2)
4909 real(RP), intent(out) :: vec_out(14,14**2)
4910
4911 integer :: i, jk
4912 !----------------------------------------------------------
4913
4914 do jk=1, 14**2
4915 do i=1, 14
4916 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
4917 + mat_x(i,2) * vec_in(2,jk) &
4918 + mat_x(i,3) * vec_in(3,jk) &
4919 + mat_x(i,4) * vec_in(4,jk) &
4920 + mat_x(i,5) * vec_in(5,jk) &
4921 + mat_x(i,6) * vec_in(6,jk) &
4922 + mat_x(i,7) * vec_in(7,jk) &
4923 + mat_x(i,8) * vec_in(8,jk) &
4924 + mat_x(i,9) * vec_in(9,jk) &
4925 + mat_x(i,10) * vec_in(10,jk) &
4926 + mat_x(i,11) * vec_in(11,jk) &
4927 + mat_x(i,12) * vec_in(12,jk) &
4928 + mat_x(i,13) * vec_in(13,jk) &
4929 + mat_x(i,14) * vec_in(14,jk)
4930 end do
4931 end do
4932
4933 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p13 ( real(rp), dimension(14,14), intent(in) mat_y_tr,
real(rp), dimension(14,14,14), intent(in) vec_in,
real(rp), dimension(14,14,14), intent(out) vec_out )

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.

Definition at line 4940 of file scale_element_operation_tensorprod3D_kernel.F90.

4941 implicit none
4942 real(RP), intent(in) :: Mat_y_tr(14,14)
4943 real(RP), intent(in) :: vec_in(14,14,14)
4944 real(RP), intent(out) :: vec_out(14,14,14)
4945
4946 integer :: i, j, k
4947 !----------------------------------------------------------
4948
4949 do k=1, 14
4950 do j=1, 14
4951 do i=1, 14
4952 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
4953 + vec_in(i,2,k) * mat_y_tr(2,j) &
4954 + vec_in(i,3,k) * mat_y_tr(3,j) &
4955 + vec_in(i,4,k) * mat_y_tr(4,j) &
4956 + vec_in(i,5,k) * mat_y_tr(5,j) &
4957 + vec_in(i,6,k) * mat_y_tr(6,j) &
4958 + vec_in(i,7,k) * mat_y_tr(7,j) &
4959 + vec_in(i,8,k) * mat_y_tr(8,j) &
4960 + vec_in(i,9,k) * mat_y_tr(9,j) &
4961 + vec_in(i,10,k) * mat_y_tr(10,j) &
4962 + vec_in(i,11,k) * mat_y_tr(11,j) &
4963 + vec_in(i,12,k) * mat_y_tr(12,j) &
4964 + vec_in(i,13,k) * mat_y_tr(13,j) &
4965 + vec_in(i,14,k) * mat_y_tr(14,j)
4966 end do
4967 end do
4968 end do
4969
4970 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p13 ( real(rp), dimension(14,14), intent(in) mat_z_tr,
real(rp), dimension(14,14,14), intent(in) vec_in,
real(rp), dimension(14,14,14), intent(out) vec_out )

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.

Definition at line 4977 of file scale_element_operation_tensorprod3D_kernel.F90.

4978 implicit none
4979 real(RP), intent(in) :: Mat_z_tr(14,14)
4980 real(RP), intent(in) :: vec_in(14,14,14)
4981 real(RP), intent(out) :: vec_out(14,14,14)
4982
4983 integer :: i, j, k
4984 !----------------------------------------------------------
4985
4986 do k=1, 14
4987 do j=1, 14
4988 do i=1, 14
4989 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
4990 + vec_in(i,j,2) * mat_z_tr(2,k) &
4991 + vec_in(i,j,3) * mat_z_tr(3,k) &
4992 + vec_in(i,j,4) * mat_z_tr(4,k) &
4993 + vec_in(i,j,5) * mat_z_tr(5,k) &
4994 + vec_in(i,j,6) * mat_z_tr(6,k) &
4995 + vec_in(i,j,7) * mat_z_tr(7,k) &
4996 + vec_in(i,j,8) * mat_z_tr(8,k) &
4997 + vec_in(i,j,9) * mat_z_tr(9,k) &
4998 + vec_in(i,j,10) * mat_z_tr(10,k) &
4999 + vec_in(i,j,11) * mat_z_tr(11,k) &
5000 + vec_in(i,j,12) * mat_z_tr(12,k) &
5001 + vec_in(i,j,13) * mat_z_tr(13,k) &
5002 + vec_in(i,j,14) * mat_z_tr(14,k)
5003 end do
5004 end do
5005 end do
5006
5007 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p13 ( real(rp), dimension(14,14,14,6), intent(in) lift,
real(rp), dimension(14,14,6), intent(in) vec_in,
real(rp), dimension(14,14,14), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=13.

Definition at line 5013 of file scale_element_operation_tensorprod3D_kernel.F90.

5014 implicit none
5015 real(RP), intent(in) :: Lift(14,14,14,6)
5016 real(RP), intent(in) :: vec_in(14,14,6)
5017 real(RP), intent(out) :: vec_out(14,14,14)
5018
5019 integer :: i, j, k
5020 !----------------------------------------------------------
5021
5022 do k=1, 14
5023 do j=1, 14
5024 do i=1, 14
5025 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
5026 + lift(i,j,k,2) * vec_in(j,k,2) &
5027 + lift(i,j,k,3) * vec_in(i,k,3) &
5028 + lift(i,j,k,4) * vec_in(j,k,4) &
5029 + lift(i,j,k,5) * vec_in(i,j,5) &
5030 + lift(i,j,k,6) * vec_in(i,j,6)
5031 end do
5032 end do
5033 end do
5034
5035 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p13 ( real(rp), dimension(14,14), intent(in) mat,
real(rp), dimension(14,14), intent(in) mat_tr,
real(rp), dimension(14,14,14), intent(in) vec_in,
real(rp), dimension(14,14**2), intent(in) vec_in_,
real(rp), dimension(14,14**2), intent(out) vec_out_x,
real(rp), dimension(14,14,14), intent(out) vec_out_y,
real(rp), dimension(14,14,14), intent(out) vec_out_z )

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.

Definition at line 5043 of file scale_element_operation_tensorprod3D_kernel.F90.

5045 implicit none
5046 real(RP), intent(in) :: Mat(14,14)
5047 real(RP), intent(in) :: Mat_tr(14,14)
5048 real(RP), intent(in) :: vec_in_(14,14**2)
5049 real(RP), intent(in) :: vec_in(14,14,14)
5050 real(RP), intent(out) :: vec_out_x(14,14**2)
5051 real(RP), intent(out) :: vec_out_y(14,14,14)
5052 real(RP), intent(out) :: vec_out_z(14,14,14)
5053
5054 integer :: i, j, k, jk
5055 !----------------------------------------------------------
5056
5057 ! X-dir
5058
5059 do jk=1, 14**2
5060 do i=1, 14
5061 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
5062 + mat(i,2) * vec_in_(2,jk) &
5063 + mat(i,3) * vec_in_(3,jk) &
5064 + mat(i,4) * vec_in_(4,jk) &
5065 + mat(i,5) * vec_in_(5,jk) &
5066 + mat(i,6) * vec_in_(6,jk) &
5067 + mat(i,7) * vec_in_(7,jk) &
5068 + mat(i,8) * vec_in_(8,jk) &
5069 + mat(i,9) * vec_in_(9,jk) &
5070 + mat(i,10) * vec_in_(10,jk) &
5071 + mat(i,11) * vec_in_(11,jk) &
5072 + mat(i,12) * vec_in_(12,jk) &
5073 + mat(i,13) * vec_in_(13,jk) &
5074 + mat(i,14) * vec_in_(14,jk)
5075 end do
5076 end do
5077
5078 ! Y-dir
5079 do k=1, 14
5080 do j=1, 14
5081 do i=1, 14
5082 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
5083 + vec_in(i,2,k) * mat_tr(2,j) &
5084 + vec_in(i,3,k) * mat_tr(3,j) &
5085 + vec_in(i,4,k) * mat_tr(4,j) &
5086 + vec_in(i,5,k) * mat_tr(5,j) &
5087 + vec_in(i,6,k) * mat_tr(6,j) &
5088 + vec_in(i,7,k) * mat_tr(7,j) &
5089 + vec_in(i,8,k) * mat_tr(8,j) &
5090 + vec_in(i,9,k) * mat_tr(9,j) &
5091 + vec_in(i,10,k) * mat_tr(10,j) &
5092 + vec_in(i,11,k) * mat_tr(11,j) &
5093 + vec_in(i,12,k) * mat_tr(12,j) &
5094 + vec_in(i,13,k) * mat_tr(13,j) &
5095 + vec_in(i,14,k) * mat_tr(14,j)
5096 end do
5097 end do
5098 end do
5099
5100 ! Z-dir
5101 do k=1, 14
5102 do j=1, 14
5103 do i=1, 14
5104 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
5105 + vec_in(i,j,2) * mat_tr(2,k) &
5106 + vec_in(i,j,3) * mat_tr(3,k) &
5107 + vec_in(i,j,4) * mat_tr(4,k) &
5108 + vec_in(i,j,5) * mat_tr(5,k) &
5109 + vec_in(i,j,6) * mat_tr(6,k) &
5110 + vec_in(i,j,7) * mat_tr(7,k) &
5111 + vec_in(i,j,8) * mat_tr(8,k) &
5112 + vec_in(i,j,9) * mat_tr(9,k) &
5113 + vec_in(i,j,10) * mat_tr(10,k) &
5114 + vec_in(i,j,11) * mat_tr(11,k) &
5115 + vec_in(i,j,12) * mat_tr(12,k) &
5116 + vec_in(i,j,13) * mat_tr(13,k) &
5117 + vec_in(i,j,14) * mat_tr(14,k)
5118 end do
5119 end do
5120 end do
5121
5122 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p13 ( real(rp), dimension(14,14), intent(in) mat,
real(rp), dimension(14,14), intent(in) mat_tr,
real(rp), dimension(14,14**2), intent(in) vec_in_x,
real(rp), dimension(14,14,14), intent(in) vec_in_y,
real(rp), dimension(14,14,14), intent(in) vec_in_z,
real(rp), dimension(14,14**2), intent(out) vec_out_x,
real(rp), dimension(14,14**2), intent(out) vec_out_y,
real(rp), dimension(14,14**2), intent(out) vec_out_z )

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.

Definition at line 5130 of file scale_element_operation_tensorprod3D_kernel.F90.

5133 implicit none
5134 real(RP), intent(in) :: Mat(14,14)
5135 real(RP), intent(in) :: Mat_tr(14,14)
5136 real(RP), intent(in) :: vec_in_x(14,14**2)
5137 real(RP), intent(in) :: vec_in_y(14,14,14)
5138 real(RP), intent(in) :: vec_in_z(14,14,14)
5139 real(RP), intent(out) :: vec_out_x(14,14**2)
5140 real(RP), intent(out) :: vec_out_y(14,14**2)
5141 real(RP), intent(out) :: vec_out_z(14,14**2)
5142
5143 integer :: i, j, k, jk
5144 real(RP) :: tmp1, tmp2, tmp3
5145 !----------------------------------------------------------
5146
5147 ! X-dir
5148
5149 do jk=1, 14**2
5150 do i=1, 14
5151 tmp1 = mat(i,1) * vec_in_x(1,jk) &
5152 + mat(i,2) * vec_in_x(2,jk) &
5153 + mat(i,3) * vec_in_x(3,jk) &
5154 + mat(i,4) * vec_in_x(4,jk) &
5155 + mat(i,5) * vec_in_x(5,jk)
5156 tmp2 = mat(i,6) * vec_in_x(6,jk) &
5157 + mat(i,7) * vec_in_x(7,jk) &
5158 + mat(i,8) * vec_in_x(8,jk) &
5159 + mat(i,9) * vec_in_x(9,jk) &
5160 + mat(i,10) * vec_in_x(10,jk)
5161 tmp3 = mat(i,11) * vec_in_x(11,jk) &
5162 + mat(i,12) * vec_in_x(12,jk) &
5163 + mat(i,13) * vec_in_x(13,jk) &
5164 + mat(i,14) * vec_in_x(14,jk)
5165 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
5166 end do
5167 end do
5168
5169 ! Y-dir
5170 do k=1, 14
5171 do j=1, 14
5172 jk = j + (k-1)*14
5173 do i=1, 14
5174 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
5175 + vec_in_y(i,2,k) * mat_tr(2,j) &
5176 + vec_in_y(i,3,k) * mat_tr(3,j) &
5177 + vec_in_y(i,4,k) * mat_tr(4,j) &
5178 + vec_in_y(i,5,k) * mat_tr(5,j)
5179 tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
5180 + vec_in_y(i,7,k) * mat_tr(7,j) &
5181 + vec_in_y(i,8,k) * mat_tr(8,j) &
5182 + vec_in_y(i,9,k) * mat_tr(9,j) &
5183 + vec_in_y(i,10,k) * mat_tr(10,j)
5184 tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
5185 + vec_in_y(i,12,k) * mat_tr(12,j) &
5186 + vec_in_y(i,13,k) * mat_tr(13,j) &
5187 + vec_in_y(i,14,k) * mat_tr(14,j)
5188 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
5189 end do
5190 end do
5191 end do
5192
5193 ! Z-dir
5194 do k=1, 14
5195 do j=1, 14
5196 jk = j + (k-1)*14
5197 do i=1, 14
5198 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
5199 + vec_in_z(i,j,2) * mat_tr(2,k) &
5200 + vec_in_z(i,j,3) * mat_tr(3,k) &
5201 + vec_in_z(i,j,4) * mat_tr(4,k) &
5202 + vec_in_z(i,j,5) * mat_tr(5,k)
5203 tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
5204 + vec_in_z(i,j,7) * mat_tr(7,k) &
5205 + vec_in_z(i,j,8) * mat_tr(8,k) &
5206 + vec_in_z(i,j,9) * mat_tr(9,k) &
5207 + vec_in_z(i,j,10) * mat_tr(10,k)
5208 tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
5209 + vec_in_z(i,j,12) * mat_tr(12,k) &
5210 + vec_in_z(i,j,13) * mat_tr(13,k) &
5211 + vec_in_z(i,j,14) * mat_tr(14,k)
5212 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
5213 end do
5214 end do
5215 end do
5216 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p13()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p13 ( real(rp), dimension(14,14), intent(in) mat_h1d,
real(rp), dimension(14,14), intent(in) mat_h1d_tr,
real(rp), dimension(14,14), intent(in) mat_v1d_tr,
real(rp), dimension(14,14,14), intent(in) vec_in,
real(rp), dimension(14,14,14), intent(out) vec_work,
real(rp), dimension(14,14,14), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=13.

Definition at line 5314 of file scale_element_operation_tensorprod3D_kernel.F90.

5316 implicit none
5317 real(RP), intent(in) :: Mat_h1D(14,14)
5318 real(RP), intent(in) :: Mat_h1D_tr(14,14)
5319 real(RP), intent(in) :: Mat_v1D_tr(14,14)
5320 real(RP), intent(in) :: vec_in(14,14,14)
5321 real(RP), intent(out) :: vec_work(14,14,14)
5322 real(RP), intent(out) :: vec_out(14,14,14)
5323
5324 integer :: i, j, k
5325 real(RP) :: tmp1, tmp2, tmp3
5326 !----------------------------------------------------------
5327
5328 ! X-dir
5329
5330 do k=1, 14
5331 do j=1, 14
5332 do i=1, 14
5333 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
5334 + mat_h1d(i,2) * vec_in(2,j,k) &
5335 + mat_h1d(i,3) * vec_in(3,j,k) &
5336 + mat_h1d(i,4) * vec_in(4,j,k) &
5337 + mat_h1d(i,5) * vec_in(5,j,k)
5338 tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
5339 + mat_h1d(i,7) * vec_in(7,j,k) &
5340 + mat_h1d(i,8) * vec_in(8,j,k) &
5341 + mat_h1d(i,9) * vec_in(9,j,k) &
5342 + mat_h1d(i,10) * vec_in(10,j,k)
5343 tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
5344 + mat_h1d(i,12) * vec_in(12,j,k) &
5345 + mat_h1d(i,13) * vec_in(13,j,k) &
5346 + mat_h1d(i,14) * vec_in(14,j,k)
5347 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
5348 end do
5349 end do
5350 end do
5351
5352 ! Y-dir
5353 do k=1, 14
5354 do j=1, 14
5355 do i=1, 14
5356 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
5357 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
5358 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
5359 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
5360 + vec_out(i,5,k) * mat_h1d_tr(5,j)
5361 tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
5362 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
5363 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
5364 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
5365 + vec_out(i,10,k) * mat_h1d_tr(10,j)
5366 tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
5367 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
5368 + vec_out(i,13,k) * mat_h1d_tr(13,j) &
5369 + vec_out(i,14,k) * mat_h1d_tr(14,j)
5370 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
5371 end do
5372 end do
5373 end do
5374
5375 ! Z-dir
5376 do k=1, 14
5377 do j=1, 14
5378 do i=1, 14
5379 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
5380 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
5381 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
5382 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
5383 + vec_work(i,j,5) * mat_v1d_tr(5,k)
5384 tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
5385 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
5386 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
5387 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
5388 + vec_work(i,j,10) * mat_v1d_tr(10,k)
5389 tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
5390 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
5391 + vec_work(i,j,13) * mat_v1d_tr(13,k) &
5392 + vec_work(i,j,14) * mat_v1d_tr(14,k)
5393 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
5394 end do
5395 end do
5396 end do
5397
5398 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p14 ( real(rp), dimension(15,15), intent(in) mat_x,
real(rp), dimension(15,15**2), intent(in) vec_in,
real(rp), dimension(15,15**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=14.

Definition at line 5406 of file scale_element_operation_tensorprod3D_kernel.F90.

5407 implicit none
5408 real(RP), intent(in) :: Mat_x(15,15)
5409 real(RP), intent(in) :: vec_in(15,15**2)
5410 real(RP), intent(out) :: vec_out(15,15**2)
5411
5412 integer :: i, jk
5413 !----------------------------------------------------------
5414
5415 do jk=1, 15**2
5416 do i=1, 15
5417 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
5418 + mat_x(i,2) * vec_in(2,jk) &
5419 + mat_x(i,3) * vec_in(3,jk) &
5420 + mat_x(i,4) * vec_in(4,jk) &
5421 + mat_x(i,5) * vec_in(5,jk) &
5422 + mat_x(i,6) * vec_in(6,jk) &
5423 + mat_x(i,7) * vec_in(7,jk) &
5424 + mat_x(i,8) * vec_in(8,jk) &
5425 + mat_x(i,9) * vec_in(9,jk) &
5426 + mat_x(i,10) * vec_in(10,jk) &
5427 + mat_x(i,11) * vec_in(11,jk) &
5428 + mat_x(i,12) * vec_in(12,jk) &
5429 + mat_x(i,13) * vec_in(13,jk) &
5430 + mat_x(i,14) * vec_in(14,jk) &
5431 + mat_x(i,15) * vec_in(15,jk)
5432 end do
5433 end do
5434
5435 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p14 ( real(rp), dimension(15,15), intent(in) mat_y_tr,
real(rp), dimension(15,15,15), intent(in) vec_in,
real(rp), dimension(15,15,15), intent(out) vec_out )

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.

Definition at line 5442 of file scale_element_operation_tensorprod3D_kernel.F90.

5443 implicit none
5444 real(RP), intent(in) :: Mat_y_tr(15,15)
5445 real(RP), intent(in) :: vec_in(15,15,15)
5446 real(RP), intent(out) :: vec_out(15,15,15)
5447
5448 integer :: i, j, k
5449 !----------------------------------------------------------
5450
5451 do k=1, 15
5452 do j=1, 15
5453 do i=1, 15
5454 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
5455 + vec_in(i,2,k) * mat_y_tr(2,j) &
5456 + vec_in(i,3,k) * mat_y_tr(3,j) &
5457 + vec_in(i,4,k) * mat_y_tr(4,j) &
5458 + vec_in(i,5,k) * mat_y_tr(5,j) &
5459 + vec_in(i,6,k) * mat_y_tr(6,j) &
5460 + vec_in(i,7,k) * mat_y_tr(7,j) &
5461 + vec_in(i,8,k) * mat_y_tr(8,j) &
5462 + vec_in(i,9,k) * mat_y_tr(9,j) &
5463 + vec_in(i,10,k) * mat_y_tr(10,j) &
5464 + vec_in(i,11,k) * mat_y_tr(11,j) &
5465 + vec_in(i,12,k) * mat_y_tr(12,j) &
5466 + vec_in(i,13,k) * mat_y_tr(13,j) &
5467 + vec_in(i,14,k) * mat_y_tr(14,j) &
5468 + vec_in(i,15,k) * mat_y_tr(15,j)
5469 end do
5470 end do
5471 end do
5472
5473 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p14 ( real(rp), dimension(15,15), intent(in) mat_z_tr,
real(rp), dimension(15,15,15), intent(in) vec_in,
real(rp), dimension(15,15,15), intent(out) vec_out )

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.

Definition at line 5480 of file scale_element_operation_tensorprod3D_kernel.F90.

5481 implicit none
5482 real(RP), intent(in) :: Mat_z_tr(15,15)
5483 real(RP), intent(in) :: vec_in(15,15,15)
5484 real(RP), intent(out) :: vec_out(15,15,15)
5485
5486 integer :: i, j, k
5487 !----------------------------------------------------------
5488
5489 do k=1, 15
5490 do j=1, 15
5491 do i=1, 15
5492 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
5493 + vec_in(i,j,2) * mat_z_tr(2,k) &
5494 + vec_in(i,j,3) * mat_z_tr(3,k) &
5495 + vec_in(i,j,4) * mat_z_tr(4,k) &
5496 + vec_in(i,j,5) * mat_z_tr(5,k) &
5497 + vec_in(i,j,6) * mat_z_tr(6,k) &
5498 + vec_in(i,j,7) * mat_z_tr(7,k) &
5499 + vec_in(i,j,8) * mat_z_tr(8,k) &
5500 + vec_in(i,j,9) * mat_z_tr(9,k) &
5501 + vec_in(i,j,10) * mat_z_tr(10,k) &
5502 + vec_in(i,j,11) * mat_z_tr(11,k) &
5503 + vec_in(i,j,12) * mat_z_tr(12,k) &
5504 + vec_in(i,j,13) * mat_z_tr(13,k) &
5505 + vec_in(i,j,14) * mat_z_tr(14,k) &
5506 + vec_in(i,j,15) * mat_z_tr(15,k)
5507 end do
5508 end do
5509 end do
5510
5511 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p14 ( real(rp), dimension(15,15,15,6), intent(in) lift,
real(rp), dimension(15,15,6), intent(in) vec_in,
real(rp), dimension(15,15,15), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=14.

Definition at line 5517 of file scale_element_operation_tensorprod3D_kernel.F90.

5518 implicit none
5519 real(RP), intent(in) :: Lift(15,15,15,6)
5520 real(RP), intent(in) :: vec_in(15,15,6)
5521 real(RP), intent(out) :: vec_out(15,15,15)
5522
5523 integer :: i, j, k
5524 !----------------------------------------------------------
5525
5526 do k=1, 15
5527 do j=1, 15
5528 do i=1, 15
5529 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
5530 + lift(i,j,k,2) * vec_in(j,k,2) &
5531 + lift(i,j,k,3) * vec_in(i,k,3) &
5532 + lift(i,j,k,4) * vec_in(j,k,4) &
5533 + lift(i,j,k,5) * vec_in(i,j,5) &
5534 + lift(i,j,k,6) * vec_in(i,j,6)
5535 end do
5536 end do
5537 end do
5538
5539 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p14 ( real(rp), dimension(15,15), intent(in) mat,
real(rp), dimension(15,15), intent(in) mat_tr,
real(rp), dimension(15,15,15), intent(in) vec_in,
real(rp), dimension(15,15**2), intent(in) vec_in_,
real(rp), dimension(15,15**2), intent(out) vec_out_x,
real(rp), dimension(15,15,15), intent(out) vec_out_y,
real(rp), dimension(15,15,15), intent(out) vec_out_z )

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.

Definition at line 5547 of file scale_element_operation_tensorprod3D_kernel.F90.

5549 implicit none
5550 real(RP), intent(in) :: Mat(15,15)
5551 real(RP), intent(in) :: Mat_tr(15,15)
5552 real(RP), intent(in) :: vec_in_(15,15**2)
5553 real(RP), intent(in) :: vec_in(15,15,15)
5554 real(RP), intent(out) :: vec_out_x(15,15**2)
5555 real(RP), intent(out) :: vec_out_y(15,15,15)
5556 real(RP), intent(out) :: vec_out_z(15,15,15)
5557
5558 integer :: i, j, k, jk
5559 !----------------------------------------------------------
5560
5561 ! X-dir
5562
5563 do jk=1, 15**2
5564 do i=1, 15
5565 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
5566 + mat(i,2) * vec_in_(2,jk) &
5567 + mat(i,3) * vec_in_(3,jk) &
5568 + mat(i,4) * vec_in_(4,jk) &
5569 + mat(i,5) * vec_in_(5,jk) &
5570 + mat(i,6) * vec_in_(6,jk) &
5571 + mat(i,7) * vec_in_(7,jk) &
5572 + mat(i,8) * vec_in_(8,jk) &
5573 + mat(i,9) * vec_in_(9,jk) &
5574 + mat(i,10) * vec_in_(10,jk) &
5575 + mat(i,11) * vec_in_(11,jk) &
5576 + mat(i,12) * vec_in_(12,jk) &
5577 + mat(i,13) * vec_in_(13,jk) &
5578 + mat(i,14) * vec_in_(14,jk) &
5579 + mat(i,15) * vec_in_(15,jk)
5580 end do
5581 end do
5582
5583 ! Y-dir
5584 do k=1, 15
5585 do j=1, 15
5586 do i=1, 15
5587 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
5588 + vec_in(i,2,k) * mat_tr(2,j) &
5589 + vec_in(i,3,k) * mat_tr(3,j) &
5590 + vec_in(i,4,k) * mat_tr(4,j) &
5591 + vec_in(i,5,k) * mat_tr(5,j) &
5592 + vec_in(i,6,k) * mat_tr(6,j) &
5593 + vec_in(i,7,k) * mat_tr(7,j) &
5594 + vec_in(i,8,k) * mat_tr(8,j) &
5595 + vec_in(i,9,k) * mat_tr(9,j) &
5596 + vec_in(i,10,k) * mat_tr(10,j) &
5597 + vec_in(i,11,k) * mat_tr(11,j) &
5598 + vec_in(i,12,k) * mat_tr(12,j) &
5599 + vec_in(i,13,k) * mat_tr(13,j) &
5600 + vec_in(i,14,k) * mat_tr(14,j) &
5601 + vec_in(i,15,k) * mat_tr(15,j)
5602 end do
5603 end do
5604 end do
5605
5606 ! Z-dir
5607 do k=1, 15
5608 do j=1, 15
5609 do i=1, 15
5610 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
5611 + vec_in(i,j,2) * mat_tr(2,k) &
5612 + vec_in(i,j,3) * mat_tr(3,k) &
5613 + vec_in(i,j,4) * mat_tr(4,k) &
5614 + vec_in(i,j,5) * mat_tr(5,k) &
5615 + vec_in(i,j,6) * mat_tr(6,k) &
5616 + vec_in(i,j,7) * mat_tr(7,k) &
5617 + vec_in(i,j,8) * mat_tr(8,k) &
5618 + vec_in(i,j,9) * mat_tr(9,k) &
5619 + vec_in(i,j,10) * mat_tr(10,k) &
5620 + vec_in(i,j,11) * mat_tr(11,k) &
5621 + vec_in(i,j,12) * mat_tr(12,k) &
5622 + vec_in(i,j,13) * mat_tr(13,k) &
5623 + vec_in(i,j,14) * mat_tr(14,k) &
5624 + vec_in(i,j,15) * mat_tr(15,k)
5625 end do
5626 end do
5627 end do
5628
5629 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p14 ( real(rp), dimension(15,15), intent(in) mat,
real(rp), dimension(15,15), intent(in) mat_tr,
real(rp), dimension(15,15**2), intent(in) vec_in_x,
real(rp), dimension(15,15,15), intent(in) vec_in_y,
real(rp), dimension(15,15,15), intent(in) vec_in_z,
real(rp), dimension(15,15**2), intent(out) vec_out_x,
real(rp), dimension(15,15**2), intent(out) vec_out_y,
real(rp), dimension(15,15**2), intent(out) vec_out_z )

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.

Definition at line 5637 of file scale_element_operation_tensorprod3D_kernel.F90.

5640 implicit none
5641 real(RP), intent(in) :: Mat(15,15)
5642 real(RP), intent(in) :: Mat_tr(15,15)
5643 real(RP), intent(in) :: vec_in_x(15,15**2)
5644 real(RP), intent(in) :: vec_in_y(15,15,15)
5645 real(RP), intent(in) :: vec_in_z(15,15,15)
5646 real(RP), intent(out) :: vec_out_x(15,15**2)
5647 real(RP), intent(out) :: vec_out_y(15,15**2)
5648 real(RP), intent(out) :: vec_out_z(15,15**2)
5649
5650 integer :: i, j, k, jk
5651 real(RP) :: tmp1, tmp2, tmp3
5652 !----------------------------------------------------------
5653
5654 ! X-dir
5655
5656 do jk=1, 15**2
5657 do i=1, 15
5658 tmp1 = mat(i,1) * vec_in_x(1,jk) &
5659 + mat(i,2) * vec_in_x(2,jk) &
5660 + mat(i,3) * vec_in_x(3,jk) &
5661 + mat(i,4) * vec_in_x(4,jk) &
5662 + mat(i,5) * vec_in_x(5,jk)
5663 tmp2 = mat(i,6) * vec_in_x(6,jk) &
5664 + mat(i,7) * vec_in_x(7,jk) &
5665 + mat(i,8) * vec_in_x(8,jk) &
5666 + mat(i,9) * vec_in_x(9,jk) &
5667 + mat(i,10) * vec_in_x(10,jk)
5668 tmp3 = mat(i,11) * vec_in_x(11,jk) &
5669 + mat(i,12) * vec_in_x(12,jk) &
5670 + mat(i,13) * vec_in_x(13,jk) &
5671 + mat(i,14) * vec_in_x(14,jk) &
5672 + mat(i,15) * vec_in_x(15,jk)
5673 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
5674 end do
5675 end do
5676
5677 ! Y-dir
5678 do k=1, 15
5679 do j=1, 15
5680 jk = j + (k-1)*15
5681 do i=1, 15
5682 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
5683 + vec_in_y(i,2,k) * mat_tr(2,j) &
5684 + vec_in_y(i,3,k) * mat_tr(3,j) &
5685 + vec_in_y(i,4,k) * mat_tr(4,j) &
5686 + vec_in_y(i,5,k) * mat_tr(5,j)
5687 tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
5688 + vec_in_y(i,7,k) * mat_tr(7,j) &
5689 + vec_in_y(i,8,k) * mat_tr(8,j) &
5690 + vec_in_y(i,9,k) * mat_tr(9,j) &
5691 + vec_in_y(i,10,k) * mat_tr(10,j)
5692 tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
5693 + vec_in_y(i,12,k) * mat_tr(12,j) &
5694 + vec_in_y(i,13,k) * mat_tr(13,j) &
5695 + vec_in_y(i,14,k) * mat_tr(14,j) &
5696 + vec_in_y(i,15,k) * mat_tr(15,j)
5697 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
5698 end do
5699 end do
5700 end do
5701
5702 ! Z-dir
5703 do k=1, 15
5704 do j=1, 15
5705 jk = j + (k-1)*15
5706 do i=1, 15
5707 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
5708 + vec_in_z(i,j,2) * mat_tr(2,k) &
5709 + vec_in_z(i,j,3) * mat_tr(3,k) &
5710 + vec_in_z(i,j,4) * mat_tr(4,k) &
5711 + vec_in_z(i,j,5) * mat_tr(5,k)
5712 tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
5713 + vec_in_z(i,j,7) * mat_tr(7,k) &
5714 + vec_in_z(i,j,8) * mat_tr(8,k) &
5715 + vec_in_z(i,j,9) * mat_tr(9,k) &
5716 + vec_in_z(i,j,10) * mat_tr(10,k)
5717 tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
5718 + vec_in_z(i,j,12) * mat_tr(12,k) &
5719 + vec_in_z(i,j,13) * mat_tr(13,k) &
5720 + vec_in_z(i,j,14) * mat_tr(14,k) &
5721 + vec_in_z(i,j,15) * mat_tr(15,k)
5722 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
5723 end do
5724 end do
5725 end do
5726 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p14()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p14 ( real(rp), dimension(15,15), intent(in) mat_h1d,
real(rp), dimension(15,15), intent(in) mat_h1d_tr,
real(rp), dimension(15,15), intent(in) mat_v1d_tr,
real(rp), dimension(15,15,15), intent(in) vec_in,
real(rp), dimension(15,15,15), intent(out) vec_work,
real(rp), dimension(15,15,15), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=14.

Definition at line 5827 of file scale_element_operation_tensorprod3D_kernel.F90.

5829 implicit none
5830 real(RP), intent(in) :: Mat_h1D(15,15)
5831 real(RP), intent(in) :: Mat_h1D_tr(15,15)
5832 real(RP), intent(in) :: Mat_v1D_tr(15,15)
5833 real(RP), intent(in) :: vec_in(15,15,15)
5834 real(RP), intent(out) :: vec_work(15,15,15)
5835 real(RP), intent(out) :: vec_out(15,15,15)
5836
5837 integer :: i, j, k
5838 real(RP) :: tmp1, tmp2, tmp3
5839 !----------------------------------------------------------
5840
5841 ! X-dir
5842
5843 do k=1, 15
5844 do j=1, 15
5845 do i=1, 15
5846 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
5847 + mat_h1d(i,2) * vec_in(2,j,k) &
5848 + mat_h1d(i,3) * vec_in(3,j,k) &
5849 + mat_h1d(i,4) * vec_in(4,j,k) &
5850 + mat_h1d(i,5) * vec_in(5,j,k)
5851 tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
5852 + mat_h1d(i,7) * vec_in(7,j,k) &
5853 + mat_h1d(i,8) * vec_in(8,j,k) &
5854 + mat_h1d(i,9) * vec_in(9,j,k) &
5855 + mat_h1d(i,10) * vec_in(10,j,k)
5856 tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
5857 + mat_h1d(i,12) * vec_in(12,j,k) &
5858 + mat_h1d(i,13) * vec_in(13,j,k) &
5859 + mat_h1d(i,14) * vec_in(14,j,k) &
5860 + mat_h1d(i,15) * vec_in(15,j,k)
5861 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
5862 end do
5863 end do
5864 end do
5865
5866 ! Y-dir
5867 do k=1, 15
5868 do j=1, 15
5869 do i=1, 15
5870 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
5871 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
5872 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
5873 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
5874 + vec_out(i,5,k) * mat_h1d_tr(5,j)
5875 tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
5876 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
5877 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
5878 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
5879 + vec_out(i,10,k) * mat_h1d_tr(10,j)
5880 tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
5881 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
5882 + vec_out(i,13,k) * mat_h1d_tr(13,j) &
5883 + vec_out(i,14,k) * mat_h1d_tr(14,j) &
5884 + vec_out(i,15,k) * mat_h1d_tr(15,j)
5885 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
5886 end do
5887 end do
5888 end do
5889
5890 ! Z-dir
5891 do k=1, 15
5892 do j=1, 15
5893 do i=1, 15
5894 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
5895 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
5896 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
5897 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
5898 + vec_work(i,j,5) * mat_v1d_tr(5,k)
5899 tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
5900 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
5901 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
5902 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
5903 + vec_work(i,j,10) * mat_v1d_tr(10,k)
5904 tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
5905 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
5906 + vec_work(i,j,13) * mat_v1d_tr(13,k) &
5907 + vec_work(i,j,14) * mat_v1d_tr(14,k) &
5908 + vec_work(i,j,15) * mat_v1d_tr(15,k)
5909 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
5910 end do
5911 end do
5912 end do
5913
5914 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirx_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirx_p15 ( real(rp), dimension(16,16), intent(in) mat_x,
real(rp), dimension(16,16**2), intent(in) vec_in,
real(rp), dimension(16,16**2), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with mathematical operations in the x direction (first dimension of vec_in) with p=15.

Definition at line 5922 of file scale_element_operation_tensorprod3D_kernel.F90.

5923 implicit none
5924 real(RP), intent(in) :: Mat_x(16,16)
5925 real(RP), intent(in) :: vec_in(16,16**2)
5926 real(RP), intent(out) :: vec_out(16,16**2)
5927
5928 integer :: i, jk
5929 !----------------------------------------------------------
5930
5931 do jk=1, 16**2
5932 do i=1, 16
5933 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
5934 + mat_x(i,2) * vec_in(2,jk) &
5935 + mat_x(i,3) * vec_in(3,jk) &
5936 + mat_x(i,4) * vec_in(4,jk) &
5937 + mat_x(i,5) * vec_in(5,jk) &
5938 + mat_x(i,6) * vec_in(6,jk) &
5939 + mat_x(i,7) * vec_in(7,jk) &
5940 + mat_x(i,8) * vec_in(8,jk) &
5941 + mat_x(i,9) * vec_in(9,jk) &
5942 + mat_x(i,10) * vec_in(10,jk) &
5943 + mat_x(i,11) * vec_in(11,jk) &
5944 + mat_x(i,12) * vec_in(12,jk) &
5945 + mat_x(i,13) * vec_in(13,jk) &
5946 + mat_x(i,14) * vec_in(14,jk) &
5947 + mat_x(i,15) * vec_in(15,jk) &
5948 + mat_x(i,16) * vec_in(16,jk)
5949 end do
5950 end do
5951
5952 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_diry_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_diry_p15 ( real(rp), dimension(16,16), intent(in) mat_y_tr,
real(rp), dimension(16,16,16), intent(in) vec_in,
real(rp), dimension(16,16,16), intent(out) vec_out )

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.

Definition at line 5959 of file scale_element_operation_tensorprod3D_kernel.F90.

5960 implicit none
5961 real(RP), intent(in) :: Mat_y_tr(16,16)
5962 real(RP), intent(in) :: vec_in(16,16,16)
5963 real(RP), intent(out) :: vec_out(16,16,16)
5964
5965 integer :: i, j, k
5966 !----------------------------------------------------------
5967
5968 do k=1, 16
5969 do j=1, 16
5970 do i=1, 16
5971 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
5972 + vec_in(i,2,k) * mat_y_tr(2,j) &
5973 + vec_in(i,3,k) * mat_y_tr(3,j) &
5974 + vec_in(i,4,k) * mat_y_tr(4,j) &
5975 + vec_in(i,5,k) * mat_y_tr(5,j) &
5976 + vec_in(i,6,k) * mat_y_tr(6,j) &
5977 + vec_in(i,7,k) * mat_y_tr(7,j) &
5978 + vec_in(i,8,k) * mat_y_tr(8,j) &
5979 + vec_in(i,9,k) * mat_y_tr(9,j) &
5980 + vec_in(i,10,k) * mat_y_tr(10,j) &
5981 + vec_in(i,11,k) * mat_y_tr(11,j) &
5982 + vec_in(i,12,k) * mat_y_tr(12,j) &
5983 + vec_in(i,13,k) * mat_y_tr(13,j) &
5984 + vec_in(i,14,k) * mat_y_tr(14,j) &
5985 + vec_in(i,15,k) * mat_y_tr(15,j) &
5986 + vec_in(i,16,k) * mat_y_tr(16,j)
5987 end do
5988 end do
5989 end do
5990
5991 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_dirz_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_dirz_p15 ( real(rp), dimension(16,16), intent(in) mat_z_tr,
real(rp), dimension(16,16,16), intent(in) vec_in,
real(rp), dimension(16,16,16), intent(out) vec_out )

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.

Definition at line 5998 of file scale_element_operation_tensorprod3D_kernel.F90.

5999 implicit none
6000 real(RP), intent(in) :: Mat_z_tr(16,16)
6001 real(RP), intent(in) :: vec_in(16,16,16)
6002 real(RP), intent(out) :: vec_out(16,16,16)
6003
6004 integer :: i, j, k
6005 !----------------------------------------------------------
6006
6007 do k=1, 16
6008 do j=1, 16
6009 do i=1, 16
6010 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
6011 + vec_in(i,j,2) * mat_z_tr(2,k) &
6012 + vec_in(i,j,3) * mat_z_tr(3,k) &
6013 + vec_in(i,j,4) * mat_z_tr(4,k) &
6014 + vec_in(i,j,5) * mat_z_tr(5,k) &
6015 + vec_in(i,j,6) * mat_z_tr(6,k) &
6016 + vec_in(i,j,7) * mat_z_tr(7,k) &
6017 + vec_in(i,j,8) * mat_z_tr(8,k) &
6018 + vec_in(i,j,9) * mat_z_tr(9,k) &
6019 + vec_in(i,j,10) * mat_z_tr(10,k) &
6020 + vec_in(i,j,11) * mat_z_tr(11,k) &
6021 + vec_in(i,j,12) * mat_z_tr(12,k) &
6022 + vec_in(i,j,13) * mat_z_tr(13,k) &
6023 + vec_in(i,j,14) * mat_z_tr(14,k) &
6024 + vec_in(i,j,15) * mat_z_tr(15,k) &
6025 + vec_in(i,j,16) * mat_z_tr(16,k)
6026 end do
6027 end do
6028 end do
6029
6030 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_lift_hexahedral_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_lift_hexahedral_p15 ( real(rp), dimension(16,16,16,6), intent(in) lift,
real(rp), dimension(16,16,6), intent(in) vec_in,
real(rp), dimension(16,16,16), intent(out) vec_out )

Calculate a matrix-vector multiplication with lifting operations for a hexahedral element of order p=15.

Definition at line 6036 of file scale_element_operation_tensorprod3D_kernel.F90.

6037 implicit none
6038 real(RP), intent(in) :: Lift(16,16,16,6)
6039 real(RP), intent(in) :: vec_in(16,16,6)
6040 real(RP), intent(out) :: vec_out(16,16,16)
6041
6042 integer :: i, j, k
6043 !----------------------------------------------------------
6044
6045 do k=1, 16
6046 do j=1, 16
6047 do i=1, 16
6048 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
6049 + lift(i,j,k,2) * vec_in(j,k,2) &
6050 + lift(i,j,k,3) * vec_in(i,k,3) &
6051 + lift(i,j,k,4) * vec_in(j,k,4) &
6052 + lift(i,j,k,5) * vec_in(i,j,5) &
6053 + lift(i,j,k,6) * vec_in(i,j,6)
6054 end do
6055 end do
6056 end do
6057
6058 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_gradlike_dirxyz_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_gradlike_dirxyz_p15 ( real(rp), dimension(16,16), intent(in) mat,
real(rp), dimension(16,16), intent(in) mat_tr,
real(rp), dimension(16,16,16), intent(in) vec_in,
real(rp), dimension(16,16**2), intent(in) vec_in_,
real(rp), dimension(16,16**2), intent(out) vec_out_x,
real(rp), dimension(16,16,16), intent(out) vec_out_y,
real(rp), dimension(16,16,16), intent(out) vec_out_z )

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.

Definition at line 6066 of file scale_element_operation_tensorprod3D_kernel.F90.

6068 implicit none
6069 real(RP), intent(in) :: Mat(16,16)
6070 real(RP), intent(in) :: Mat_tr(16,16)
6071 real(RP), intent(in) :: vec_in_(16,16**2)
6072 real(RP), intent(in) :: vec_in(16,16,16)
6073 real(RP), intent(out) :: vec_out_x(16,16**2)
6074 real(RP), intent(out) :: vec_out_y(16,16,16)
6075 real(RP), intent(out) :: vec_out_z(16,16,16)
6076
6077 integer :: i, j, k, jk
6078 !----------------------------------------------------------
6079
6080 ! X-dir
6081
6082 do jk=1, 16**2
6083 do i=1, 16
6084 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
6085 + mat(i,2) * vec_in_(2,jk) &
6086 + mat(i,3) * vec_in_(3,jk) &
6087 + mat(i,4) * vec_in_(4,jk) &
6088 + mat(i,5) * vec_in_(5,jk) &
6089 + mat(i,6) * vec_in_(6,jk) &
6090 + mat(i,7) * vec_in_(7,jk) &
6091 + mat(i,8) * vec_in_(8,jk) &
6092 + mat(i,9) * vec_in_(9,jk) &
6093 + mat(i,10) * vec_in_(10,jk) &
6094 + mat(i,11) * vec_in_(11,jk) &
6095 + mat(i,12) * vec_in_(12,jk) &
6096 + mat(i,13) * vec_in_(13,jk) &
6097 + mat(i,14) * vec_in_(14,jk) &
6098 + mat(i,15) * vec_in_(15,jk) &
6099 + mat(i,16) * vec_in_(16,jk)
6100 end do
6101 end do
6102
6103 ! Y-dir
6104 do k=1, 16
6105 do j=1, 16
6106 do i=1, 16
6107 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
6108 + vec_in(i,2,k) * mat_tr(2,j) &
6109 + vec_in(i,3,k) * mat_tr(3,j) &
6110 + vec_in(i,4,k) * mat_tr(4,j) &
6111 + vec_in(i,5,k) * mat_tr(5,j) &
6112 + vec_in(i,6,k) * mat_tr(6,j) &
6113 + vec_in(i,7,k) * mat_tr(7,j) &
6114 + vec_in(i,8,k) * mat_tr(8,j) &
6115 + vec_in(i,9,k) * mat_tr(9,j) &
6116 + vec_in(i,10,k) * mat_tr(10,j) &
6117 + vec_in(i,11,k) * mat_tr(11,j) &
6118 + vec_in(i,12,k) * mat_tr(12,j) &
6119 + vec_in(i,13,k) * mat_tr(13,j) &
6120 + vec_in(i,14,k) * mat_tr(14,j) &
6121 + vec_in(i,15,k) * mat_tr(15,j) &
6122 + vec_in(i,16,k) * mat_tr(16,j)
6123 end do
6124 end do
6125 end do
6126
6127 ! Z-dir
6128 do k=1, 16
6129 do j=1, 16
6130 do i=1, 16
6131 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
6132 + vec_in(i,j,2) * mat_tr(2,k) &
6133 + vec_in(i,j,3) * mat_tr(3,k) &
6134 + vec_in(i,j,4) * mat_tr(4,k) &
6135 + vec_in(i,j,5) * mat_tr(5,k) &
6136 + vec_in(i,j,6) * mat_tr(6,k) &
6137 + vec_in(i,j,7) * mat_tr(7,k) &
6138 + vec_in(i,j,8) * mat_tr(8,k) &
6139 + vec_in(i,j,9) * mat_tr(9,k) &
6140 + vec_in(i,j,10) * mat_tr(10,k) &
6141 + vec_in(i,j,11) * mat_tr(11,k) &
6142 + vec_in(i,j,12) * mat_tr(12,k) &
6143 + vec_in(i,j,13) * mat_tr(13,k) &
6144 + vec_in(i,j,14) * mat_tr(14,k) &
6145 + vec_in(i,j,15) * mat_tr(15,k) &
6146 + vec_in(i,j,16) * mat_tr(16,k)
6147 end do
6148 end do
6149 end do
6150
6151 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_divlike_dirxyz_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_divlike_dirxyz_p15 ( real(rp), dimension(16,16), intent(in) mat,
real(rp), dimension(16,16), intent(in) mat_tr,
real(rp), dimension(16,16**2), intent(in) vec_in_x,
real(rp), dimension(16,16,16), intent(in) vec_in_y,
real(rp), dimension(16,16,16), intent(in) vec_in_z,
real(rp), dimension(16,16**2), intent(out) vec_out_x,
real(rp), dimension(16,16**2), intent(out) vec_out_y,
real(rp), dimension(16,16**2), intent(out) vec_out_z )

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.

Definition at line 6159 of file scale_element_operation_tensorprod3D_kernel.F90.

6162 implicit none
6163 real(RP), intent(in) :: Mat(16,16)
6164 real(RP), intent(in) :: Mat_tr(16,16)
6165 real(RP), intent(in) :: vec_in_x(16,16**2)
6166 real(RP), intent(in) :: vec_in_y(16,16,16)
6167 real(RP), intent(in) :: vec_in_z(16,16,16)
6168 real(RP), intent(out) :: vec_out_x(16,16**2)
6169 real(RP), intent(out) :: vec_out_y(16,16**2)
6170 real(RP), intent(out) :: vec_out_z(16,16**2)
6171
6172 integer :: i, j, k, jk
6173 real(RP) :: tmp1, tmp2, tmp3
6174 !----------------------------------------------------------
6175
6176 ! X-dir
6177
6178 do jk=1, 16**2
6179 do i=1, 16
6180 tmp1 = mat(i,1) * vec_in_x(1,jk) &
6181 + mat(i,2) * vec_in_x(2,jk) &
6182 + mat(i,3) * vec_in_x(3,jk) &
6183 + mat(i,4) * vec_in_x(4,jk) &
6184 + mat(i,5) * vec_in_x(5,jk)
6185 tmp2 = mat(i,6) * vec_in_x(6,jk) &
6186 + mat(i,7) * vec_in_x(7,jk) &
6187 + mat(i,8) * vec_in_x(8,jk) &
6188 + mat(i,9) * vec_in_x(9,jk) &
6189 + mat(i,10) * vec_in_x(10,jk)
6190 tmp3 = mat(i,11) * vec_in_x(11,jk) &
6191 + mat(i,12) * vec_in_x(12,jk) &
6192 + mat(i,13) * vec_in_x(13,jk) &
6193 + mat(i,14) * vec_in_x(14,jk) &
6194 + mat(i,15) * vec_in_x(15,jk) &
6195 + mat(i,16) * vec_in_x(16,jk)
6196 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
6197 end do
6198 end do
6199
6200 ! Y-dir
6201 do k=1, 16
6202 do j=1, 16
6203 jk = j + (k-1)*16
6204 do i=1, 16
6205 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
6206 + vec_in_y(i,2,k) * mat_tr(2,j) &
6207 + vec_in_y(i,3,k) * mat_tr(3,j) &
6208 + vec_in_y(i,4,k) * mat_tr(4,j) &
6209 + vec_in_y(i,5,k) * mat_tr(5,j)
6210 tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
6211 + vec_in_y(i,7,k) * mat_tr(7,j) &
6212 + vec_in_y(i,8,k) * mat_tr(8,j) &
6213 + vec_in_y(i,9,k) * mat_tr(9,j) &
6214 + vec_in_y(i,10,k) * mat_tr(10,j)
6215 tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
6216 + vec_in_y(i,12,k) * mat_tr(12,j) &
6217 + vec_in_y(i,13,k) * mat_tr(13,j) &
6218 + vec_in_y(i,14,k) * mat_tr(14,j) &
6219 + vec_in_y(i,15,k) * mat_tr(15,j) &
6220 + vec_in_y(i,16,k) * mat_tr(16,j)
6221 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
6222 end do
6223 end do
6224 end do
6225
6226 ! Z-dir
6227 do k=1, 16
6228 do j=1, 16
6229 jk = j + (k-1)*16
6230 do i=1, 16
6231 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
6232 + vec_in_z(i,j,2) * mat_tr(2,k) &
6233 + vec_in_z(i,j,3) * mat_tr(3,k) &
6234 + vec_in_z(i,j,4) * mat_tr(4,k) &
6235 + vec_in_z(i,j,5) * mat_tr(5,k)
6236 tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
6237 + vec_in_z(i,j,7) * mat_tr(7,k) &
6238 + vec_in_z(i,j,8) * mat_tr(8,k) &
6239 + vec_in_z(i,j,9) * mat_tr(9,k) &
6240 + vec_in_z(i,j,10) * mat_tr(10,k)
6241 tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
6242 + vec_in_z(i,j,12) * mat_tr(12,k) &
6243 + vec_in_z(i,j,13) * mat_tr(13,k) &
6244 + vec_in_z(i,j,14) * mat_tr(14,k) &
6245 + vec_in_z(i,j,15) * mat_tr(15,k) &
6246 + vec_in_z(i,j,16) * mat_tr(16,k)
6247 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
6248 end do
6249 end do
6250 end do
6251 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

◆ element_operation_kernel_matvec_modalfilter_p15()

subroutine, public scale_element_operation_tensorprod3d_kernel::element_operation_kernel_matvec_modalfilter_p15 ( real(rp), dimension(16,16), intent(in) mat_h1d,
real(rp), dimension(16,16), intent(in) mat_h1d_tr,
real(rp), dimension(16,16), intent(in) mat_v1d_tr,
real(rp), dimension(16,16,16), intent(in) vec_in,
real(rp), dimension(16,16,16), intent(out) vec_work,
real(rp), dimension(16,16,16), intent(out) vec_out )

Calculate a matrix-vector multiplication associated with 3D modal filtering with p=15.

Definition at line 6355 of file scale_element_operation_tensorprod3D_kernel.F90.

6357 implicit none
6358 real(RP), intent(in) :: Mat_h1D(16,16)
6359 real(RP), intent(in) :: Mat_h1D_tr(16,16)
6360 real(RP), intent(in) :: Mat_v1D_tr(16,16)
6361 real(RP), intent(in) :: vec_in(16,16,16)
6362 real(RP), intent(out) :: vec_work(16,16,16)
6363 real(RP), intent(out) :: vec_out(16,16,16)
6364
6365 integer :: i, j, k
6366 real(RP) :: tmp1, tmp2, tmp3
6367 !----------------------------------------------------------
6368
6369 ! X-dir
6370
6371 do k=1, 16
6372 do j=1, 16
6373 do i=1, 16
6374 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
6375 + mat_h1d(i,2) * vec_in(2,j,k) &
6376 + mat_h1d(i,3) * vec_in(3,j,k) &
6377 + mat_h1d(i,4) * vec_in(4,j,k) &
6378 + mat_h1d(i,5) * vec_in(5,j,k)
6379 tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
6380 + mat_h1d(i,7) * vec_in(7,j,k) &
6381 + mat_h1d(i,8) * vec_in(8,j,k) &
6382 + mat_h1d(i,9) * vec_in(9,j,k) &
6383 + mat_h1d(i,10) * vec_in(10,j,k)
6384 tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
6385 + mat_h1d(i,12) * vec_in(12,j,k) &
6386 + mat_h1d(i,13) * vec_in(13,j,k) &
6387 + mat_h1d(i,14) * vec_in(14,j,k) &
6388 + mat_h1d(i,15) * vec_in(15,j,k) &
6389 + mat_h1d(i,16) * vec_in(16,j,k)
6390 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
6391 end do
6392 end do
6393 end do
6394
6395 ! Y-dir
6396 do k=1, 16
6397 do j=1, 16
6398 do i=1, 16
6399 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
6400 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
6401 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
6402 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
6403 + vec_out(i,5,k) * mat_h1d_tr(5,j)
6404 tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
6405 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
6406 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
6407 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
6408 + vec_out(i,10,k) * mat_h1d_tr(10,j)
6409 tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
6410 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
6411 + vec_out(i,13,k) * mat_h1d_tr(13,j) &
6412 + vec_out(i,14,k) * mat_h1d_tr(14,j) &
6413 + vec_out(i,15,k) * mat_h1d_tr(15,j) &
6414 + vec_out(i,16,k) * mat_h1d_tr(16,j)
6415 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
6416 end do
6417 end do
6418 end do
6419
6420 ! Z-dir
6421 do k=1, 16
6422 do j=1, 16
6423 do i=1, 16
6424 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
6425 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
6426 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
6427 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
6428 + vec_work(i,j,5) * mat_v1d_tr(5,k)
6429 tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
6430 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
6431 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
6432 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
6433 + vec_work(i,j,10) * mat_v1d_tr(10,k)
6434 tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
6435 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
6436 + vec_work(i,j,13) * mat_v1d_tr(13,k) &
6437 + vec_work(i,j,14) * mat_v1d_tr(14,k) &
6438 + vec_work(i,j,15) * mat_v1d_tr(15,k) &
6439 + vec_work(i,j,16) * mat_v1d_tr(16,k)
6440 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
6441 end do
6442 end do
6443 end do
6444
6445 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

Generated by doxygen 1.14.0