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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 associated with Lift operations with hexahedral element of 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 352 of file scale_element_operation_tensorprod3D_kernel.F90.

354 implicit none
355 real(RP), intent(in) :: Mat_h1D(2,2)
356 real(RP), intent(in) :: Mat_h1D_tr(2,2)
357 real(RP), intent(in) :: Mat_v1D_tr(2,2)
358 real(RP), intent(in) :: vec_in(2,2,2)
359 real(RP), intent(out) :: vec_work(2,2,2)
360 real(RP), intent(out) :: vec_out(2,2,2)
361
362 integer :: i, j, k
363 !----------------------------------------------------------
364
365 ! X-dir
366
367 do k=1, 2
368 do j=1, 2
369 do i=1, 2
370 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
371 + mat_h1d(i,2) * vec_in(2,j,k)
372 end do
373 end do
374 end do
375
376 ! Y-dir
377 do k=1, 2
378 do j=1, 2
379 do i=1, 2
380 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
381 + vec_out(i,2,k) * mat_h1d_tr(2,j)
382 end do
383 end do
384 end do
385
386 ! Z-dir
387 do k=1, 2
388 do j=1, 2
389 do i=1, 2
390 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
391 + vec_work(i,j,2) * mat_v1d_tr(2,k)
392 end do
393 end do
394 end do
395
396 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 404 of file scale_element_operation_tensorprod3D_kernel.F90.

405 implicit none
406 real(RP), intent(in) :: Mat_x(3,3)
407 real(RP), intent(in) :: vec_in(3,3**2)
408 real(RP), intent(out) :: vec_out(3,3**2)
409
410 integer :: i, jk
411 !----------------------------------------------------------
412
413 do jk=1, 3**2
414 do i=1, 3
415 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
416 + mat_x(i,2) * vec_in(2,jk) &
417 + mat_x(i,3) * vec_in(3,jk)
418 end do
419 end do
420
421 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 428 of file scale_element_operation_tensorprod3D_kernel.F90.

429 implicit none
430 real(RP), intent(in) :: Mat_y_tr(3,3)
431 real(RP), intent(in) :: vec_in(3,3,3)
432 real(RP), intent(out) :: vec_out(3,3,3)
433
434 integer :: i, j, k
435 !----------------------------------------------------------
436
437 do k=1, 3
438 do j=1, 3
439 do i=1, 3
440 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
441 + vec_in(i,2,k) * mat_y_tr(2,j) &
442 + vec_in(i,3,k) * mat_y_tr(3,j)
443 end do
444 end do
445 end do
446
447 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 454 of file scale_element_operation_tensorprod3D_kernel.F90.

455 implicit none
456 real(RP), intent(in) :: Mat_z_tr(3,3)
457 real(RP), intent(in) :: vec_in(3,3,3)
458 real(RP), intent(out) :: vec_out(3,3,3)
459
460 integer :: i, j, k
461 !----------------------------------------------------------
462
463 do k=1, 3
464 do j=1, 3
465 do i=1, 3
466 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
467 + vec_in(i,j,2) * mat_z_tr(2,k) &
468 + vec_in(i,j,3) * mat_z_tr(3,k)
469 end do
470 end do
471 end do
472
473 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 associated with Lift operations with hexahedral element of p=2.

Definition at line 479 of file scale_element_operation_tensorprod3D_kernel.F90.

480 implicit none
481 real(RP), intent(in) :: Lift(3,3,3,6)
482 real(RP), intent(in) :: vec_in(3,3,6)
483 real(RP), intent(out) :: vec_out(3,3,3)
484
485 integer :: i, j, k
486 !----------------------------------------------------------
487
488 do k=1, 3
489 do j=1, 3
490 do i=1, 3
491 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
492 + lift(i,j,k,2) * vec_in(j,k,2) &
493 + lift(i,j,k,3) * vec_in(i,k,3) &
494 + lift(i,j,k,4) * vec_in(j,k,4) &
495 + lift(i,j,k,5) * vec_in(i,j,5) &
496 + lift(i,j,k,6) * vec_in(i,j,6)
497 end do
498 end do
499 end do
500
501 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 509 of file scale_element_operation_tensorprod3D_kernel.F90.

511 implicit none
512 real(RP), intent(in) :: Mat(3,3)
513 real(RP), intent(in) :: Mat_tr(3,3)
514 real(RP), intent(in) :: vec_in_(3,3**2)
515 real(RP), intent(in) :: vec_in(3,3,3)
516 real(RP), intent(out) :: vec_out_x(3,3**2)
517 real(RP), intent(out) :: vec_out_y(3,3,3)
518 real(RP), intent(out) :: vec_out_z(3,3,3)
519
520 integer :: i, j, k, jk
521 !----------------------------------------------------------
522
523 ! X-dir
524
525 do jk=1, 3**2
526 do i=1, 3
527 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
528 + mat(i,2) * vec_in_(2,jk) &
529 + mat(i,3) * vec_in_(3,jk)
530 end do
531 end do
532
533 ! Y-dir
534 do k=1, 3
535 do j=1, 3
536 do i=1, 3
537 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
538 + vec_in(i,2,k) * mat_tr(2,j) &
539 + vec_in(i,3,k) * mat_tr(3,j)
540 end do
541 end do
542 end do
543
544 ! Z-dir
545 do k=1, 3
546 do j=1, 3
547 do i=1, 3
548 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
549 + vec_in(i,j,2) * mat_tr(2,k) &
550 + vec_in(i,j,3) * mat_tr(3,k)
551 end do
552 end do
553 end do
554
555 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 563 of file scale_element_operation_tensorprod3D_kernel.F90.

566 implicit none
567 real(RP), intent(in) :: Mat(3,3)
568 real(RP), intent(in) :: Mat_tr(3,3)
569 real(RP), intent(in) :: vec_in_x(3,3**2)
570 real(RP), intent(in) :: vec_in_y(3,3,3)
571 real(RP), intent(in) :: vec_in_z(3,3,3)
572 real(RP), intent(out) :: vec_out_x(3,3**2)
573 real(RP), intent(out) :: vec_out_y(3,3**2)
574 real(RP), intent(out) :: vec_out_z(3,3**2)
575
576 integer :: i, j, k, jk
577 !----------------------------------------------------------
578
579 ! X-dir
580
581 do jk=1, 3**2
582 do i=1, 3
583 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
584 + mat(i,2) * vec_in_x(2,jk) &
585 + mat(i,3) * vec_in_x(3,jk)
586 end do
587 end do
588
589 ! Y-dir
590 do k=1, 3
591 do j=1, 3
592 jk = j + (k-1)*3
593 do i=1, 3
594 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
595 + vec_in_y(i,2,k) * mat_tr(2,j) &
596 + vec_in_y(i,3,k) * mat_tr(3,j)
597 end do
598 end do
599 end do
600
601 ! Z-dir
602 do k=1, 3
603 do j=1, 3
604 jk = j + (k-1)*3
605 do i=1, 3
606 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
607 + vec_in_z(i,j,2) * mat_tr(2,k) &
608 + vec_in_z(i,j,3) * mat_tr(3,k)
609 end do
610 end do
611 end do
612 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 618 of file scale_element_operation_tensorprod3D_kernel.F90.

620 implicit none
621 real(RP), intent(in) :: Mat_h1D(3,3)
622 real(RP), intent(in) :: Mat_h1D_tr(3,3)
623 real(RP), intent(in) :: Mat_v1D_tr(3,3)
624 real(RP), intent(in) :: vec_in(3,3,3)
625 real(RP), intent(out) :: vec_work(3,3,3)
626 real(RP), intent(out) :: vec_out(3,3,3)
627
628 integer :: i, j, k
629 !----------------------------------------------------------
630
631 ! X-dir
632
633 do k=1, 3
634 do j=1, 3
635 do i=1, 3
636 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
637 + mat_h1d(i,2) * vec_in(2,j,k) &
638 + mat_h1d(i,3) * vec_in(3,j,k)
639 end do
640 end do
641 end do
642
643 ! Y-dir
644 do k=1, 3
645 do j=1, 3
646 do i=1, 3
647 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
648 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
649 + vec_out(i,3,k) * mat_h1d_tr(3,j)
650 end do
651 end do
652 end do
653
654 ! Z-dir
655 do k=1, 3
656 do j=1, 3
657 do i=1, 3
658 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
659 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
660 + vec_work(i,j,3) * mat_v1d_tr(3,k)
661 end do
662 end do
663 end do
664
665 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 673 of file scale_element_operation_tensorprod3D_kernel.F90.

674 implicit none
675 real(RP), intent(in) :: Mat_x(4,4)
676 real(RP), intent(in) :: vec_in(4,4**2)
677 real(RP), intent(out) :: vec_out(4,4**2)
678
679 integer :: i, jk
680 !----------------------------------------------------------
681
682 do jk=1, 4**2
683 do i=1, 4
684 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
685 + mat_x(i,2) * vec_in(2,jk) &
686 + mat_x(i,3) * vec_in(3,jk) &
687 + mat_x(i,4) * vec_in(4,jk)
688 end do
689 end do
690
691 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 698 of file scale_element_operation_tensorprod3D_kernel.F90.

699 implicit none
700 real(RP), intent(in) :: Mat_y_tr(4,4)
701 real(RP), intent(in) :: vec_in(4,4,4)
702 real(RP), intent(out) :: vec_out(4,4,4)
703
704 integer :: i, j, k
705 !----------------------------------------------------------
706
707 do k=1, 4
708 do j=1, 4
709 do i=1, 4
710 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
711 + vec_in(i,2,k) * mat_y_tr(2,j) &
712 + vec_in(i,3,k) * mat_y_tr(3,j) &
713 + vec_in(i,4,k) * mat_y_tr(4,j)
714 end do
715 end do
716 end do
717
718 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 725 of file scale_element_operation_tensorprod3D_kernel.F90.

726 implicit none
727 real(RP), intent(in) :: Mat_z_tr(4,4)
728 real(RP), intent(in) :: vec_in(4,4,4)
729 real(RP), intent(out) :: vec_out(4,4,4)
730
731 integer :: i, j, k
732 !----------------------------------------------------------
733
734 do k=1, 4
735 do j=1, 4
736 do i=1, 4
737 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
738 + vec_in(i,j,2) * mat_z_tr(2,k) &
739 + vec_in(i,j,3) * mat_z_tr(3,k) &
740 + vec_in(i,j,4) * mat_z_tr(4,k)
741 end do
742 end do
743 end do
744
745 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 associated with Lift operations with hexahedral element of p=3.

Definition at line 751 of file scale_element_operation_tensorprod3D_kernel.F90.

752 implicit none
753 real(RP), intent(in) :: Lift(4,4,4,6)
754 real(RP), intent(in) :: vec_in(4,4,6)
755 real(RP), intent(out) :: vec_out(4,4,4)
756
757 integer :: i, j, k
758 !----------------------------------------------------------
759
760 do k=1, 4
761 do j=1, 4
762 do i=1, 4
763 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
764 + lift(i,j,k,2) * vec_in(j,k,2) &
765 + lift(i,j,k,3) * vec_in(i,k,3) &
766 + lift(i,j,k,4) * vec_in(j,k,4) &
767 + lift(i,j,k,5) * vec_in(i,j,5) &
768 + lift(i,j,k,6) * vec_in(i,j,6)
769 end do
770 end do
771 end do
772
773 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 781 of file scale_element_operation_tensorprod3D_kernel.F90.

783 implicit none
784 real(RP), intent(in) :: Mat(4,4)
785 real(RP), intent(in) :: Mat_tr(4,4)
786 real(RP), intent(in) :: vec_in_(4,4**2)
787 real(RP), intent(in) :: vec_in(4,4,4)
788 real(RP), intent(out) :: vec_out_x(4,4**2)
789 real(RP), intent(out) :: vec_out_y(4,4,4)
790 real(RP), intent(out) :: vec_out_z(4,4,4)
791
792 integer :: i, j, k, jk
793 !----------------------------------------------------------
794
795 ! X-dir
796
797 do jk=1, 4**2
798 do i=1, 4
799 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
800 + mat(i,2) * vec_in_(2,jk) &
801 + mat(i,3) * vec_in_(3,jk) &
802 + mat(i,4) * vec_in_(4,jk)
803 end do
804 end do
805
806 ! Y-dir
807 do k=1, 4
808 do j=1, 4
809 do i=1, 4
810 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
811 + vec_in(i,2,k) * mat_tr(2,j) &
812 + vec_in(i,3,k) * mat_tr(3,j) &
813 + vec_in(i,4,k) * mat_tr(4,j)
814 end do
815 end do
816 end do
817
818 ! Z-dir
819 do k=1, 4
820 do j=1, 4
821 do i=1, 4
822 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
823 + vec_in(i,j,2) * mat_tr(2,k) &
824 + vec_in(i,j,3) * mat_tr(3,k) &
825 + vec_in(i,j,4) * mat_tr(4,k)
826 end do
827 end do
828 end do
829
830 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 838 of file scale_element_operation_tensorprod3D_kernel.F90.

841 implicit none
842 real(RP), intent(in) :: Mat(4,4)
843 real(RP), intent(in) :: Mat_tr(4,4)
844 real(RP), intent(in) :: vec_in_x(4,4**2)
845 real(RP), intent(in) :: vec_in_y(4,4,4)
846 real(RP), intent(in) :: vec_in_z(4,4,4)
847 real(RP), intent(out) :: vec_out_x(4,4**2)
848 real(RP), intent(out) :: vec_out_y(4,4**2)
849 real(RP), intent(out) :: vec_out_z(4,4**2)
850
851 integer :: i, j, k, jk
852 !----------------------------------------------------------
853
854 ! X-dir
855
856 do jk=1, 4**2
857 do i=1, 4
858 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
859 + mat(i,2) * vec_in_x(2,jk) &
860 + mat(i,3) * vec_in_x(3,jk) &
861 + mat(i,4) * vec_in_x(4,jk)
862 end do
863 end do
864
865 ! Y-dir
866 do k=1, 4
867 do j=1, 4
868 jk = j + (k-1)*4
869 do i=1, 4
870 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
871 + vec_in_y(i,2,k) * mat_tr(2,j) &
872 + vec_in_y(i,3,k) * mat_tr(3,j) &
873 + vec_in_y(i,4,k) * mat_tr(4,j)
874 end do
875 end do
876 end do
877
878 ! Z-dir
879 do k=1, 4
880 do j=1, 4
881 jk = j + (k-1)*4
882 do i=1, 4
883 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
884 + vec_in_z(i,j,2) * mat_tr(2,k) &
885 + vec_in_z(i,j,3) * mat_tr(3,k) &
886 + vec_in_z(i,j,4) * mat_tr(4,k)
887 end do
888 end do
889 end do
890 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 896 of file scale_element_operation_tensorprod3D_kernel.F90.

898 implicit none
899 real(RP), intent(in) :: Mat_h1D(4,4)
900 real(RP), intent(in) :: Mat_h1D_tr(4,4)
901 real(RP), intent(in) :: Mat_v1D_tr(4,4)
902 real(RP), intent(in) :: vec_in(4,4,4)
903 real(RP), intent(out) :: vec_work(4,4,4)
904 real(RP), intent(out) :: vec_out(4,4,4)
905
906 integer :: i, j, k
907 !----------------------------------------------------------
908
909 ! X-dir
910
911 do k=1, 4
912 do j=1, 4
913 do i=1, 4
914 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
915 + mat_h1d(i,2) * vec_in(2,j,k) &
916 + mat_h1d(i,3) * vec_in(3,j,k) &
917 + mat_h1d(i,4) * vec_in(4,j,k)
918 end do
919 end do
920 end do
921
922 ! Y-dir
923 do k=1, 4
924 do j=1, 4
925 do i=1, 4
926 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
927 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
928 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
929 + vec_out(i,4,k) * mat_h1d_tr(4,j)
930 end do
931 end do
932 end do
933
934 ! Z-dir
935 do k=1, 4
936 do j=1, 4
937 do i=1, 4
938 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
939 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
940 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
941 + vec_work(i,j,4) * mat_v1d_tr(4,k)
942 end do
943 end do
944 end do
945
946 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 954 of file scale_element_operation_tensorprod3D_kernel.F90.

955 implicit none
956 real(RP), intent(in) :: Mat_x(5,5)
957 real(RP), intent(in) :: vec_in(5,5**2)
958 real(RP), intent(out) :: vec_out(5,5**2)
959
960 integer :: i, jk
961 !----------------------------------------------------------
962
963 do jk=1, 5**2
964 do i=1, 5
965 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
966 + mat_x(i,2) * vec_in(2,jk) &
967 + mat_x(i,3) * vec_in(3,jk) &
968 + mat_x(i,4) * vec_in(4,jk) &
969 + mat_x(i,5) * vec_in(5,jk)
970 end do
971 end do
972
973 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 980 of file scale_element_operation_tensorprod3D_kernel.F90.

981 implicit none
982 real(RP), intent(in) :: Mat_y_tr(5,5)
983 real(RP), intent(in) :: vec_in(5,5,5)
984 real(RP), intent(out) :: vec_out(5,5,5)
985
986 integer :: i, j, k
987 !----------------------------------------------------------
988
989 do k=1, 5
990 do j=1, 5
991 do i=1, 5
992 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
993 + vec_in(i,2,k) * mat_y_tr(2,j) &
994 + vec_in(i,3,k) * mat_y_tr(3,j) &
995 + vec_in(i,4,k) * mat_y_tr(4,j) &
996 + vec_in(i,5,k) * mat_y_tr(5,j)
997 end do
998 end do
999 end do
1000
1001 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 1008 of file scale_element_operation_tensorprod3D_kernel.F90.

1009 implicit none
1010 real(RP), intent(in) :: Mat_z_tr(5,5)
1011 real(RP), intent(in) :: vec_in(5,5,5)
1012 real(RP), intent(out) :: vec_out(5,5,5)
1013
1014 integer :: i, j, k
1015 !----------------------------------------------------------
1016
1017 do k=1, 5
1018 do j=1, 5
1019 do i=1, 5
1020 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1021 + vec_in(i,j,2) * mat_z_tr(2,k) &
1022 + vec_in(i,j,3) * mat_z_tr(3,k) &
1023 + vec_in(i,j,4) * mat_z_tr(4,k) &
1024 + vec_in(i,j,5) * mat_z_tr(5,k)
1025 end do
1026 end do
1027 end do
1028
1029 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 associated with Lift operations with hexahedral element of p=4.

Definition at line 1035 of file scale_element_operation_tensorprod3D_kernel.F90.

1036 implicit none
1037 real(RP), intent(in) :: Lift(5,5,5,6)
1038 real(RP), intent(in) :: vec_in(5,5,6)
1039 real(RP), intent(out) :: vec_out(5,5,5)
1040
1041 integer :: i, j, k
1042 !----------------------------------------------------------
1043
1044 do k=1, 5
1045 do j=1, 5
1046 do i=1, 5
1047 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1048 + lift(i,j,k,2) * vec_in(j,k,2) &
1049 + lift(i,j,k,3) * vec_in(i,k,3) &
1050 + lift(i,j,k,4) * vec_in(j,k,4) &
1051 + lift(i,j,k,5) * vec_in(i,j,5) &
1052 + lift(i,j,k,6) * vec_in(i,j,6)
1053 end do
1054 end do
1055 end do
1056
1057 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 1065 of file scale_element_operation_tensorprod3D_kernel.F90.

1067 implicit none
1068 real(RP), intent(in) :: Mat(5,5)
1069 real(RP), intent(in) :: Mat_tr(5,5)
1070 real(RP), intent(in) :: vec_in_(5,5**2)
1071 real(RP), intent(in) :: vec_in(5,5,5)
1072 real(RP), intent(out) :: vec_out_x(5,5**2)
1073 real(RP), intent(out) :: vec_out_y(5,5,5)
1074 real(RP), intent(out) :: vec_out_z(5,5,5)
1075
1076 integer :: i, j, k, jk
1077 !----------------------------------------------------------
1078
1079 ! X-dir
1080
1081 do jk=1, 5**2
1082 do i=1, 5
1083 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
1084 + mat(i,2) * vec_in_(2,jk) &
1085 + mat(i,3) * vec_in_(3,jk) &
1086 + mat(i,4) * vec_in_(4,jk) &
1087 + mat(i,5) * vec_in_(5,jk)
1088 end do
1089 end do
1090
1091 ! Y-dir
1092 do k=1, 5
1093 do j=1, 5
1094 do i=1, 5
1095 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1096 + vec_in(i,2,k) * mat_tr(2,j) &
1097 + vec_in(i,3,k) * mat_tr(3,j) &
1098 + vec_in(i,4,k) * mat_tr(4,j) &
1099 + vec_in(i,5,k) * mat_tr(5,j)
1100 end do
1101 end do
1102 end do
1103
1104 ! Z-dir
1105 do k=1, 5
1106 do j=1, 5
1107 do i=1, 5
1108 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1109 + vec_in(i,j,2) * mat_tr(2,k) &
1110 + vec_in(i,j,3) * mat_tr(3,k) &
1111 + vec_in(i,j,4) * mat_tr(4,k) &
1112 + vec_in(i,j,5) * mat_tr(5,k)
1113 end do
1114 end do
1115 end do
1116
1117 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 1125 of file scale_element_operation_tensorprod3D_kernel.F90.

1128 implicit none
1129 real(RP), intent(in) :: Mat(5,5)
1130 real(RP), intent(in) :: Mat_tr(5,5)
1131 real(RP), intent(in) :: vec_in_x(5,5**2)
1132 real(RP), intent(in) :: vec_in_y(5,5,5)
1133 real(RP), intent(in) :: vec_in_z(5,5,5)
1134 real(RP), intent(out) :: vec_out_x(5,5**2)
1135 real(RP), intent(out) :: vec_out_y(5,5**2)
1136 real(RP), intent(out) :: vec_out_z(5,5**2)
1137
1138 integer :: i, j, k, jk
1139 !----------------------------------------------------------
1140
1141 ! X-dir
1142
1143 do jk=1, 5**2
1144 do i=1, 5
1145 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
1146 + mat(i,2) * vec_in_x(2,jk) &
1147 + mat(i,3) * vec_in_x(3,jk) &
1148 + mat(i,4) * vec_in_x(4,jk) &
1149 + mat(i,5) * vec_in_x(5,jk)
1150 end do
1151 end do
1152
1153 ! Y-dir
1154 do k=1, 5
1155 do j=1, 5
1156 jk = j + (k-1)*5
1157 do i=1, 5
1158 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
1159 + vec_in_y(i,2,k) * mat_tr(2,j) &
1160 + vec_in_y(i,3,k) * mat_tr(3,j) &
1161 + vec_in_y(i,4,k) * mat_tr(4,j) &
1162 + vec_in_y(i,5,k) * mat_tr(5,j)
1163 end do
1164 end do
1165 end do
1166
1167 ! Z-dir
1168 do k=1, 5
1169 do j=1, 5
1170 jk = j + (k-1)*5
1171 do i=1, 5
1172 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
1173 + vec_in_z(i,j,2) * mat_tr(2,k) &
1174 + vec_in_z(i,j,3) * mat_tr(3,k) &
1175 + vec_in_z(i,j,4) * mat_tr(4,k) &
1176 + vec_in_z(i,j,5) * mat_tr(5,k)
1177 end do
1178 end do
1179 end do
1180 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 1186 of file scale_element_operation_tensorprod3D_kernel.F90.

1188 implicit none
1189 real(RP), intent(in) :: Mat_h1D(5,5)
1190 real(RP), intent(in) :: Mat_h1D_tr(5,5)
1191 real(RP), intent(in) :: Mat_v1D_tr(5,5)
1192 real(RP), intent(in) :: vec_in(5,5,5)
1193 real(RP), intent(out) :: vec_work(5,5,5)
1194 real(RP), intent(out) :: vec_out(5,5,5)
1195
1196 integer :: i, j, k
1197 !----------------------------------------------------------
1198
1199 ! X-dir
1200
1201 do k=1, 5
1202 do j=1, 5
1203 do i=1, 5
1204 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
1205 + mat_h1d(i,2) * vec_in(2,j,k) &
1206 + mat_h1d(i,3) * vec_in(3,j,k) &
1207 + mat_h1d(i,4) * vec_in(4,j,k) &
1208 + mat_h1d(i,5) * vec_in(5,j,k)
1209 end do
1210 end do
1211 end do
1212
1213 ! Y-dir
1214 do k=1, 5
1215 do j=1, 5
1216 do i=1, 5
1217 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
1218 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
1219 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
1220 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
1221 + vec_out(i,5,k) * mat_h1d_tr(5,j)
1222 end do
1223 end do
1224 end do
1225
1226 ! Z-dir
1227 do k=1, 5
1228 do j=1, 5
1229 do i=1, 5
1230 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
1231 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
1232 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
1233 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
1234 + vec_work(i,j,5) * mat_v1d_tr(5,k)
1235 end do
1236 end do
1237 end do
1238
1239 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 1247 of file scale_element_operation_tensorprod3D_kernel.F90.

1248 implicit none
1249 real(RP), intent(in) :: Mat_x(6,6)
1250 real(RP), intent(in) :: vec_in(6,6**2)
1251 real(RP), intent(out) :: vec_out(6,6**2)
1252
1253 integer :: i, jk
1254 !----------------------------------------------------------
1255
1256 do jk=1, 6**2
1257 do i=1, 6
1258 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
1259 + mat_x(i,2) * vec_in(2,jk) &
1260 + mat_x(i,3) * vec_in(3,jk) &
1261 + mat_x(i,4) * vec_in(4,jk) &
1262 + mat_x(i,5) * vec_in(5,jk) &
1263 + mat_x(i,6) * vec_in(6,jk)
1264 end do
1265 end do
1266
1267 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 1274 of file scale_element_operation_tensorprod3D_kernel.F90.

1275 implicit none
1276 real(RP), intent(in) :: Mat_y_tr(6,6)
1277 real(RP), intent(in) :: vec_in(6,6,6)
1278 real(RP), intent(out) :: vec_out(6,6,6)
1279
1280 integer :: i, j, k
1281 !----------------------------------------------------------
1282
1283 do k=1, 6
1284 do j=1, 6
1285 do i=1, 6
1286 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
1287 + vec_in(i,2,k) * mat_y_tr(2,j) &
1288 + vec_in(i,3,k) * mat_y_tr(3,j) &
1289 + vec_in(i,4,k) * mat_y_tr(4,j) &
1290 + vec_in(i,5,k) * mat_y_tr(5,j) &
1291 + vec_in(i,6,k) * mat_y_tr(6,j)
1292 end do
1293 end do
1294 end do
1295
1296 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 1303 of file scale_element_operation_tensorprod3D_kernel.F90.

1304 implicit none
1305 real(RP), intent(in) :: Mat_z_tr(6,6)
1306 real(RP), intent(in) :: vec_in(6,6,6)
1307 real(RP), intent(out) :: vec_out(6,6,6)
1308
1309 integer :: i, j, k
1310 !----------------------------------------------------------
1311
1312 do k=1, 6
1313 do j=1, 6
1314 do i=1, 6
1315 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1316 + vec_in(i,j,2) * mat_z_tr(2,k) &
1317 + vec_in(i,j,3) * mat_z_tr(3,k) &
1318 + vec_in(i,j,4) * mat_z_tr(4,k) &
1319 + vec_in(i,j,5) * mat_z_tr(5,k) &
1320 + vec_in(i,j,6) * mat_z_tr(6,k)
1321 end do
1322 end do
1323 end do
1324
1325 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 associated with Lift operations with hexahedral element of p=5.

Definition at line 1331 of file scale_element_operation_tensorprod3D_kernel.F90.

1332 implicit none
1333 real(RP), intent(in) :: Lift(6,6,6,6)
1334 real(RP), intent(in) :: vec_in(6,6,6)
1335 real(RP), intent(out) :: vec_out(6,6,6)
1336
1337 integer :: i, j, k
1338 !----------------------------------------------------------
1339
1340 do k=1, 6
1341 do j=1, 6
1342 do i=1, 6
1343 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1344 + lift(i,j,k,2) * vec_in(j,k,2) &
1345 + lift(i,j,k,3) * vec_in(i,k,3) &
1346 + lift(i,j,k,4) * vec_in(j,k,4) &
1347 + lift(i,j,k,5) * vec_in(i,j,5) &
1348 + lift(i,j,k,6) * vec_in(i,j,6)
1349 end do
1350 end do
1351 end do
1352
1353 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 1361 of file scale_element_operation_tensorprod3D_kernel.F90.

1363 implicit none
1364 real(RP), intent(in) :: Mat(6,6)
1365 real(RP), intent(in) :: Mat_tr(6,6)
1366 real(RP), intent(in) :: vec_in_(6,6**2)
1367 real(RP), intent(in) :: vec_in(6,6,6)
1368 real(RP), intent(out) :: vec_out_x(6,6**2)
1369 real(RP), intent(out) :: vec_out_y(6,6,6)
1370 real(RP), intent(out) :: vec_out_z(6,6,6)
1371
1372 integer :: i, j, k, jk
1373 !----------------------------------------------------------
1374
1375 ! X-dir
1376
1377 do jk=1, 6**2
1378 do i=1, 6
1379 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
1380 + mat(i,2) * vec_in_(2,jk) &
1381 + mat(i,3) * vec_in_(3,jk) &
1382 + mat(i,4) * vec_in_(4,jk) &
1383 + mat(i,5) * vec_in_(5,jk) &
1384 + mat(i,6) * vec_in_(6,jk)
1385 end do
1386 end do
1387
1388 ! Y-dir
1389 do k=1, 6
1390 do j=1, 6
1391 do i=1, 6
1392 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1393 + vec_in(i,2,k) * mat_tr(2,j) &
1394 + vec_in(i,3,k) * mat_tr(3,j) &
1395 + vec_in(i,4,k) * mat_tr(4,j) &
1396 + vec_in(i,5,k) * mat_tr(5,j) &
1397 + vec_in(i,6,k) * mat_tr(6,j)
1398 end do
1399 end do
1400 end do
1401
1402 ! Z-dir
1403 do k=1, 6
1404 do j=1, 6
1405 do i=1, 6
1406 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1407 + vec_in(i,j,2) * mat_tr(2,k) &
1408 + vec_in(i,j,3) * mat_tr(3,k) &
1409 + vec_in(i,j,4) * mat_tr(4,k) &
1410 + vec_in(i,j,5) * mat_tr(5,k) &
1411 + vec_in(i,j,6) * mat_tr(6,k)
1412 end do
1413 end do
1414 end do
1415
1416 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 1424 of file scale_element_operation_tensorprod3D_kernel.F90.

1427 implicit none
1428 real(RP), intent(in) :: Mat(6,6)
1429 real(RP), intent(in) :: Mat_tr(6,6)
1430 real(RP), intent(in) :: vec_in_x(6,6**2)
1431 real(RP), intent(in) :: vec_in_y(6,6,6)
1432 real(RP), intent(in) :: vec_in_z(6,6,6)
1433 real(RP), intent(out) :: vec_out_x(6,6**2)
1434 real(RP), intent(out) :: vec_out_y(6,6**2)
1435 real(RP), intent(out) :: vec_out_z(6,6**2)
1436
1437 integer :: i, j, k, jk
1438 !----------------------------------------------------------
1439
1440 ! X-dir
1441
1442 do jk=1, 6**2
1443 do i=1, 6
1444 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
1445 + mat(i,2) * vec_in_x(2,jk) &
1446 + mat(i,3) * vec_in_x(3,jk) &
1447 + mat(i,4) * vec_in_x(4,jk) &
1448 + mat(i,5) * vec_in_x(5,jk) &
1449 + mat(i,6) * vec_in_x(6,jk)
1450 end do
1451 end do
1452
1453 ! Y-dir
1454 do k=1, 6
1455 do j=1, 6
1456 jk = j + (k-1)*6
1457 do i=1, 6
1458 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
1459 + vec_in_y(i,2,k) * mat_tr(2,j) &
1460 + vec_in_y(i,3,k) * mat_tr(3,j) &
1461 + vec_in_y(i,4,k) * mat_tr(4,j) &
1462 + vec_in_y(i,5,k) * mat_tr(5,j) &
1463 + vec_in_y(i,6,k) * mat_tr(6,j)
1464 end do
1465 end do
1466 end do
1467
1468 ! Z-dir
1469 do k=1, 6
1470 do j=1, 6
1471 jk = j + (k-1)*6
1472 do i=1, 6
1473 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
1474 + vec_in_z(i,j,2) * mat_tr(2,k) &
1475 + vec_in_z(i,j,3) * mat_tr(3,k) &
1476 + vec_in_z(i,j,4) * mat_tr(4,k) &
1477 + vec_in_z(i,j,5) * mat_tr(5,k) &
1478 + vec_in_z(i,j,6) * mat_tr(6,k)
1479 end do
1480 end do
1481 end do
1482 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 1488 of file scale_element_operation_tensorprod3D_kernel.F90.

1490 implicit none
1491 real(RP), intent(in) :: Mat_h1D(6,6)
1492 real(RP), intent(in) :: Mat_h1D_tr(6,6)
1493 real(RP), intent(in) :: Mat_v1D_tr(6,6)
1494 real(RP), intent(in) :: vec_in(6,6,6)
1495 real(RP), intent(out) :: vec_work(6,6,6)
1496 real(RP), intent(out) :: vec_out(6,6,6)
1497
1498 integer :: i, j, k
1499 !----------------------------------------------------------
1500
1501 ! X-dir
1502
1503 do k=1, 6
1504 do j=1, 6
1505 do i=1, 6
1506 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
1507 + mat_h1d(i,2) * vec_in(2,j,k) &
1508 + mat_h1d(i,3) * vec_in(3,j,k) &
1509 + mat_h1d(i,4) * vec_in(4,j,k) &
1510 + mat_h1d(i,5) * vec_in(5,j,k) &
1511 + mat_h1d(i,6) * vec_in(6,j,k)
1512 end do
1513 end do
1514 end do
1515
1516 ! Y-dir
1517 do k=1, 6
1518 do j=1, 6
1519 do i=1, 6
1520 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
1521 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
1522 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
1523 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
1524 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
1525 + vec_out(i,6,k) * mat_h1d_tr(6,j)
1526 end do
1527 end do
1528 end do
1529
1530 ! Z-dir
1531 do k=1, 6
1532 do j=1, 6
1533 do i=1, 6
1534 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
1535 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
1536 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
1537 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
1538 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
1539 + vec_work(i,j,6) * mat_v1d_tr(6,k)
1540 end do
1541 end do
1542 end do
1543
1544 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 1552 of file scale_element_operation_tensorprod3D_kernel.F90.

1553 implicit none
1554 real(RP), intent(in) :: Mat_x(7,7)
1555 real(RP), intent(in) :: vec_in(7,7**2)
1556 real(RP), intent(out) :: vec_out(7,7**2)
1557
1558 integer :: i, jk
1559 !----------------------------------------------------------
1560
1561 do jk=1, 7**2
1562 do i=1, 7
1563 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
1564 + mat_x(i,2) * vec_in(2,jk) &
1565 + mat_x(i,3) * vec_in(3,jk) &
1566 + mat_x(i,4) * vec_in(4,jk) &
1567 + mat_x(i,5) * vec_in(5,jk) &
1568 + mat_x(i,6) * vec_in(6,jk) &
1569 + mat_x(i,7) * vec_in(7,jk)
1570 end do
1571 end do
1572
1573 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 1580 of file scale_element_operation_tensorprod3D_kernel.F90.

1581 implicit none
1582 real(RP), intent(in) :: Mat_y_tr(7,7)
1583 real(RP), intent(in) :: vec_in(7,7,7)
1584 real(RP), intent(out) :: vec_out(7,7,7)
1585
1586 integer :: i, j, k
1587 !----------------------------------------------------------
1588
1589 do k=1, 7
1590 do j=1, 7
1591 do i=1, 7
1592 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
1593 + vec_in(i,2,k) * mat_y_tr(2,j) &
1594 + vec_in(i,3,k) * mat_y_tr(3,j) &
1595 + vec_in(i,4,k) * mat_y_tr(4,j) &
1596 + vec_in(i,5,k) * mat_y_tr(5,j) &
1597 + vec_in(i,6,k) * mat_y_tr(6,j) &
1598 + vec_in(i,7,k) * mat_y_tr(7,j)
1599 end do
1600 end do
1601 end do
1602
1603 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 1610 of file scale_element_operation_tensorprod3D_kernel.F90.

1611 implicit none
1612 real(RP), intent(in) :: Mat_z_tr(7,7)
1613 real(RP), intent(in) :: vec_in(7,7,7)
1614 real(RP), intent(out) :: vec_out(7,7,7)
1615
1616 integer :: i, j, k
1617 !----------------------------------------------------------
1618
1619 do k=1, 7
1620 do j=1, 7
1621 do i=1, 7
1622 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1623 + vec_in(i,j,2) * mat_z_tr(2,k) &
1624 + vec_in(i,j,3) * mat_z_tr(3,k) &
1625 + vec_in(i,j,4) * mat_z_tr(4,k) &
1626 + vec_in(i,j,5) * mat_z_tr(5,k) &
1627 + vec_in(i,j,6) * mat_z_tr(6,k) &
1628 + vec_in(i,j,7) * mat_z_tr(7,k)
1629 end do
1630 end do
1631 end do
1632
1633 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 associated with Lift operations with hexahedral element of p=6.

Definition at line 1639 of file scale_element_operation_tensorprod3D_kernel.F90.

1640 implicit none
1641 real(RP), intent(in) :: Lift(7,7,7,6)
1642 real(RP), intent(in) :: vec_in(7,7,6)
1643 real(RP), intent(out) :: vec_out(7,7,7)
1644
1645 integer :: i, j, k
1646 !----------------------------------------------------------
1647
1648 do k=1, 7
1649 do j=1, 7
1650 do i=1, 7
1651 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1652 + lift(i,j,k,2) * vec_in(j,k,2) &
1653 + lift(i,j,k,3) * vec_in(i,k,3) &
1654 + lift(i,j,k,4) * vec_in(j,k,4) &
1655 + lift(i,j,k,5) * vec_in(i,j,5) &
1656 + lift(i,j,k,6) * vec_in(i,j,6)
1657 end do
1658 end do
1659 end do
1660
1661 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 1669 of file scale_element_operation_tensorprod3D_kernel.F90.

1671 implicit none
1672 real(RP), intent(in) :: Mat(7,7)
1673 real(RP), intent(in) :: Mat_tr(7,7)
1674 real(RP), intent(in) :: vec_in_(7,7**2)
1675 real(RP), intent(in) :: vec_in(7,7,7)
1676 real(RP), intent(out) :: vec_out_x(7,7**2)
1677 real(RP), intent(out) :: vec_out_y(7,7,7)
1678 real(RP), intent(out) :: vec_out_z(7,7,7)
1679
1680 integer :: i, j, k, jk
1681 !----------------------------------------------------------
1682
1683 ! X-dir
1684
1685 do jk=1, 7**2
1686 do i=1, 7
1687 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
1688 + mat(i,2) * vec_in_(2,jk) &
1689 + mat(i,3) * vec_in_(3,jk) &
1690 + mat(i,4) * vec_in_(4,jk) &
1691 + mat(i,5) * vec_in_(5,jk) &
1692 + mat(i,6) * vec_in_(6,jk) &
1693 + mat(i,7) * vec_in_(7,jk)
1694 end do
1695 end do
1696
1697 ! Y-dir
1698 do k=1, 7
1699 do j=1, 7
1700 do i=1, 7
1701 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1702 + vec_in(i,2,k) * mat_tr(2,j) &
1703 + vec_in(i,3,k) * mat_tr(3,j) &
1704 + vec_in(i,4,k) * mat_tr(4,j) &
1705 + vec_in(i,5,k) * mat_tr(5,j) &
1706 + vec_in(i,6,k) * mat_tr(6,j) &
1707 + vec_in(i,7,k) * mat_tr(7,j)
1708 end do
1709 end do
1710 end do
1711
1712 ! Z-dir
1713 do k=1, 7
1714 do j=1, 7
1715 do i=1, 7
1716 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
1717 + vec_in(i,j,2) * mat_tr(2,k) &
1718 + vec_in(i,j,3) * mat_tr(3,k) &
1719 + vec_in(i,j,4) * mat_tr(4,k) &
1720 + vec_in(i,j,5) * mat_tr(5,k) &
1721 + vec_in(i,j,6) * mat_tr(6,k) &
1722 + vec_in(i,j,7) * mat_tr(7,k)
1723 end do
1724 end do
1725 end do
1726
1727 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 1735 of file scale_element_operation_tensorprod3D_kernel.F90.

1738 implicit none
1739 real(RP), intent(in) :: Mat(7,7)
1740 real(RP), intent(in) :: Mat_tr(7,7)
1741 real(RP), intent(in) :: vec_in_x(7,7**2)
1742 real(RP), intent(in) :: vec_in_y(7,7,7)
1743 real(RP), intent(in) :: vec_in_z(7,7,7)
1744 real(RP), intent(out) :: vec_out_x(7,7**2)
1745 real(RP), intent(out) :: vec_out_y(7,7**2)
1746 real(RP), intent(out) :: vec_out_z(7,7**2)
1747
1748 integer :: i, j, k, jk
1749 !----------------------------------------------------------
1750
1751 ! X-dir
1752
1753 do jk=1, 7**2
1754 do i=1, 7
1755 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
1756 + mat(i,2) * vec_in_x(2,jk) &
1757 + mat(i,3) * vec_in_x(3,jk) &
1758 + mat(i,4) * vec_in_x(4,jk) &
1759 + mat(i,5) * vec_in_x(5,jk) &
1760 + mat(i,6) * vec_in_x(6,jk) &
1761 + mat(i,7) * vec_in_x(7,jk)
1762 end do
1763 end do
1764
1765 ! Y-dir
1766 do k=1, 7
1767 do j=1, 7
1768 jk = j + (k-1)*7
1769 do i=1, 7
1770 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
1771 + vec_in_y(i,2,k) * mat_tr(2,j) &
1772 + vec_in_y(i,3,k) * mat_tr(3,j) &
1773 + vec_in_y(i,4,k) * mat_tr(4,j) &
1774 + vec_in_y(i,5,k) * mat_tr(5,j) &
1775 + vec_in_y(i,6,k) * mat_tr(6,j) &
1776 + vec_in_y(i,7,k) * mat_tr(7,j)
1777 end do
1778 end do
1779 end do
1780
1781 ! Z-dir
1782 do k=1, 7
1783 do j=1, 7
1784 jk = j + (k-1)*7
1785 do i=1, 7
1786 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
1787 + vec_in_z(i,j,2) * mat_tr(2,k) &
1788 + vec_in_z(i,j,3) * mat_tr(3,k) &
1789 + vec_in_z(i,j,4) * mat_tr(4,k) &
1790 + vec_in_z(i,j,5) * mat_tr(5,k) &
1791 + vec_in_z(i,j,6) * mat_tr(6,k) &
1792 + vec_in_z(i,j,7) * mat_tr(7,k)
1793 end do
1794 end do
1795 end do
1796 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 1802 of file scale_element_operation_tensorprod3D_kernel.F90.

1804 implicit none
1805 real(RP), intent(in) :: Mat_h1D(7,7)
1806 real(RP), intent(in) :: Mat_h1D_tr(7,7)
1807 real(RP), intent(in) :: Mat_v1D_tr(7,7)
1808 real(RP), intent(in) :: vec_in(7,7,7)
1809 real(RP), intent(out) :: vec_work(7,7,7)
1810 real(RP), intent(out) :: vec_out(7,7,7)
1811
1812 integer :: i, j, k
1813 !----------------------------------------------------------
1814
1815 ! X-dir
1816
1817 do k=1, 7
1818 do j=1, 7
1819 do i=1, 7
1820 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
1821 + mat_h1d(i,2) * vec_in(2,j,k) &
1822 + mat_h1d(i,3) * vec_in(3,j,k) &
1823 + mat_h1d(i,4) * vec_in(4,j,k) &
1824 + mat_h1d(i,5) * vec_in(5,j,k) &
1825 + mat_h1d(i,6) * vec_in(6,j,k) &
1826 + mat_h1d(i,7) * vec_in(7,j,k)
1827 end do
1828 end do
1829 end do
1830
1831 ! Y-dir
1832 do k=1, 7
1833 do j=1, 7
1834 do i=1, 7
1835 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
1836 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
1837 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
1838 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
1839 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
1840 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
1841 + vec_out(i,7,k) * mat_h1d_tr(7,j)
1842 end do
1843 end do
1844 end do
1845
1846 ! Z-dir
1847 do k=1, 7
1848 do j=1, 7
1849 do i=1, 7
1850 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
1851 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
1852 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
1853 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
1854 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
1855 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
1856 + vec_work(i,j,7) * mat_v1d_tr(7,k)
1857 end do
1858 end do
1859 end do
1860
1861 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 1869 of file scale_element_operation_tensorprod3D_kernel.F90.

1870 implicit none
1871 real(RP), intent(in) :: Mat_x(8,8)
1872 real(RP), intent(in) :: vec_in(8,8**2)
1873 real(RP), intent(out) :: vec_out(8,8**2)
1874
1875 integer :: i, jk
1876 !----------------------------------------------------------
1877
1878 do jk=1, 8**2
1879 do i=1, 8
1880 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
1881 + mat_x(i,2) * vec_in(2,jk) &
1882 + mat_x(i,3) * vec_in(3,jk) &
1883 + mat_x(i,4) * vec_in(4,jk) &
1884 + mat_x(i,5) * vec_in(5,jk) &
1885 + mat_x(i,6) * vec_in(6,jk) &
1886 + mat_x(i,7) * vec_in(7,jk) &
1887 + mat_x(i,8) * vec_in(8,jk)
1888 end do
1889 end do
1890
1891 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 1898 of file scale_element_operation_tensorprod3D_kernel.F90.

1899 implicit none
1900 real(RP), intent(in) :: Mat_y_tr(8,8)
1901 real(RP), intent(in) :: vec_in(8,8,8)
1902 real(RP), intent(out) :: vec_out(8,8,8)
1903
1904 integer :: i, j, k
1905 !----------------------------------------------------------
1906
1907 do k=1, 8
1908 do j=1, 8
1909 do i=1, 8
1910 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
1911 + vec_in(i,2,k) * mat_y_tr(2,j) &
1912 + vec_in(i,3,k) * mat_y_tr(3,j) &
1913 + vec_in(i,4,k) * mat_y_tr(4,j) &
1914 + vec_in(i,5,k) * mat_y_tr(5,j) &
1915 + vec_in(i,6,k) * mat_y_tr(6,j) &
1916 + vec_in(i,7,k) * mat_y_tr(7,j) &
1917 + vec_in(i,8,k) * mat_y_tr(8,j)
1918 end do
1919 end do
1920 end do
1921
1922 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 1929 of file scale_element_operation_tensorprod3D_kernel.F90.

1930 implicit none
1931 real(RP), intent(in) :: Mat_z_tr(8,8)
1932 real(RP), intent(in) :: vec_in(8,8,8)
1933 real(RP), intent(out) :: vec_out(8,8,8)
1934
1935 integer :: i, j, k
1936 !----------------------------------------------------------
1937
1938 do k=1, 8
1939 do j=1, 8
1940 do i=1, 8
1941 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
1942 + vec_in(i,j,2) * mat_z_tr(2,k) &
1943 + vec_in(i,j,3) * mat_z_tr(3,k) &
1944 + vec_in(i,j,4) * mat_z_tr(4,k) &
1945 + vec_in(i,j,5) * mat_z_tr(5,k) &
1946 + vec_in(i,j,6) * mat_z_tr(6,k) &
1947 + vec_in(i,j,7) * mat_z_tr(7,k) &
1948 + vec_in(i,j,8) * mat_z_tr(8,k)
1949 end do
1950 end do
1951 end do
1952
1953 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 associated with Lift operations with hexahedral element of p=7.

Definition at line 1959 of file scale_element_operation_tensorprod3D_kernel.F90.

1960 implicit none
1961 real(RP), intent(in) :: Lift(8,8,8,6)
1962 real(RP), intent(in) :: vec_in(8,8,6)
1963 real(RP), intent(out) :: vec_out(8,8,8)
1964
1965 integer :: i, j, k
1966 !----------------------------------------------------------
1967
1968 do k=1, 8
1969 do j=1, 8
1970 do i=1, 8
1971 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
1972 + lift(i,j,k,2) * vec_in(j,k,2) &
1973 + lift(i,j,k,3) * vec_in(i,k,3) &
1974 + lift(i,j,k,4) * vec_in(j,k,4) &
1975 + lift(i,j,k,5) * vec_in(i,j,5) &
1976 + lift(i,j,k,6) * vec_in(i,j,6)
1977 end do
1978 end do
1979 end do
1980
1981 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 1989 of file scale_element_operation_tensorprod3D_kernel.F90.

1991 implicit none
1992 real(RP), intent(in) :: Mat(8,8)
1993 real(RP), intent(in) :: Mat_tr(8,8)
1994 real(RP), intent(in) :: vec_in_(8,8**2)
1995 real(RP), intent(in) :: vec_in(8,8,8)
1996 real(RP), intent(out) :: vec_out_x(8,8**2)
1997 real(RP), intent(out) :: vec_out_y(8,8,8)
1998 real(RP), intent(out) :: vec_out_z(8,8,8)
1999
2000 integer :: i, j, k, jk
2001 !----------------------------------------------------------
2002
2003 ! X-dir
2004
2005 do jk=1, 8**2
2006 do i=1, 8
2007 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
2008 + mat(i,2) * vec_in_(2,jk) &
2009 + mat(i,3) * vec_in_(3,jk) &
2010 + mat(i,4) * vec_in_(4,jk) &
2011 + mat(i,5) * vec_in_(5,jk) &
2012 + mat(i,6) * vec_in_(6,jk) &
2013 + mat(i,7) * vec_in_(7,jk) &
2014 + mat(i,8) * vec_in_(8,jk)
2015 end do
2016 end do
2017
2018 ! Y-dir
2019 do k=1, 8
2020 do j=1, 8
2021 do i=1, 8
2022 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2023 + vec_in(i,2,k) * mat_tr(2,j) &
2024 + vec_in(i,3,k) * mat_tr(3,j) &
2025 + vec_in(i,4,k) * mat_tr(4,j) &
2026 + vec_in(i,5,k) * mat_tr(5,j) &
2027 + vec_in(i,6,k) * mat_tr(6,j) &
2028 + vec_in(i,7,k) * mat_tr(7,j) &
2029 + vec_in(i,8,k) * mat_tr(8,j)
2030 end do
2031 end do
2032 end do
2033
2034 ! Z-dir
2035 do k=1, 8
2036 do j=1, 8
2037 do i=1, 8
2038 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2039 + vec_in(i,j,2) * mat_tr(2,k) &
2040 + vec_in(i,j,3) * mat_tr(3,k) &
2041 + vec_in(i,j,4) * mat_tr(4,k) &
2042 + vec_in(i,j,5) * mat_tr(5,k) &
2043 + vec_in(i,j,6) * mat_tr(6,k) &
2044 + vec_in(i,j,7) * mat_tr(7,k) &
2045 + vec_in(i,j,8) * mat_tr(8,k)
2046 end do
2047 end do
2048 end do
2049
2050 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 2058 of file scale_element_operation_tensorprod3D_kernel.F90.

2061 implicit none
2062 real(RP), intent(in) :: Mat(8,8)
2063 real(RP), intent(in) :: Mat_tr(8,8)
2064 real(RP), intent(in) :: vec_in_x(8,8**2)
2065 real(RP), intent(in) :: vec_in_y(8,8,8)
2066 real(RP), intent(in) :: vec_in_z(8,8,8)
2067 real(RP), intent(out) :: vec_out_x(8,8**2)
2068 real(RP), intent(out) :: vec_out_y(8,8**2)
2069 real(RP), intent(out) :: vec_out_z(8,8**2)
2070
2071 integer :: i, j, k, jk
2072 !----------------------------------------------------------
2073
2074 ! X-dir
2075
2076 do jk=1, 8**2
2077 do i=1, 8
2078 vec_out_x(i,jk) = mat(i,1) * vec_in_x(1,jk) &
2079 + mat(i,2) * vec_in_x(2,jk) &
2080 + mat(i,3) * vec_in_x(3,jk) &
2081 + mat(i,4) * vec_in_x(4,jk) &
2082 + mat(i,5) * vec_in_x(5,jk) &
2083 + mat(i,6) * vec_in_x(6,jk) &
2084 + mat(i,7) * vec_in_x(7,jk) &
2085 + mat(i,8) * vec_in_x(8,jk)
2086 end do
2087 end do
2088
2089 ! Y-dir
2090 do k=1, 8
2091 do j=1, 8
2092 jk = j + (k-1)*8
2093 do i=1, 8
2094 vec_out_y(i,jk) = vec_in_y(i,1,k) * mat_tr(1,j) &
2095 + vec_in_y(i,2,k) * mat_tr(2,j) &
2096 + vec_in_y(i,3,k) * mat_tr(3,j) &
2097 + vec_in_y(i,4,k) * mat_tr(4,j) &
2098 + vec_in_y(i,5,k) * mat_tr(5,j) &
2099 + vec_in_y(i,6,k) * mat_tr(6,j) &
2100 + vec_in_y(i,7,k) * mat_tr(7,j) &
2101 + vec_in_y(i,8,k) * mat_tr(8,j)
2102 end do
2103 end do
2104 end do
2105
2106 ! Z-dir
2107 do k=1, 8
2108 do j=1, 8
2109 jk = j + (k-1)*8
2110 do i=1, 8
2111 vec_out_z(i,jk) = vec_in_z(i,j,1) * mat_tr(1,k) &
2112 + vec_in_z(i,j,2) * mat_tr(2,k) &
2113 + vec_in_z(i,j,3) * mat_tr(3,k) &
2114 + vec_in_z(i,j,4) * mat_tr(4,k) &
2115 + vec_in_z(i,j,5) * mat_tr(5,k) &
2116 + vec_in_z(i,j,6) * mat_tr(6,k) &
2117 + vec_in_z(i,j,7) * mat_tr(7,k) &
2118 + vec_in_z(i,j,8) * mat_tr(8,k)
2119 end do
2120 end do
2121 end do
2122 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 2128 of file scale_element_operation_tensorprod3D_kernel.F90.

2130 implicit none
2131 real(RP), intent(in) :: Mat_h1D(8,8)
2132 real(RP), intent(in) :: Mat_h1D_tr(8,8)
2133 real(RP), intent(in) :: Mat_v1D_tr(8,8)
2134 real(RP), intent(in) :: vec_in(8,8,8)
2135 real(RP), intent(out) :: vec_work(8,8,8)
2136 real(RP), intent(out) :: vec_out(8,8,8)
2137
2138 integer :: i, j, k
2139 !----------------------------------------------------------
2140
2141 ! X-dir
2142
2143 do k=1, 8
2144 do j=1, 8
2145 do i=1, 8
2146 vec_out(i,j,k) = mat_h1d(i,1) * vec_in(1,j,k) &
2147 + mat_h1d(i,2) * vec_in(2,j,k) &
2148 + mat_h1d(i,3) * vec_in(3,j,k) &
2149 + mat_h1d(i,4) * vec_in(4,j,k) &
2150 + mat_h1d(i,5) * vec_in(5,j,k) &
2151 + mat_h1d(i,6) * vec_in(6,j,k) &
2152 + mat_h1d(i,7) * vec_in(7,j,k) &
2153 + mat_h1d(i,8) * vec_in(8,j,k)
2154 end do
2155 end do
2156 end do
2157
2158 ! Y-dir
2159 do k=1, 8
2160 do j=1, 8
2161 do i=1, 8
2162 vec_work(i,j,k) = vec_out(i,1,k) * mat_h1d_tr(1,j) &
2163 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
2164 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
2165 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
2166 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
2167 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
2168 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
2169 + vec_out(i,8,k) * mat_h1d_tr(8,j)
2170 end do
2171 end do
2172 end do
2173
2174 ! Z-dir
2175 do k=1, 8
2176 do j=1, 8
2177 do i=1, 8
2178 vec_out(i,j,k) = vec_work(i,j,1) * mat_v1d_tr(1,k) &
2179 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
2180 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
2181 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
2182 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
2183 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
2184 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
2185 + vec_work(i,j,8) * mat_v1d_tr(8,k)
2186 end do
2187 end do
2188 end do
2189
2190 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 2198 of file scale_element_operation_tensorprod3D_kernel.F90.

2199 implicit none
2200 real(RP), intent(in) :: Mat_x(9,9)
2201 real(RP), intent(in) :: vec_in(9,9**2)
2202 real(RP), intent(out) :: vec_out(9,9**2)
2203
2204 integer :: i, jk
2205 !----------------------------------------------------------
2206
2207 do jk=1, 9**2
2208 do i=1, 9
2209 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
2210 + mat_x(i,2) * vec_in(2,jk) &
2211 + mat_x(i,3) * vec_in(3,jk) &
2212 + mat_x(i,4) * vec_in(4,jk) &
2213 + mat_x(i,5) * vec_in(5,jk) &
2214 + mat_x(i,6) * vec_in(6,jk) &
2215 + mat_x(i,7) * vec_in(7,jk) &
2216 + mat_x(i,8) * vec_in(8,jk) &
2217 + mat_x(i,9) * vec_in(9,jk)
2218 end do
2219 end do
2220
2221 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 2228 of file scale_element_operation_tensorprod3D_kernel.F90.

2229 implicit none
2230 real(RP), intent(in) :: Mat_y_tr(9,9)
2231 real(RP), intent(in) :: vec_in(9,9,9)
2232 real(RP), intent(out) :: vec_out(9,9,9)
2233
2234 integer :: i, j, k
2235 !----------------------------------------------------------
2236
2237 do k=1, 9
2238 do j=1, 9
2239 do i=1, 9
2240 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
2241 + vec_in(i,2,k) * mat_y_tr(2,j) &
2242 + vec_in(i,3,k) * mat_y_tr(3,j) &
2243 + vec_in(i,4,k) * mat_y_tr(4,j) &
2244 + vec_in(i,5,k) * mat_y_tr(5,j) &
2245 + vec_in(i,6,k) * mat_y_tr(6,j) &
2246 + vec_in(i,7,k) * mat_y_tr(7,j) &
2247 + vec_in(i,8,k) * mat_y_tr(8,j) &
2248 + vec_in(i,9,k) * mat_y_tr(9,j)
2249 end do
2250 end do
2251 end do
2252
2253 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 2260 of file scale_element_operation_tensorprod3D_kernel.F90.

2261 implicit none
2262 real(RP), intent(in) :: Mat_z_tr(9,9)
2263 real(RP), intent(in) :: vec_in(9,9,9)
2264 real(RP), intent(out) :: vec_out(9,9,9)
2265
2266 integer :: i, j, k
2267 !----------------------------------------------------------
2268
2269 do k=1, 9
2270 do j=1, 9
2271 do i=1, 9
2272 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
2273 + vec_in(i,j,2) * mat_z_tr(2,k) &
2274 + vec_in(i,j,3) * mat_z_tr(3,k) &
2275 + vec_in(i,j,4) * mat_z_tr(4,k) &
2276 + vec_in(i,j,5) * mat_z_tr(5,k) &
2277 + vec_in(i,j,6) * mat_z_tr(6,k) &
2278 + vec_in(i,j,7) * mat_z_tr(7,k) &
2279 + vec_in(i,j,8) * mat_z_tr(8,k) &
2280 + vec_in(i,j,9) * mat_z_tr(9,k)
2281 end do
2282 end do
2283 end do
2284
2285 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 associated with Lift operations with hexahedral element of p=8.

Definition at line 2291 of file scale_element_operation_tensorprod3D_kernel.F90.

2292 implicit none
2293 real(RP), intent(in) :: Lift(9,9,9,6)
2294 real(RP), intent(in) :: vec_in(9,9,6)
2295 real(RP), intent(out) :: vec_out(9,9,9)
2296
2297 integer :: i, j, k
2298 !----------------------------------------------------------
2299
2300 do k=1, 9
2301 do j=1, 9
2302 do i=1, 9
2303 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
2304 + lift(i,j,k,2) * vec_in(j,k,2) &
2305 + lift(i,j,k,3) * vec_in(i,k,3) &
2306 + lift(i,j,k,4) * vec_in(j,k,4) &
2307 + lift(i,j,k,5) * vec_in(i,j,5) &
2308 + lift(i,j,k,6) * vec_in(i,j,6)
2309 end do
2310 end do
2311 end do
2312
2313 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 2321 of file scale_element_operation_tensorprod3D_kernel.F90.

2323 implicit none
2324 real(RP), intent(in) :: Mat(9,9)
2325 real(RP), intent(in) :: Mat_tr(9,9)
2326 real(RP), intent(in) :: vec_in_(9,9**2)
2327 real(RP), intent(in) :: vec_in(9,9,9)
2328 real(RP), intent(out) :: vec_out_x(9,9**2)
2329 real(RP), intent(out) :: vec_out_y(9,9,9)
2330 real(RP), intent(out) :: vec_out_z(9,9,9)
2331
2332 integer :: i, j, k, jk
2333 !----------------------------------------------------------
2334
2335 ! X-dir
2336
2337 do jk=1, 9**2
2338 do i=1, 9
2339 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
2340 + mat(i,2) * vec_in_(2,jk) &
2341 + mat(i,3) * vec_in_(3,jk) &
2342 + mat(i,4) * vec_in_(4,jk) &
2343 + mat(i,5) * vec_in_(5,jk) &
2344 + mat(i,6) * vec_in_(6,jk) &
2345 + mat(i,7) * vec_in_(7,jk) &
2346 + mat(i,8) * vec_in_(8,jk) &
2347 + mat(i,9) * vec_in_(9,jk)
2348 end do
2349 end do
2350
2351 ! Y-dir
2352 do k=1, 9
2353 do j=1, 9
2354 do i=1, 9
2355 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2356 + vec_in(i,2,k) * mat_tr(2,j) &
2357 + vec_in(i,3,k) * mat_tr(3,j) &
2358 + vec_in(i,4,k) * mat_tr(4,j) &
2359 + vec_in(i,5,k) * mat_tr(5,j) &
2360 + vec_in(i,6,k) * mat_tr(6,j) &
2361 + vec_in(i,7,k) * mat_tr(7,j) &
2362 + vec_in(i,8,k) * mat_tr(8,j) &
2363 + vec_in(i,9,k) * mat_tr(9,j)
2364 end do
2365 end do
2366 end do
2367
2368 ! Z-dir
2369 do k=1, 9
2370 do j=1, 9
2371 do i=1, 9
2372 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2373 + vec_in(i,j,2) * mat_tr(2,k) &
2374 + vec_in(i,j,3) * mat_tr(3,k) &
2375 + vec_in(i,j,4) * mat_tr(4,k) &
2376 + vec_in(i,j,5) * mat_tr(5,k) &
2377 + vec_in(i,j,6) * mat_tr(6,k) &
2378 + vec_in(i,j,7) * mat_tr(7,k) &
2379 + vec_in(i,j,8) * mat_tr(8,k) &
2380 + vec_in(i,j,9) * mat_tr(9,k)
2381 end do
2382 end do
2383 end do
2384
2385 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 2393 of file scale_element_operation_tensorprod3D_kernel.F90.

2396 implicit none
2397 real(RP), intent(in) :: Mat(9,9)
2398 real(RP), intent(in) :: Mat_tr(9,9)
2399 real(RP), intent(in) :: vec_in_x(9,9**2)
2400 real(RP), intent(in) :: vec_in_y(9,9,9)
2401 real(RP), intent(in) :: vec_in_z(9,9,9)
2402 real(RP), intent(out) :: vec_out_x(9,9**2)
2403 real(RP), intent(out) :: vec_out_y(9,9**2)
2404 real(RP), intent(out) :: vec_out_z(9,9**2)
2405
2406 integer :: i, j, k, jk
2407 real(RP) :: tmp1, tmp2, tmp3
2408 !----------------------------------------------------------
2409
2410 ! X-dir
2411
2412 do jk=1, 9**2
2413 do i=1, 9
2414 tmp1 = mat(i,1) * vec_in_x(1,jk) &
2415 + mat(i,2) * vec_in_x(2,jk) &
2416 + mat(i,3) * vec_in_x(3,jk)
2417 tmp2 = mat(i,4) * vec_in_x(4,jk) &
2418 + mat(i,5) * vec_in_x(5,jk) &
2419 + mat(i,6) * vec_in_x(6,jk)
2420 tmp3 = mat(i,7) * vec_in_x(7,jk) &
2421 + mat(i,8) * vec_in_x(8,jk) &
2422 + mat(i,9) * vec_in_x(9,jk)
2423 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
2424 end do
2425 end do
2426
2427 ! Y-dir
2428 do k=1, 9
2429 do j=1, 9
2430 jk = j + (k-1)*9
2431 do i=1, 9
2432 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
2433 + vec_in_y(i,2,k) * mat_tr(2,j) &
2434 + vec_in_y(i,3,k) * mat_tr(3,j)
2435 tmp2 = vec_in_y(i,4,k) * mat_tr(4,j) &
2436 + vec_in_y(i,5,k) * mat_tr(5,j) &
2437 + vec_in_y(i,6,k) * mat_tr(6,j)
2438 tmp3 = vec_in_y(i,7,k) * mat_tr(7,j) &
2439 + vec_in_y(i,8,k) * mat_tr(8,j) &
2440 + vec_in_y(i,9,k) * mat_tr(9,j)
2441 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
2442 end do
2443 end do
2444 end do
2445
2446 ! Z-dir
2447 do k=1, 9
2448 do j=1, 9
2449 jk = j + (k-1)*9
2450 do i=1, 9
2451 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
2452 + vec_in_z(i,j,2) * mat_tr(2,k) &
2453 + vec_in_z(i,j,3) * mat_tr(3,k)
2454 tmp2 = vec_in_z(i,j,4) * mat_tr(4,k) &
2455 + vec_in_z(i,j,5) * mat_tr(5,k) &
2456 + vec_in_z(i,j,6) * mat_tr(6,k)
2457 tmp3 = vec_in_z(i,j,7) * mat_tr(7,k) &
2458 + vec_in_z(i,j,8) * mat_tr(8,k) &
2459 + vec_in_z(i,j,9) * mat_tr(9,k)
2460 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
2461 end do
2462 end do
2463 end do
2464 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 2470 of file scale_element_operation_tensorprod3D_kernel.F90.

2472 implicit none
2473 real(RP), intent(in) :: Mat_h1D(9,9)
2474 real(RP), intent(in) :: Mat_h1D_tr(9,9)
2475 real(RP), intent(in) :: Mat_v1D_tr(9,9)
2476 real(RP), intent(in) :: vec_in(9,9,9)
2477 real(RP), intent(out) :: vec_work(9,9,9)
2478 real(RP), intent(out) :: vec_out(9,9,9)
2479
2480 integer :: i, j, k
2481 real(RP) :: tmp1, tmp2, tmp3
2482 !----------------------------------------------------------
2483
2484 ! X-dir
2485
2486 do k=1, 9
2487 do j=1, 9
2488 do i=1, 9
2489 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
2490 + mat_h1d(i,2) * vec_in(2,j,k) &
2491 + mat_h1d(i,3) * vec_in(3,j,k)
2492 tmp2 = mat_h1d(i,4) * vec_in(4,j,k) &
2493 + mat_h1d(i,5) * vec_in(5,j,k) &
2494 + mat_h1d(i,6) * vec_in(6,j,k)
2495 tmp3 = mat_h1d(i,7) * vec_in(7,j,k) &
2496 + mat_h1d(i,8) * vec_in(8,j,k) &
2497 + mat_h1d(i,9) * vec_in(9,j,k)
2498 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
2499 end do
2500 end do
2501 end do
2502
2503 ! Y-dir
2504 do k=1, 9
2505 do j=1, 9
2506 do i=1, 9
2507 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
2508 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
2509 + vec_out(i,3,k) * mat_h1d_tr(3,j)
2510 tmp2 = vec_out(i,4,k) * mat_h1d_tr(4,j) &
2511 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
2512 + vec_out(i,6,k) * mat_h1d_tr(6,j)
2513 tmp3 = vec_out(i,7,k) * mat_h1d_tr(7,j) &
2514 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
2515 + vec_out(i,9,k) * mat_h1d_tr(9,j)
2516 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
2517 end do
2518 end do
2519 end do
2520
2521 ! Z-dir
2522 do k=1, 9
2523 do j=1, 9
2524 do i=1, 9
2525 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
2526 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
2527 + vec_work(i,j,3) * mat_v1d_tr(3,k)
2528 tmp2 = vec_work(i,j,4) * mat_v1d_tr(4,k) &
2529 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
2530 + vec_work(i,j,6) * mat_v1d_tr(6,k)
2531 tmp3 = vec_work(i,j,7) * mat_v1d_tr(7,k) &
2532 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
2533 + vec_work(i,j,9) * mat_v1d_tr(9,k)
2534 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
2535 end do
2536 end do
2537 end do
2538
2539 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 2547 of file scale_element_operation_tensorprod3D_kernel.F90.

2548 implicit none
2549 real(RP), intent(in) :: Mat_x(10,10)
2550 real(RP), intent(in) :: vec_in(10,10**2)
2551 real(RP), intent(out) :: vec_out(10,10**2)
2552
2553 integer :: i, jk
2554 !----------------------------------------------------------
2555
2556 do jk=1, 10**2
2557 do i=1, 10
2558 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
2559 + mat_x(i,2) * vec_in(2,jk) &
2560 + mat_x(i,3) * vec_in(3,jk) &
2561 + mat_x(i,4) * vec_in(4,jk) &
2562 + mat_x(i,5) * vec_in(5,jk) &
2563 + mat_x(i,6) * vec_in(6,jk) &
2564 + mat_x(i,7) * vec_in(7,jk) &
2565 + mat_x(i,8) * vec_in(8,jk) &
2566 + mat_x(i,9) * vec_in(9,jk) &
2567 + mat_x(i,10) * vec_in(10,jk)
2568 end do
2569 end do
2570
2571 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 2578 of file scale_element_operation_tensorprod3D_kernel.F90.

2579 implicit none
2580 real(RP), intent(in) :: Mat_y_tr(10,10)
2581 real(RP), intent(in) :: vec_in(10,10,10)
2582 real(RP), intent(out) :: vec_out(10,10,10)
2583
2584 integer :: i, j, k
2585 !----------------------------------------------------------
2586
2587 do k=1, 10
2588 do j=1, 10
2589 do i=1, 10
2590 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
2591 + vec_in(i,2,k) * mat_y_tr(2,j) &
2592 + vec_in(i,3,k) * mat_y_tr(3,j) &
2593 + vec_in(i,4,k) * mat_y_tr(4,j) &
2594 + vec_in(i,5,k) * mat_y_tr(5,j) &
2595 + vec_in(i,6,k) * mat_y_tr(6,j) &
2596 + vec_in(i,7,k) * mat_y_tr(7,j) &
2597 + vec_in(i,8,k) * mat_y_tr(8,j) &
2598 + vec_in(i,9,k) * mat_y_tr(9,j) &
2599 + vec_in(i,10,k) * mat_y_tr(10,j)
2600 end do
2601 end do
2602 end do
2603
2604 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 2611 of file scale_element_operation_tensorprod3D_kernel.F90.

2612 implicit none
2613 real(RP), intent(in) :: Mat_z_tr(10,10)
2614 real(RP), intent(in) :: vec_in(10,10,10)
2615 real(RP), intent(out) :: vec_out(10,10,10)
2616
2617 integer :: i, j, k
2618 !----------------------------------------------------------
2619
2620 do k=1, 10
2621 do j=1, 10
2622 do i=1, 10
2623 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
2624 + vec_in(i,j,2) * mat_z_tr(2,k) &
2625 + vec_in(i,j,3) * mat_z_tr(3,k) &
2626 + vec_in(i,j,4) * mat_z_tr(4,k) &
2627 + vec_in(i,j,5) * mat_z_tr(5,k) &
2628 + vec_in(i,j,6) * mat_z_tr(6,k) &
2629 + vec_in(i,j,7) * mat_z_tr(7,k) &
2630 + vec_in(i,j,8) * mat_z_tr(8,k) &
2631 + vec_in(i,j,9) * mat_z_tr(9,k) &
2632 + vec_in(i,j,10) * mat_z_tr(10,k)
2633 end do
2634 end do
2635 end do
2636
2637 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 associated with Lift operations with hexahedral element of p=9.

Definition at line 2643 of file scale_element_operation_tensorprod3D_kernel.F90.

2644 implicit none
2645 real(RP), intent(in) :: Lift(10,10,10,6)
2646 real(RP), intent(in) :: vec_in(10,10,6)
2647 real(RP), intent(out) :: vec_out(10,10,10)
2648
2649 integer :: i, j, k
2650 !----------------------------------------------------------
2651
2652 do k=1, 10
2653 do j=1, 10
2654 do i=1, 10
2655 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
2656 + lift(i,j,k,2) * vec_in(j,k,2) &
2657 + lift(i,j,k,3) * vec_in(i,k,3) &
2658 + lift(i,j,k,4) * vec_in(j,k,4) &
2659 + lift(i,j,k,5) * vec_in(i,j,5) &
2660 + lift(i,j,k,6) * vec_in(i,j,6)
2661 end do
2662 end do
2663 end do
2664
2665 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 2673 of file scale_element_operation_tensorprod3D_kernel.F90.

2675 implicit none
2676 real(RP), intent(in) :: Mat(10,10)
2677 real(RP), intent(in) :: Mat_tr(10,10)
2678 real(RP), intent(in) :: vec_in_(10,10**2)
2679 real(RP), intent(in) :: vec_in(10,10,10)
2680 real(RP), intent(out) :: vec_out_x(10,10**2)
2681 real(RP), intent(out) :: vec_out_y(10,10,10)
2682 real(RP), intent(out) :: vec_out_z(10,10,10)
2683
2684 integer :: i, j, k, jk
2685 !----------------------------------------------------------
2686
2687 ! X-dir
2688
2689 do jk=1, 10**2
2690 do i=1, 10
2691 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
2692 + mat(i,2) * vec_in_(2,jk) &
2693 + mat(i,3) * vec_in_(3,jk) &
2694 + mat(i,4) * vec_in_(4,jk) &
2695 + mat(i,5) * vec_in_(5,jk) &
2696 + mat(i,6) * vec_in_(6,jk) &
2697 + mat(i,7) * vec_in_(7,jk) &
2698 + mat(i,8) * vec_in_(8,jk) &
2699 + mat(i,9) * vec_in_(9,jk) &
2700 + mat(i,10) * vec_in_(10,jk)
2701 end do
2702 end do
2703
2704 ! Y-dir
2705 do k=1, 10
2706 do j=1, 10
2707 do i=1, 10
2708 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2709 + vec_in(i,2,k) * mat_tr(2,j) &
2710 + vec_in(i,3,k) * mat_tr(3,j) &
2711 + vec_in(i,4,k) * mat_tr(4,j) &
2712 + vec_in(i,5,k) * mat_tr(5,j) &
2713 + vec_in(i,6,k) * mat_tr(6,j) &
2714 + vec_in(i,7,k) * mat_tr(7,j) &
2715 + vec_in(i,8,k) * mat_tr(8,j) &
2716 + vec_in(i,9,k) * mat_tr(9,j) &
2717 + vec_in(i,10,k) * mat_tr(10,j)
2718 end do
2719 end do
2720 end do
2721
2722 ! Z-dir
2723 do k=1, 10
2724 do j=1, 10
2725 do i=1, 10
2726 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
2727 + vec_in(i,j,2) * mat_tr(2,k) &
2728 + vec_in(i,j,3) * mat_tr(3,k) &
2729 + vec_in(i,j,4) * mat_tr(4,k) &
2730 + vec_in(i,j,5) * mat_tr(5,k) &
2731 + vec_in(i,j,6) * mat_tr(6,k) &
2732 + vec_in(i,j,7) * mat_tr(7,k) &
2733 + vec_in(i,j,8) * mat_tr(8,k) &
2734 + vec_in(i,j,9) * mat_tr(9,k) &
2735 + vec_in(i,j,10) * mat_tr(10,k)
2736 end do
2737 end do
2738 end do
2739
2740 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 2748 of file scale_element_operation_tensorprod3D_kernel.F90.

2751 implicit none
2752 real(RP), intent(in) :: Mat(10,10)
2753 real(RP), intent(in) :: Mat_tr(10,10)
2754 real(RP), intent(in) :: vec_in_x(10,10**2)
2755 real(RP), intent(in) :: vec_in_y(10,10,10)
2756 real(RP), intent(in) :: vec_in_z(10,10,10)
2757 real(RP), intent(out) :: vec_out_x(10,10**2)
2758 real(RP), intent(out) :: vec_out_y(10,10**2)
2759 real(RP), intent(out) :: vec_out_z(10,10**2)
2760
2761 integer :: i, j, k, jk
2762 real(RP) :: tmp1, tmp2, tmp3
2763 !----------------------------------------------------------
2764
2765 ! X-dir
2766
2767 do jk=1, 10**2
2768 do i=1, 10
2769 tmp1 = mat(i,1) * vec_in_x(1,jk) &
2770 + mat(i,2) * vec_in_x(2,jk) &
2771 + mat(i,3) * vec_in_x(3,jk)
2772 tmp2 = mat(i,4) * vec_in_x(4,jk) &
2773 + mat(i,5) * vec_in_x(5,jk) &
2774 + mat(i,6) * vec_in_x(6,jk)
2775 tmp3 = mat(i,7) * vec_in_x(7,jk) &
2776 + mat(i,8) * vec_in_x(8,jk) &
2777 + mat(i,9) * vec_in_x(9,jk) &
2778 + mat(i,10) * vec_in_x(10,jk)
2779 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
2780 end do
2781 end do
2782
2783 ! Y-dir
2784 do k=1, 10
2785 do j=1, 10
2786 jk = j + (k-1)*10
2787 do i=1, 10
2788 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
2789 + vec_in_y(i,2,k) * mat_tr(2,j) &
2790 + vec_in_y(i,3,k) * mat_tr(3,j)
2791 tmp2 = vec_in_y(i,4,k) * mat_tr(4,j) &
2792 + vec_in_y(i,5,k) * mat_tr(5,j) &
2793 + vec_in_y(i,6,k) * mat_tr(6,j)
2794 tmp3 = vec_in_y(i,7,k) * mat_tr(7,j) &
2795 + vec_in_y(i,8,k) * mat_tr(8,j) &
2796 + vec_in_y(i,9,k) * mat_tr(9,j) &
2797 + vec_in_y(i,10,k) * mat_tr(10,j)
2798 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
2799 end do
2800 end do
2801 end do
2802
2803 ! Z-dir
2804 do k=1, 10
2805 do j=1, 10
2806 jk = j + (k-1)*10
2807 do i=1, 10
2808 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
2809 + vec_in_z(i,j,2) * mat_tr(2,k) &
2810 + vec_in_z(i,j,3) * mat_tr(3,k)
2811 tmp2 = vec_in_z(i,j,4) * mat_tr(4,k) &
2812 + vec_in_z(i,j,5) * mat_tr(5,k) &
2813 + vec_in_z(i,j,6) * mat_tr(6,k)
2814 tmp3 = vec_in_z(i,j,7) * mat_tr(7,k) &
2815 + vec_in_z(i,j,8) * mat_tr(8,k) &
2816 + vec_in_z(i,j,9) * mat_tr(9,k) &
2817 + vec_in_z(i,j,10) * mat_tr(10,k)
2818 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
2819 end do
2820 end do
2821 end do
2822 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 2828 of file scale_element_operation_tensorprod3D_kernel.F90.

2830 implicit none
2831 real(RP), intent(in) :: Mat_h1D(10,10)
2832 real(RP), intent(in) :: Mat_h1D_tr(10,10)
2833 real(RP), intent(in) :: Mat_v1D_tr(10,10)
2834 real(RP), intent(in) :: vec_in(10,10,10)
2835 real(RP), intent(out) :: vec_work(10,10,10)
2836 real(RP), intent(out) :: vec_out(10,10,10)
2837
2838 integer :: i, j, k
2839 real(RP) :: tmp1, tmp2, tmp3
2840 !----------------------------------------------------------
2841
2842 ! X-dir
2843
2844 do k=1, 10
2845 do j=1, 10
2846 do i=1, 10
2847 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
2848 + mat_h1d(i,2) * vec_in(2,j,k) &
2849 + mat_h1d(i,3) * vec_in(3,j,k)
2850 tmp2 = mat_h1d(i,4) * vec_in(4,j,k) &
2851 + mat_h1d(i,5) * vec_in(5,j,k) &
2852 + mat_h1d(i,6) * vec_in(6,j,k)
2853 tmp3 = mat_h1d(i,7) * vec_in(7,j,k) &
2854 + mat_h1d(i,8) * vec_in(8,j,k) &
2855 + mat_h1d(i,9) * vec_in(9,j,k) &
2856 + mat_h1d(i,10) * vec_in(10,j,k)
2857 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
2858 end do
2859 end do
2860 end do
2861
2862 ! Y-dir
2863 do k=1, 10
2864 do j=1, 10
2865 do i=1, 10
2866 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
2867 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
2868 + vec_out(i,3,k) * mat_h1d_tr(3,j)
2869 tmp2 = vec_out(i,4,k) * mat_h1d_tr(4,j) &
2870 + vec_out(i,5,k) * mat_h1d_tr(5,j) &
2871 + vec_out(i,6,k) * mat_h1d_tr(6,j)
2872 tmp3 = vec_out(i,7,k) * mat_h1d_tr(7,j) &
2873 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
2874 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
2875 + vec_out(i,10,k) * mat_h1d_tr(10,j)
2876 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
2877 end do
2878 end do
2879 end do
2880
2881 ! Z-dir
2882 do k=1, 10
2883 do j=1, 10
2884 do i=1, 10
2885 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
2886 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
2887 + vec_work(i,j,3) * mat_v1d_tr(3,k)
2888 tmp2 = vec_work(i,j,4) * mat_v1d_tr(4,k) &
2889 + vec_work(i,j,5) * mat_v1d_tr(5,k) &
2890 + vec_work(i,j,6) * mat_v1d_tr(6,k)
2891 tmp3 = vec_work(i,j,7) * mat_v1d_tr(7,k) &
2892 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
2893 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
2894 + vec_work(i,j,10) * mat_v1d_tr(10,k)
2895 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
2896 end do
2897 end do
2898 end do
2899
2900 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 2908 of file scale_element_operation_tensorprod3D_kernel.F90.

2909 implicit none
2910 real(RP), intent(in) :: Mat_x(11,11)
2911 real(RP), intent(in) :: vec_in(11,11**2)
2912 real(RP), intent(out) :: vec_out(11,11**2)
2913
2914 integer :: i, jk
2915 !----------------------------------------------------------
2916
2917 do jk=1, 11**2
2918 do i=1, 11
2919 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
2920 + mat_x(i,2) * vec_in(2,jk) &
2921 + mat_x(i,3) * vec_in(3,jk) &
2922 + mat_x(i,4) * vec_in(4,jk) &
2923 + mat_x(i,5) * vec_in(5,jk) &
2924 + mat_x(i,6) * vec_in(6,jk) &
2925 + mat_x(i,7) * vec_in(7,jk) &
2926 + mat_x(i,8) * vec_in(8,jk) &
2927 + mat_x(i,9) * vec_in(9,jk) &
2928 + mat_x(i,10) * vec_in(10,jk) &
2929 + mat_x(i,11) * vec_in(11,jk)
2930 end do
2931 end do
2932
2933 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 2940 of file scale_element_operation_tensorprod3D_kernel.F90.

2941 implicit none
2942 real(RP), intent(in) :: Mat_y_tr(11,11)
2943 real(RP), intent(in) :: vec_in(11,11,11)
2944 real(RP), intent(out) :: vec_out(11,11,11)
2945
2946 integer :: i, j, k
2947 !----------------------------------------------------------
2948
2949 do k=1, 11
2950 do j=1, 11
2951 do i=1, 11
2952 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
2953 + vec_in(i,2,k) * mat_y_tr(2,j) &
2954 + vec_in(i,3,k) * mat_y_tr(3,j) &
2955 + vec_in(i,4,k) * mat_y_tr(4,j) &
2956 + vec_in(i,5,k) * mat_y_tr(5,j) &
2957 + vec_in(i,6,k) * mat_y_tr(6,j) &
2958 + vec_in(i,7,k) * mat_y_tr(7,j) &
2959 + vec_in(i,8,k) * mat_y_tr(8,j) &
2960 + vec_in(i,9,k) * mat_y_tr(9,j) &
2961 + vec_in(i,10,k) * mat_y_tr(10,j) &
2962 + vec_in(i,11,k) * mat_y_tr(11,j)
2963 end do
2964 end do
2965 end do
2966
2967 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 2974 of file scale_element_operation_tensorprod3D_kernel.F90.

2975 implicit none
2976 real(RP), intent(in) :: Mat_z_tr(11,11)
2977 real(RP), intent(in) :: vec_in(11,11,11)
2978 real(RP), intent(out) :: vec_out(11,11,11)
2979
2980 integer :: i, j, k
2981 !----------------------------------------------------------
2982
2983 do k=1, 11
2984 do j=1, 11
2985 do i=1, 11
2986 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
2987 + vec_in(i,j,2) * mat_z_tr(2,k) &
2988 + vec_in(i,j,3) * mat_z_tr(3,k) &
2989 + vec_in(i,j,4) * mat_z_tr(4,k) &
2990 + vec_in(i,j,5) * mat_z_tr(5,k) &
2991 + vec_in(i,j,6) * mat_z_tr(6,k) &
2992 + vec_in(i,j,7) * mat_z_tr(7,k) &
2993 + vec_in(i,j,8) * mat_z_tr(8,k) &
2994 + vec_in(i,j,9) * mat_z_tr(9,k) &
2995 + vec_in(i,j,10) * mat_z_tr(10,k) &
2996 + vec_in(i,j,11) * mat_z_tr(11,k)
2997 end do
2998 end do
2999 end do
3000
3001 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 associated with Lift operations with hexahedral element of p=10.

Definition at line 3007 of file scale_element_operation_tensorprod3D_kernel.F90.

3008 implicit none
3009 real(RP), intent(in) :: Lift(11,11,11,6)
3010 real(RP), intent(in) :: vec_in(11,11,6)
3011 real(RP), intent(out) :: vec_out(11,11,11)
3012
3013 integer :: i, j, k
3014 !----------------------------------------------------------
3015
3016 do k=1, 11
3017 do j=1, 11
3018 do i=1, 11
3019 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
3020 + lift(i,j,k,2) * vec_in(j,k,2) &
3021 + lift(i,j,k,3) * vec_in(i,k,3) &
3022 + lift(i,j,k,4) * vec_in(j,k,4) &
3023 + lift(i,j,k,5) * vec_in(i,j,5) &
3024 + lift(i,j,k,6) * vec_in(i,j,6)
3025 end do
3026 end do
3027 end do
3028
3029 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 3037 of file scale_element_operation_tensorprod3D_kernel.F90.

3039 implicit none
3040 real(RP), intent(in) :: Mat(11,11)
3041 real(RP), intent(in) :: Mat_tr(11,11)
3042 real(RP), intent(in) :: vec_in_(11,11**2)
3043 real(RP), intent(in) :: vec_in(11,11,11)
3044 real(RP), intent(out) :: vec_out_x(11,11**2)
3045 real(RP), intent(out) :: vec_out_y(11,11,11)
3046 real(RP), intent(out) :: vec_out_z(11,11,11)
3047
3048 integer :: i, j, k, jk
3049 !----------------------------------------------------------
3050
3051 ! X-dir
3052
3053 do jk=1, 11**2
3054 do i=1, 11
3055 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
3056 + mat(i,2) * vec_in_(2,jk) &
3057 + mat(i,3) * vec_in_(3,jk) &
3058 + mat(i,4) * vec_in_(4,jk) &
3059 + mat(i,5) * vec_in_(5,jk) &
3060 + mat(i,6) * vec_in_(6,jk) &
3061 + mat(i,7) * vec_in_(7,jk) &
3062 + mat(i,8) * vec_in_(8,jk) &
3063 + mat(i,9) * vec_in_(9,jk) &
3064 + mat(i,10) * vec_in_(10,jk) &
3065 + mat(i,11) * vec_in_(11,jk)
3066 end do
3067 end do
3068
3069 ! Y-dir
3070 do k=1, 11
3071 do j=1, 11
3072 do i=1, 11
3073 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3074 + vec_in(i,2,k) * mat_tr(2,j) &
3075 + vec_in(i,3,k) * mat_tr(3,j) &
3076 + vec_in(i,4,k) * mat_tr(4,j) &
3077 + vec_in(i,5,k) * mat_tr(5,j) &
3078 + vec_in(i,6,k) * mat_tr(6,j) &
3079 + vec_in(i,7,k) * mat_tr(7,j) &
3080 + vec_in(i,8,k) * mat_tr(8,j) &
3081 + vec_in(i,9,k) * mat_tr(9,j) &
3082 + vec_in(i,10,k) * mat_tr(10,j) &
3083 + vec_in(i,11,k) * mat_tr(11,j)
3084 end do
3085 end do
3086 end do
3087
3088 ! Z-dir
3089 do k=1, 11
3090 do j=1, 11
3091 do i=1, 11
3092 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3093 + vec_in(i,j,2) * mat_tr(2,k) &
3094 + vec_in(i,j,3) * mat_tr(3,k) &
3095 + vec_in(i,j,4) * mat_tr(4,k) &
3096 + vec_in(i,j,5) * mat_tr(5,k) &
3097 + vec_in(i,j,6) * mat_tr(6,k) &
3098 + vec_in(i,j,7) * mat_tr(7,k) &
3099 + vec_in(i,j,8) * mat_tr(8,k) &
3100 + vec_in(i,j,9) * mat_tr(9,k) &
3101 + vec_in(i,j,10) * mat_tr(10,k) &
3102 + vec_in(i,j,11) * mat_tr(11,k)
3103 end do
3104 end do
3105 end do
3106
3107 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 3115 of file scale_element_operation_tensorprod3D_kernel.F90.

3118 implicit none
3119 real(RP), intent(in) :: Mat(11,11)
3120 real(RP), intent(in) :: Mat_tr(11,11)
3121 real(RP), intent(in) :: vec_in_x(11,11**2)
3122 real(RP), intent(in) :: vec_in_y(11,11,11)
3123 real(RP), intent(in) :: vec_in_z(11,11,11)
3124 real(RP), intent(out) :: vec_out_x(11,11**2)
3125 real(RP), intent(out) :: vec_out_y(11,11**2)
3126 real(RP), intent(out) :: vec_out_z(11,11**2)
3127
3128 integer :: i, j, k, jk
3129 real(RP) :: tmp1, tmp2, tmp3
3130 !----------------------------------------------------------
3131
3132 ! X-dir
3133
3134 do jk=1, 11**2
3135 do i=1, 11
3136 tmp1 = mat(i,1) * vec_in_x(1,jk) &
3137 + mat(i,2) * vec_in_x(2,jk) &
3138 + mat(i,3) * vec_in_x(3,jk) &
3139 + mat(i,4) * vec_in_x(4,jk)
3140 tmp2 = mat(i,5) * vec_in_x(5,jk) &
3141 + mat(i,6) * vec_in_x(6,jk) &
3142 + mat(i,7) * vec_in_x(7,jk) &
3143 + mat(i,8) * vec_in_x(8,jk)
3144 tmp3 = mat(i,9) * vec_in_x(9,jk) &
3145 + mat(i,10) * vec_in_x(10,jk) &
3146 + mat(i,11) * vec_in_x(11,jk)
3147 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
3148 end do
3149 end do
3150
3151 ! Y-dir
3152 do k=1, 11
3153 do j=1, 11
3154 jk = j + (k-1)*11
3155 do i=1, 11
3156 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
3157 + vec_in_y(i,2,k) * mat_tr(2,j) &
3158 + vec_in_y(i,3,k) * mat_tr(3,j) &
3159 + vec_in_y(i,4,k) * mat_tr(4,j)
3160 tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
3161 + vec_in_y(i,6,k) * mat_tr(6,j) &
3162 + vec_in_y(i,7,k) * mat_tr(7,j) &
3163 + vec_in_y(i,8,k) * mat_tr(8,j)
3164 tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
3165 + vec_in_y(i,10,k) * mat_tr(10,j) &
3166 + vec_in_y(i,11,k) * mat_tr(11,j)
3167 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
3168 end do
3169 end do
3170 end do
3171
3172 ! Z-dir
3173 do k=1, 11
3174 do j=1, 11
3175 jk = j + (k-1)*11
3176 do i=1, 11
3177 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
3178 + vec_in_z(i,j,2) * mat_tr(2,k) &
3179 + vec_in_z(i,j,3) * mat_tr(3,k) &
3180 + vec_in_z(i,j,4) * mat_tr(4,k)
3181 tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
3182 + vec_in_z(i,j,6) * mat_tr(6,k) &
3183 + vec_in_z(i,j,7) * mat_tr(7,k) &
3184 + vec_in_z(i,j,8) * mat_tr(8,k)
3185 tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
3186 + vec_in_z(i,j,10) * mat_tr(10,k) &
3187 + vec_in_z(i,j,11) * mat_tr(11,k)
3188 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
3189 end do
3190 end do
3191 end do
3192 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 3198 of file scale_element_operation_tensorprod3D_kernel.F90.

3200 implicit none
3201 real(RP), intent(in) :: Mat_h1D(11,11)
3202 real(RP), intent(in) :: Mat_h1D_tr(11,11)
3203 real(RP), intent(in) :: Mat_v1D_tr(11,11)
3204 real(RP), intent(in) :: vec_in(11,11,11)
3205 real(RP), intent(out) :: vec_work(11,11,11)
3206 real(RP), intent(out) :: vec_out(11,11,11)
3207
3208 integer :: i, j, k
3209 real(RP) :: tmp1, tmp2, tmp3
3210 !----------------------------------------------------------
3211
3212 ! X-dir
3213
3214 do k=1, 11
3215 do j=1, 11
3216 do i=1, 11
3217 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
3218 + mat_h1d(i,2) * vec_in(2,j,k) &
3219 + mat_h1d(i,3) * vec_in(3,j,k) &
3220 + mat_h1d(i,4) * vec_in(4,j,k)
3221 tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
3222 + mat_h1d(i,6) * vec_in(6,j,k) &
3223 + mat_h1d(i,7) * vec_in(7,j,k) &
3224 + mat_h1d(i,8) * vec_in(8,j,k)
3225 tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
3226 + mat_h1d(i,10) * vec_in(10,j,k) &
3227 + mat_h1d(i,11) * vec_in(11,j,k)
3228 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3229 end do
3230 end do
3231 end do
3232
3233 ! Y-dir
3234 do k=1, 11
3235 do j=1, 11
3236 do i=1, 11
3237 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
3238 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
3239 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
3240 + vec_out(i,4,k) * mat_h1d_tr(4,j)
3241 tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
3242 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
3243 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
3244 + vec_out(i,8,k) * mat_h1d_tr(8,j)
3245 tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
3246 + vec_out(i,10,k) * mat_h1d_tr(10,j) &
3247 + vec_out(i,11,k) * mat_h1d_tr(11,j)
3248 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
3249 end do
3250 end do
3251 end do
3252
3253 ! Z-dir
3254 do k=1, 11
3255 do j=1, 11
3256 do i=1, 11
3257 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
3258 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
3259 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
3260 + vec_work(i,j,4) * mat_v1d_tr(4,k)
3261 tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
3262 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
3263 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
3264 + vec_work(i,j,8) * mat_v1d_tr(8,k)
3265 tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
3266 + vec_work(i,j,10) * mat_v1d_tr(10,k) &
3267 + vec_work(i,j,11) * mat_v1d_tr(11,k)
3268 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3269 end do
3270 end do
3271 end do
3272
3273 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 3281 of file scale_element_operation_tensorprod3D_kernel.F90.

3282 implicit none
3283 real(RP), intent(in) :: Mat_x(12,12)
3284 real(RP), intent(in) :: vec_in(12,12**2)
3285 real(RP), intent(out) :: vec_out(12,12**2)
3286
3287 integer :: i, jk
3288 !----------------------------------------------------------
3289
3290 do jk=1, 12**2
3291 do i=1, 12
3292 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
3293 + mat_x(i,2) * vec_in(2,jk) &
3294 + mat_x(i,3) * vec_in(3,jk) &
3295 + mat_x(i,4) * vec_in(4,jk) &
3296 + mat_x(i,5) * vec_in(5,jk) &
3297 + mat_x(i,6) * vec_in(6,jk) &
3298 + mat_x(i,7) * vec_in(7,jk) &
3299 + mat_x(i,8) * vec_in(8,jk) &
3300 + mat_x(i,9) * vec_in(9,jk) &
3301 + mat_x(i,10) * vec_in(10,jk) &
3302 + mat_x(i,11) * vec_in(11,jk) &
3303 + mat_x(i,12) * vec_in(12,jk)
3304 end do
3305 end do
3306
3307 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 3314 of file scale_element_operation_tensorprod3D_kernel.F90.

3315 implicit none
3316 real(RP), intent(in) :: Mat_y_tr(12,12)
3317 real(RP), intent(in) :: vec_in(12,12,12)
3318 real(RP), intent(out) :: vec_out(12,12,12)
3319
3320 integer :: i, j, k
3321 !----------------------------------------------------------
3322
3323 do k=1, 12
3324 do j=1, 12
3325 do i=1, 12
3326 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
3327 + vec_in(i,2,k) * mat_y_tr(2,j) &
3328 + vec_in(i,3,k) * mat_y_tr(3,j) &
3329 + vec_in(i,4,k) * mat_y_tr(4,j) &
3330 + vec_in(i,5,k) * mat_y_tr(5,j) &
3331 + vec_in(i,6,k) * mat_y_tr(6,j) &
3332 + vec_in(i,7,k) * mat_y_tr(7,j) &
3333 + vec_in(i,8,k) * mat_y_tr(8,j) &
3334 + vec_in(i,9,k) * mat_y_tr(9,j) &
3335 + vec_in(i,10,k) * mat_y_tr(10,j) &
3336 + vec_in(i,11,k) * mat_y_tr(11,j) &
3337 + vec_in(i,12,k) * mat_y_tr(12,j)
3338 end do
3339 end do
3340 end do
3341
3342 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 3349 of file scale_element_operation_tensorprod3D_kernel.F90.

3350 implicit none
3351 real(RP), intent(in) :: Mat_z_tr(12,12)
3352 real(RP), intent(in) :: vec_in(12,12,12)
3353 real(RP), intent(out) :: vec_out(12,12,12)
3354
3355 integer :: i, j, k
3356 !----------------------------------------------------------
3357
3358 do k=1, 12
3359 do j=1, 12
3360 do i=1, 12
3361 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
3362 + vec_in(i,j,2) * mat_z_tr(2,k) &
3363 + vec_in(i,j,3) * mat_z_tr(3,k) &
3364 + vec_in(i,j,4) * mat_z_tr(4,k) &
3365 + vec_in(i,j,5) * mat_z_tr(5,k) &
3366 + vec_in(i,j,6) * mat_z_tr(6,k) &
3367 + vec_in(i,j,7) * mat_z_tr(7,k) &
3368 + vec_in(i,j,8) * mat_z_tr(8,k) &
3369 + vec_in(i,j,9) * mat_z_tr(9,k) &
3370 + vec_in(i,j,10) * mat_z_tr(10,k) &
3371 + vec_in(i,j,11) * mat_z_tr(11,k) &
3372 + vec_in(i,j,12) * mat_z_tr(12,k)
3373 end do
3374 end do
3375 end do
3376
3377 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 associated with Lift operations with hexahedral element of p=11.

Definition at line 3383 of file scale_element_operation_tensorprod3D_kernel.F90.

3384 implicit none
3385 real(RP), intent(in) :: Lift(12,12,12,6)
3386 real(RP), intent(in) :: vec_in(12,12,6)
3387 real(RP), intent(out) :: vec_out(12,12,12)
3388
3389 integer :: i, j, k
3390 !----------------------------------------------------------
3391
3392 do k=1, 12
3393 do j=1, 12
3394 do i=1, 12
3395 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
3396 + lift(i,j,k,2) * vec_in(j,k,2) &
3397 + lift(i,j,k,3) * vec_in(i,k,3) &
3398 + lift(i,j,k,4) * vec_in(j,k,4) &
3399 + lift(i,j,k,5) * vec_in(i,j,5) &
3400 + lift(i,j,k,6) * vec_in(i,j,6)
3401 end do
3402 end do
3403 end do
3404
3405 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 3413 of file scale_element_operation_tensorprod3D_kernel.F90.

3415 implicit none
3416 real(RP), intent(in) :: Mat(12,12)
3417 real(RP), intent(in) :: Mat_tr(12,12)
3418 real(RP), intent(in) :: vec_in_(12,12**2)
3419 real(RP), intent(in) :: vec_in(12,12,12)
3420 real(RP), intent(out) :: vec_out_x(12,12**2)
3421 real(RP), intent(out) :: vec_out_y(12,12,12)
3422 real(RP), intent(out) :: vec_out_z(12,12,12)
3423
3424 integer :: i, j, k, jk
3425 !----------------------------------------------------------
3426
3427 ! X-dir
3428
3429 do jk=1, 12**2
3430 do i=1, 12
3431 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
3432 + mat(i,2) * vec_in_(2,jk) &
3433 + mat(i,3) * vec_in_(3,jk) &
3434 + mat(i,4) * vec_in_(4,jk) &
3435 + mat(i,5) * vec_in_(5,jk) &
3436 + mat(i,6) * vec_in_(6,jk) &
3437 + mat(i,7) * vec_in_(7,jk) &
3438 + mat(i,8) * vec_in_(8,jk) &
3439 + mat(i,9) * vec_in_(9,jk) &
3440 + mat(i,10) * vec_in_(10,jk) &
3441 + mat(i,11) * vec_in_(11,jk) &
3442 + mat(i,12) * vec_in_(12,jk)
3443 end do
3444 end do
3445
3446 ! Y-dir
3447 do k=1, 12
3448 do j=1, 12
3449 do i=1, 12
3450 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3451 + vec_in(i,2,k) * mat_tr(2,j) &
3452 + vec_in(i,3,k) * mat_tr(3,j) &
3453 + vec_in(i,4,k) * mat_tr(4,j) &
3454 + vec_in(i,5,k) * mat_tr(5,j) &
3455 + vec_in(i,6,k) * mat_tr(6,j) &
3456 + vec_in(i,7,k) * mat_tr(7,j) &
3457 + vec_in(i,8,k) * mat_tr(8,j) &
3458 + vec_in(i,9,k) * mat_tr(9,j) &
3459 + vec_in(i,10,k) * mat_tr(10,j) &
3460 + vec_in(i,11,k) * mat_tr(11,j) &
3461 + vec_in(i,12,k) * mat_tr(12,j)
3462 end do
3463 end do
3464 end do
3465
3466 ! Z-dir
3467 do k=1, 12
3468 do j=1, 12
3469 do i=1, 12
3470 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3471 + vec_in(i,j,2) * mat_tr(2,k) &
3472 + vec_in(i,j,3) * mat_tr(3,k) &
3473 + vec_in(i,j,4) * mat_tr(4,k) &
3474 + vec_in(i,j,5) * mat_tr(5,k) &
3475 + vec_in(i,j,6) * mat_tr(6,k) &
3476 + vec_in(i,j,7) * mat_tr(7,k) &
3477 + vec_in(i,j,8) * mat_tr(8,k) &
3478 + vec_in(i,j,9) * mat_tr(9,k) &
3479 + vec_in(i,j,10) * mat_tr(10,k) &
3480 + vec_in(i,j,11) * mat_tr(11,k) &
3481 + vec_in(i,j,12) * mat_tr(12,k)
3482 end do
3483 end do
3484 end do
3485
3486 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 3494 of file scale_element_operation_tensorprod3D_kernel.F90.

3497 implicit none
3498 real(RP), intent(in) :: Mat(12,12)
3499 real(RP), intent(in) :: Mat_tr(12,12)
3500 real(RP), intent(in) :: vec_in_x(12,12**2)
3501 real(RP), intent(in) :: vec_in_y(12,12,12)
3502 real(RP), intent(in) :: vec_in_z(12,12,12)
3503 real(RP), intent(out) :: vec_out_x(12,12**2)
3504 real(RP), intent(out) :: vec_out_y(12,12**2)
3505 real(RP), intent(out) :: vec_out_z(12,12**2)
3506
3507 integer :: i, j, k, jk
3508 real(RP) :: tmp1, tmp2, tmp3
3509 !----------------------------------------------------------
3510
3511 ! X-dir
3512
3513 do jk=1, 12**2
3514 do i=1, 12
3515 tmp1 = mat(i,1) * vec_in_x(1,jk) &
3516 + mat(i,2) * vec_in_x(2,jk) &
3517 + mat(i,3) * vec_in_x(3,jk) &
3518 + mat(i,4) * vec_in_x(4,jk)
3519 tmp2 = mat(i,5) * vec_in_x(5,jk) &
3520 + mat(i,6) * vec_in_x(6,jk) &
3521 + mat(i,7) * vec_in_x(7,jk) &
3522 + mat(i,8) * vec_in_x(8,jk)
3523 tmp3 = mat(i,9) * vec_in_x(9,jk) &
3524 + mat(i,10) * vec_in_x(10,jk) &
3525 + mat(i,11) * vec_in_x(11,jk) &
3526 + mat(i,12) * vec_in_x(12,jk)
3527 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
3528 end do
3529 end do
3530
3531 ! Y-dir
3532 do k=1, 12
3533 do j=1, 12
3534 jk = j + (k-1)*12
3535 do i=1, 12
3536 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
3537 + vec_in_y(i,2,k) * mat_tr(2,j) &
3538 + vec_in_y(i,3,k) * mat_tr(3,j) &
3539 + vec_in_y(i,4,k) * mat_tr(4,j)
3540 tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
3541 + vec_in_y(i,6,k) * mat_tr(6,j) &
3542 + vec_in_y(i,7,k) * mat_tr(7,j) &
3543 + vec_in_y(i,8,k) * mat_tr(8,j)
3544 tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
3545 + vec_in_y(i,10,k) * mat_tr(10,j) &
3546 + vec_in_y(i,11,k) * mat_tr(11,j) &
3547 + vec_in_y(i,12,k) * mat_tr(12,j)
3548 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
3549 end do
3550 end do
3551 end do
3552
3553 ! Z-dir
3554 do k=1, 12
3555 do j=1, 12
3556 jk = j + (k-1)*12
3557 do i=1, 12
3558 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
3559 + vec_in_z(i,j,2) * mat_tr(2,k) &
3560 + vec_in_z(i,j,3) * mat_tr(3,k) &
3561 + vec_in_z(i,j,4) * mat_tr(4,k)
3562 tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
3563 + vec_in_z(i,j,6) * mat_tr(6,k) &
3564 + vec_in_z(i,j,7) * mat_tr(7,k) &
3565 + vec_in_z(i,j,8) * mat_tr(8,k)
3566 tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
3567 + vec_in_z(i,j,10) * mat_tr(10,k) &
3568 + vec_in_z(i,j,11) * mat_tr(11,k) &
3569 + vec_in_z(i,j,12) * mat_tr(12,k)
3570 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
3571 end do
3572 end do
3573 end do
3574 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 3580 of file scale_element_operation_tensorprod3D_kernel.F90.

3582 implicit none
3583 real(RP), intent(in) :: Mat_h1D(12,12)
3584 real(RP), intent(in) :: Mat_h1D_tr(12,12)
3585 real(RP), intent(in) :: Mat_v1D_tr(12,12)
3586 real(RP), intent(in) :: vec_in(12,12,12)
3587 real(RP), intent(out) :: vec_work(12,12,12)
3588 real(RP), intent(out) :: vec_out(12,12,12)
3589
3590 integer :: i, j, k
3591 real(RP) :: tmp1, tmp2, tmp3
3592 !----------------------------------------------------------
3593
3594 ! X-dir
3595
3596 do k=1, 12
3597 do j=1, 12
3598 do i=1, 12
3599 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
3600 + mat_h1d(i,2) * vec_in(2,j,k) &
3601 + mat_h1d(i,3) * vec_in(3,j,k) &
3602 + mat_h1d(i,4) * vec_in(4,j,k)
3603 tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
3604 + mat_h1d(i,6) * vec_in(6,j,k) &
3605 + mat_h1d(i,7) * vec_in(7,j,k) &
3606 + mat_h1d(i,8) * vec_in(8,j,k)
3607 tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
3608 + mat_h1d(i,10) * vec_in(10,j,k) &
3609 + mat_h1d(i,11) * vec_in(11,j,k) &
3610 + mat_h1d(i,12) * vec_in(12,j,k)
3611 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3612 end do
3613 end do
3614 end do
3615
3616 ! Y-dir
3617 do k=1, 12
3618 do j=1, 12
3619 do i=1, 12
3620 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
3621 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
3622 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
3623 + vec_out(i,4,k) * mat_h1d_tr(4,j)
3624 tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
3625 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
3626 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
3627 + vec_out(i,8,k) * mat_h1d_tr(8,j)
3628 tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
3629 + vec_out(i,10,k) * mat_h1d_tr(10,j) &
3630 + vec_out(i,11,k) * mat_h1d_tr(11,j) &
3631 + vec_out(i,12,k) * mat_h1d_tr(12,j)
3632 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
3633 end do
3634 end do
3635 end do
3636
3637 ! Z-dir
3638 do k=1, 12
3639 do j=1, 12
3640 do i=1, 12
3641 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
3642 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
3643 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
3644 + vec_work(i,j,4) * mat_v1d_tr(4,k)
3645 tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
3646 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
3647 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
3648 + vec_work(i,j,8) * mat_v1d_tr(8,k)
3649 tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
3650 + vec_work(i,j,10) * mat_v1d_tr(10,k) &
3651 + vec_work(i,j,11) * mat_v1d_tr(11,k) &
3652 + vec_work(i,j,12) * mat_v1d_tr(12,k)
3653 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
3654 end do
3655 end do
3656 end do
3657
3658 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 3666 of file scale_element_operation_tensorprod3D_kernel.F90.

3667 implicit none
3668 real(RP), intent(in) :: Mat_x(13,13)
3669 real(RP), intent(in) :: vec_in(13,13**2)
3670 real(RP), intent(out) :: vec_out(13,13**2)
3671
3672 integer :: i, jk
3673 !----------------------------------------------------------
3674
3675 do jk=1, 13**2
3676 do i=1, 13
3677 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
3678 + mat_x(i,2) * vec_in(2,jk) &
3679 + mat_x(i,3) * vec_in(3,jk) &
3680 + mat_x(i,4) * vec_in(4,jk) &
3681 + mat_x(i,5) * vec_in(5,jk) &
3682 + mat_x(i,6) * vec_in(6,jk) &
3683 + mat_x(i,7) * vec_in(7,jk) &
3684 + mat_x(i,8) * vec_in(8,jk) &
3685 + mat_x(i,9) * vec_in(9,jk) &
3686 + mat_x(i,10) * vec_in(10,jk) &
3687 + mat_x(i,11) * vec_in(11,jk) &
3688 + mat_x(i,12) * vec_in(12,jk) &
3689 + mat_x(i,13) * vec_in(13,jk)
3690 end do
3691 end do
3692
3693 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 3700 of file scale_element_operation_tensorprod3D_kernel.F90.

3701 implicit none
3702 real(RP), intent(in) :: Mat_y_tr(13,13)
3703 real(RP), intent(in) :: vec_in(13,13,13)
3704 real(RP), intent(out) :: vec_out(13,13,13)
3705
3706 integer :: i, j, k
3707 !----------------------------------------------------------
3708
3709 do k=1, 13
3710 do j=1, 13
3711 do i=1, 13
3712 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
3713 + vec_in(i,2,k) * mat_y_tr(2,j) &
3714 + vec_in(i,3,k) * mat_y_tr(3,j) &
3715 + vec_in(i,4,k) * mat_y_tr(4,j) &
3716 + vec_in(i,5,k) * mat_y_tr(5,j) &
3717 + vec_in(i,6,k) * mat_y_tr(6,j) &
3718 + vec_in(i,7,k) * mat_y_tr(7,j) &
3719 + vec_in(i,8,k) * mat_y_tr(8,j) &
3720 + vec_in(i,9,k) * mat_y_tr(9,j) &
3721 + vec_in(i,10,k) * mat_y_tr(10,j) &
3722 + vec_in(i,11,k) * mat_y_tr(11,j) &
3723 + vec_in(i,12,k) * mat_y_tr(12,j) &
3724 + vec_in(i,13,k) * mat_y_tr(13,j)
3725 end do
3726 end do
3727 end do
3728
3729 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 3736 of file scale_element_operation_tensorprod3D_kernel.F90.

3737 implicit none
3738 real(RP), intent(in) :: Mat_z_tr(13,13)
3739 real(RP), intent(in) :: vec_in(13,13,13)
3740 real(RP), intent(out) :: vec_out(13,13,13)
3741
3742 integer :: i, j, k
3743 !----------------------------------------------------------
3744
3745 do k=1, 13
3746 do j=1, 13
3747 do i=1, 13
3748 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
3749 + vec_in(i,j,2) * mat_z_tr(2,k) &
3750 + vec_in(i,j,3) * mat_z_tr(3,k) &
3751 + vec_in(i,j,4) * mat_z_tr(4,k) &
3752 + vec_in(i,j,5) * mat_z_tr(5,k) &
3753 + vec_in(i,j,6) * mat_z_tr(6,k) &
3754 + vec_in(i,j,7) * mat_z_tr(7,k) &
3755 + vec_in(i,j,8) * mat_z_tr(8,k) &
3756 + vec_in(i,j,9) * mat_z_tr(9,k) &
3757 + vec_in(i,j,10) * mat_z_tr(10,k) &
3758 + vec_in(i,j,11) * mat_z_tr(11,k) &
3759 + vec_in(i,j,12) * mat_z_tr(12,k) &
3760 + vec_in(i,j,13) * mat_z_tr(13,k)
3761 end do
3762 end do
3763 end do
3764
3765 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 associated with Lift operations with hexahedral element of p=12.

Definition at line 3771 of file scale_element_operation_tensorprod3D_kernel.F90.

3772 implicit none
3773 real(RP), intent(in) :: Lift(13,13,13,6)
3774 real(RP), intent(in) :: vec_in(13,13,6)
3775 real(RP), intent(out) :: vec_out(13,13,13)
3776
3777 integer :: i, j, k
3778 !----------------------------------------------------------
3779
3780 do k=1, 13
3781 do j=1, 13
3782 do i=1, 13
3783 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
3784 + lift(i,j,k,2) * vec_in(j,k,2) &
3785 + lift(i,j,k,3) * vec_in(i,k,3) &
3786 + lift(i,j,k,4) * vec_in(j,k,4) &
3787 + lift(i,j,k,5) * vec_in(i,j,5) &
3788 + lift(i,j,k,6) * vec_in(i,j,6)
3789 end do
3790 end do
3791 end do
3792
3793 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 3801 of file scale_element_operation_tensorprod3D_kernel.F90.

3803 implicit none
3804 real(RP), intent(in) :: Mat(13,13)
3805 real(RP), intent(in) :: Mat_tr(13,13)
3806 real(RP), intent(in) :: vec_in_(13,13**2)
3807 real(RP), intent(in) :: vec_in(13,13,13)
3808 real(RP), intent(out) :: vec_out_x(13,13**2)
3809 real(RP), intent(out) :: vec_out_y(13,13,13)
3810 real(RP), intent(out) :: vec_out_z(13,13,13)
3811
3812 integer :: i, j, k, jk
3813 !----------------------------------------------------------
3814
3815 ! X-dir
3816
3817 do jk=1, 13**2
3818 do i=1, 13
3819 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
3820 + mat(i,2) * vec_in_(2,jk) &
3821 + mat(i,3) * vec_in_(3,jk) &
3822 + mat(i,4) * vec_in_(4,jk) &
3823 + mat(i,5) * vec_in_(5,jk) &
3824 + mat(i,6) * vec_in_(6,jk) &
3825 + mat(i,7) * vec_in_(7,jk) &
3826 + mat(i,8) * vec_in_(8,jk) &
3827 + mat(i,9) * vec_in_(9,jk) &
3828 + mat(i,10) * vec_in_(10,jk) &
3829 + mat(i,11) * vec_in_(11,jk) &
3830 + mat(i,12) * vec_in_(12,jk) &
3831 + mat(i,13) * vec_in_(13,jk)
3832 end do
3833 end do
3834
3835 ! Y-dir
3836 do k=1, 13
3837 do j=1, 13
3838 do i=1, 13
3839 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3840 + vec_in(i,2,k) * mat_tr(2,j) &
3841 + vec_in(i,3,k) * mat_tr(3,j) &
3842 + vec_in(i,4,k) * mat_tr(4,j) &
3843 + vec_in(i,5,k) * mat_tr(5,j) &
3844 + vec_in(i,6,k) * mat_tr(6,j) &
3845 + vec_in(i,7,k) * mat_tr(7,j) &
3846 + vec_in(i,8,k) * mat_tr(8,j) &
3847 + vec_in(i,9,k) * mat_tr(9,j) &
3848 + vec_in(i,10,k) * mat_tr(10,j) &
3849 + vec_in(i,11,k) * mat_tr(11,j) &
3850 + vec_in(i,12,k) * mat_tr(12,j) &
3851 + vec_in(i,13,k) * mat_tr(13,j)
3852 end do
3853 end do
3854 end do
3855
3856 ! Z-dir
3857 do k=1, 13
3858 do j=1, 13
3859 do i=1, 13
3860 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
3861 + vec_in(i,j,2) * mat_tr(2,k) &
3862 + vec_in(i,j,3) * mat_tr(3,k) &
3863 + vec_in(i,j,4) * mat_tr(4,k) &
3864 + vec_in(i,j,5) * mat_tr(5,k) &
3865 + vec_in(i,j,6) * mat_tr(6,k) &
3866 + vec_in(i,j,7) * mat_tr(7,k) &
3867 + vec_in(i,j,8) * mat_tr(8,k) &
3868 + vec_in(i,j,9) * mat_tr(9,k) &
3869 + vec_in(i,j,10) * mat_tr(10,k) &
3870 + vec_in(i,j,11) * mat_tr(11,k) &
3871 + vec_in(i,j,12) * mat_tr(12,k) &
3872 + vec_in(i,j,13) * mat_tr(13,k)
3873 end do
3874 end do
3875 end do
3876
3877 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 3885 of file scale_element_operation_tensorprod3D_kernel.F90.

3888 implicit none
3889 real(RP), intent(in) :: Mat(13,13)
3890 real(RP), intent(in) :: Mat_tr(13,13)
3891 real(RP), intent(in) :: vec_in_x(13,13**2)
3892 real(RP), intent(in) :: vec_in_y(13,13,13)
3893 real(RP), intent(in) :: vec_in_z(13,13,13)
3894 real(RP), intent(out) :: vec_out_x(13,13**2)
3895 real(RP), intent(out) :: vec_out_y(13,13**2)
3896 real(RP), intent(out) :: vec_out_z(13,13**2)
3897
3898 integer :: i, j, k, jk
3899 real(RP) :: tmp1, tmp2, tmp3
3900 !----------------------------------------------------------
3901
3902 ! X-dir
3903
3904 do jk=1, 13**2
3905 do i=1, 13
3906 tmp1 = mat(i,1) * vec_in_x(1,jk) &
3907 + mat(i,2) * vec_in_x(2,jk) &
3908 + mat(i,3) * vec_in_x(3,jk) &
3909 + mat(i,4) * vec_in_x(4,jk)
3910 tmp2 = mat(i,5) * vec_in_x(5,jk) &
3911 + mat(i,6) * vec_in_x(6,jk) &
3912 + mat(i,7) * vec_in_x(7,jk) &
3913 + mat(i,8) * vec_in_x(8,jk)
3914 tmp3 = mat(i,9) * vec_in_x(9,jk) &
3915 + mat(i,10) * vec_in_x(10,jk) &
3916 + mat(i,11) * vec_in_x(11,jk) &
3917 + mat(i,12) * vec_in_x(12,jk) &
3918 + mat(i,13) * vec_in_x(13,jk)
3919 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
3920 end do
3921 end do
3922
3923 ! Y-dir
3924 do k=1, 13
3925 do j=1, 13
3926 jk = j + (k-1)*13
3927 do i=1, 13
3928 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
3929 + vec_in_y(i,2,k) * mat_tr(2,j) &
3930 + vec_in_y(i,3,k) * mat_tr(3,j) &
3931 + vec_in_y(i,4,k) * mat_tr(4,j)
3932 tmp2 = vec_in_y(i,5,k) * mat_tr(5,j) &
3933 + vec_in_y(i,6,k) * mat_tr(6,j) &
3934 + vec_in_y(i,7,k) * mat_tr(7,j) &
3935 + vec_in_y(i,8,k) * mat_tr(8,j)
3936 tmp3 = vec_in_y(i,9,k) * mat_tr(9,j) &
3937 + vec_in_y(i,10,k) * mat_tr(10,j) &
3938 + vec_in_y(i,11,k) * mat_tr(11,j) &
3939 + vec_in_y(i,12,k) * mat_tr(12,j) &
3940 + vec_in_y(i,13,k) * mat_tr(13,j)
3941 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
3942 end do
3943 end do
3944 end do
3945
3946 ! Z-dir
3947 do k=1, 13
3948 do j=1, 13
3949 jk = j + (k-1)*13
3950 do i=1, 13
3951 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
3952 + vec_in_z(i,j,2) * mat_tr(2,k) &
3953 + vec_in_z(i,j,3) * mat_tr(3,k) &
3954 + vec_in_z(i,j,4) * mat_tr(4,k)
3955 tmp2 = vec_in_z(i,j,5) * mat_tr(5,k) &
3956 + vec_in_z(i,j,6) * mat_tr(6,k) &
3957 + vec_in_z(i,j,7) * mat_tr(7,k) &
3958 + vec_in_z(i,j,8) * mat_tr(8,k)
3959 tmp3 = vec_in_z(i,j,9) * mat_tr(9,k) &
3960 + vec_in_z(i,j,10) * mat_tr(10,k) &
3961 + vec_in_z(i,j,11) * mat_tr(11,k) &
3962 + vec_in_z(i,j,12) * mat_tr(12,k) &
3963 + vec_in_z(i,j,13) * mat_tr(13,k)
3964 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
3965 end do
3966 end do
3967 end do
3968 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 3974 of file scale_element_operation_tensorprod3D_kernel.F90.

3976 implicit none
3977 real(RP), intent(in) :: Mat_h1D(13,13)
3978 real(RP), intent(in) :: Mat_h1D_tr(13,13)
3979 real(RP), intent(in) :: Mat_v1D_tr(13,13)
3980 real(RP), intent(in) :: vec_in(13,13,13)
3981 real(RP), intent(out) :: vec_work(13,13,13)
3982 real(RP), intent(out) :: vec_out(13,13,13)
3983
3984 integer :: i, j, k
3985 real(RP) :: tmp1, tmp2, tmp3
3986 !----------------------------------------------------------
3987
3988 ! X-dir
3989
3990 do k=1, 13
3991 do j=1, 13
3992 do i=1, 13
3993 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
3994 + mat_h1d(i,2) * vec_in(2,j,k) &
3995 + mat_h1d(i,3) * vec_in(3,j,k) &
3996 + mat_h1d(i,4) * vec_in(4,j,k)
3997 tmp2 = mat_h1d(i,5) * vec_in(5,j,k) &
3998 + mat_h1d(i,6) * vec_in(6,j,k) &
3999 + mat_h1d(i,7) * vec_in(7,j,k) &
4000 + mat_h1d(i,8) * vec_in(8,j,k)
4001 tmp3 = mat_h1d(i,9) * vec_in(9,j,k) &
4002 + mat_h1d(i,10) * vec_in(10,j,k) &
4003 + mat_h1d(i,11) * vec_in(11,j,k) &
4004 + mat_h1d(i,12) * vec_in(12,j,k) &
4005 + mat_h1d(i,13) * vec_in(13,j,k)
4006 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4007 end do
4008 end do
4009 end do
4010
4011 ! Y-dir
4012 do k=1, 13
4013 do j=1, 13
4014 do i=1, 13
4015 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
4016 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
4017 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
4018 + vec_out(i,4,k) * mat_h1d_tr(4,j)
4019 tmp2 = vec_out(i,5,k) * mat_h1d_tr(5,j) &
4020 + vec_out(i,6,k) * mat_h1d_tr(6,j) &
4021 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
4022 + vec_out(i,8,k) * mat_h1d_tr(8,j)
4023 tmp3 = vec_out(i,9,k) * mat_h1d_tr(9,j) &
4024 + vec_out(i,10,k) * mat_h1d_tr(10,j) &
4025 + vec_out(i,11,k) * mat_h1d_tr(11,j) &
4026 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
4027 + vec_out(i,13,k) * mat_h1d_tr(13,j)
4028 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
4029 end do
4030 end do
4031 end do
4032
4033 ! Z-dir
4034 do k=1, 13
4035 do j=1, 13
4036 do i=1, 13
4037 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
4038 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
4039 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
4040 + vec_work(i,j,4) * mat_v1d_tr(4,k)
4041 tmp2 = vec_work(i,j,5) * mat_v1d_tr(5,k) &
4042 + vec_work(i,j,6) * mat_v1d_tr(6,k) &
4043 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
4044 + vec_work(i,j,8) * mat_v1d_tr(8,k)
4045 tmp3 = vec_work(i,j,9) * mat_v1d_tr(9,k) &
4046 + vec_work(i,j,10) * mat_v1d_tr(10,k) &
4047 + vec_work(i,j,11) * mat_v1d_tr(11,k) &
4048 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
4049 + vec_work(i,j,13) * mat_v1d_tr(13,k)
4050 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4051 end do
4052 end do
4053 end do
4054
4055 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 4063 of file scale_element_operation_tensorprod3D_kernel.F90.

4064 implicit none
4065 real(RP), intent(in) :: Mat_x(14,14)
4066 real(RP), intent(in) :: vec_in(14,14**2)
4067 real(RP), intent(out) :: vec_out(14,14**2)
4068
4069 integer :: i, jk
4070 !----------------------------------------------------------
4071
4072 do jk=1, 14**2
4073 do i=1, 14
4074 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
4075 + mat_x(i,2) * vec_in(2,jk) &
4076 + mat_x(i,3) * vec_in(3,jk) &
4077 + mat_x(i,4) * vec_in(4,jk) &
4078 + mat_x(i,5) * vec_in(5,jk) &
4079 + mat_x(i,6) * vec_in(6,jk) &
4080 + mat_x(i,7) * vec_in(7,jk) &
4081 + mat_x(i,8) * vec_in(8,jk) &
4082 + mat_x(i,9) * vec_in(9,jk) &
4083 + mat_x(i,10) * vec_in(10,jk) &
4084 + mat_x(i,11) * vec_in(11,jk) &
4085 + mat_x(i,12) * vec_in(12,jk) &
4086 + mat_x(i,13) * vec_in(13,jk) &
4087 + mat_x(i,14) * vec_in(14,jk)
4088 end do
4089 end do
4090
4091 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 4098 of file scale_element_operation_tensorprod3D_kernel.F90.

4099 implicit none
4100 real(RP), intent(in) :: Mat_y_tr(14,14)
4101 real(RP), intent(in) :: vec_in(14,14,14)
4102 real(RP), intent(out) :: vec_out(14,14,14)
4103
4104 integer :: i, j, k
4105 !----------------------------------------------------------
4106
4107 do k=1, 14
4108 do j=1, 14
4109 do i=1, 14
4110 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
4111 + vec_in(i,2,k) * mat_y_tr(2,j) &
4112 + vec_in(i,3,k) * mat_y_tr(3,j) &
4113 + vec_in(i,4,k) * mat_y_tr(4,j) &
4114 + vec_in(i,5,k) * mat_y_tr(5,j) &
4115 + vec_in(i,6,k) * mat_y_tr(6,j) &
4116 + vec_in(i,7,k) * mat_y_tr(7,j) &
4117 + vec_in(i,8,k) * mat_y_tr(8,j) &
4118 + vec_in(i,9,k) * mat_y_tr(9,j) &
4119 + vec_in(i,10,k) * mat_y_tr(10,j) &
4120 + vec_in(i,11,k) * mat_y_tr(11,j) &
4121 + vec_in(i,12,k) * mat_y_tr(12,j) &
4122 + vec_in(i,13,k) * mat_y_tr(13,j) &
4123 + vec_in(i,14,k) * mat_y_tr(14,j)
4124 end do
4125 end do
4126 end do
4127
4128 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 4135 of file scale_element_operation_tensorprod3D_kernel.F90.

4136 implicit none
4137 real(RP), intent(in) :: Mat_z_tr(14,14)
4138 real(RP), intent(in) :: vec_in(14,14,14)
4139 real(RP), intent(out) :: vec_out(14,14,14)
4140
4141 integer :: i, j, k
4142 !----------------------------------------------------------
4143
4144 do k=1, 14
4145 do j=1, 14
4146 do i=1, 14
4147 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
4148 + vec_in(i,j,2) * mat_z_tr(2,k) &
4149 + vec_in(i,j,3) * mat_z_tr(3,k) &
4150 + vec_in(i,j,4) * mat_z_tr(4,k) &
4151 + vec_in(i,j,5) * mat_z_tr(5,k) &
4152 + vec_in(i,j,6) * mat_z_tr(6,k) &
4153 + vec_in(i,j,7) * mat_z_tr(7,k) &
4154 + vec_in(i,j,8) * mat_z_tr(8,k) &
4155 + vec_in(i,j,9) * mat_z_tr(9,k) &
4156 + vec_in(i,j,10) * mat_z_tr(10,k) &
4157 + vec_in(i,j,11) * mat_z_tr(11,k) &
4158 + vec_in(i,j,12) * mat_z_tr(12,k) &
4159 + vec_in(i,j,13) * mat_z_tr(13,k) &
4160 + vec_in(i,j,14) * mat_z_tr(14,k)
4161 end do
4162 end do
4163 end do
4164
4165 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 associated with Lift operations with hexahedral element of p=13.

Definition at line 4171 of file scale_element_operation_tensorprod3D_kernel.F90.

4172 implicit none
4173 real(RP), intent(in) :: Lift(14,14,14,6)
4174 real(RP), intent(in) :: vec_in(14,14,6)
4175 real(RP), intent(out) :: vec_out(14,14,14)
4176
4177 integer :: i, j, k
4178 !----------------------------------------------------------
4179
4180 do k=1, 14
4181 do j=1, 14
4182 do i=1, 14
4183 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
4184 + lift(i,j,k,2) * vec_in(j,k,2) &
4185 + lift(i,j,k,3) * vec_in(i,k,3) &
4186 + lift(i,j,k,4) * vec_in(j,k,4) &
4187 + lift(i,j,k,5) * vec_in(i,j,5) &
4188 + lift(i,j,k,6) * vec_in(i,j,6)
4189 end do
4190 end do
4191 end do
4192
4193 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 4201 of file scale_element_operation_tensorprod3D_kernel.F90.

4203 implicit none
4204 real(RP), intent(in) :: Mat(14,14)
4205 real(RP), intent(in) :: Mat_tr(14,14)
4206 real(RP), intent(in) :: vec_in_(14,14**2)
4207 real(RP), intent(in) :: vec_in(14,14,14)
4208 real(RP), intent(out) :: vec_out_x(14,14**2)
4209 real(RP), intent(out) :: vec_out_y(14,14,14)
4210 real(RP), intent(out) :: vec_out_z(14,14,14)
4211
4212 integer :: i, j, k, jk
4213 !----------------------------------------------------------
4214
4215 ! X-dir
4216
4217 do jk=1, 14**2
4218 do i=1, 14
4219 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
4220 + mat(i,2) * vec_in_(2,jk) &
4221 + mat(i,3) * vec_in_(3,jk) &
4222 + mat(i,4) * vec_in_(4,jk) &
4223 + mat(i,5) * vec_in_(5,jk) &
4224 + mat(i,6) * vec_in_(6,jk) &
4225 + mat(i,7) * vec_in_(7,jk) &
4226 + mat(i,8) * vec_in_(8,jk) &
4227 + mat(i,9) * vec_in_(9,jk) &
4228 + mat(i,10) * vec_in_(10,jk) &
4229 + mat(i,11) * vec_in_(11,jk) &
4230 + mat(i,12) * vec_in_(12,jk) &
4231 + mat(i,13) * vec_in_(13,jk) &
4232 + mat(i,14) * vec_in_(14,jk)
4233 end do
4234 end do
4235
4236 ! Y-dir
4237 do k=1, 14
4238 do j=1, 14
4239 do i=1, 14
4240 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4241 + vec_in(i,2,k) * mat_tr(2,j) &
4242 + vec_in(i,3,k) * mat_tr(3,j) &
4243 + vec_in(i,4,k) * mat_tr(4,j) &
4244 + vec_in(i,5,k) * mat_tr(5,j) &
4245 + vec_in(i,6,k) * mat_tr(6,j) &
4246 + vec_in(i,7,k) * mat_tr(7,j) &
4247 + vec_in(i,8,k) * mat_tr(8,j) &
4248 + vec_in(i,9,k) * mat_tr(9,j) &
4249 + vec_in(i,10,k) * mat_tr(10,j) &
4250 + vec_in(i,11,k) * mat_tr(11,j) &
4251 + vec_in(i,12,k) * mat_tr(12,j) &
4252 + vec_in(i,13,k) * mat_tr(13,j) &
4253 + vec_in(i,14,k) * mat_tr(14,j)
4254 end do
4255 end do
4256 end do
4257
4258 ! Z-dir
4259 do k=1, 14
4260 do j=1, 14
4261 do i=1, 14
4262 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4263 + vec_in(i,j,2) * mat_tr(2,k) &
4264 + vec_in(i,j,3) * mat_tr(3,k) &
4265 + vec_in(i,j,4) * mat_tr(4,k) &
4266 + vec_in(i,j,5) * mat_tr(5,k) &
4267 + vec_in(i,j,6) * mat_tr(6,k) &
4268 + vec_in(i,j,7) * mat_tr(7,k) &
4269 + vec_in(i,j,8) * mat_tr(8,k) &
4270 + vec_in(i,j,9) * mat_tr(9,k) &
4271 + vec_in(i,j,10) * mat_tr(10,k) &
4272 + vec_in(i,j,11) * mat_tr(11,k) &
4273 + vec_in(i,j,12) * mat_tr(12,k) &
4274 + vec_in(i,j,13) * mat_tr(13,k) &
4275 + vec_in(i,j,14) * mat_tr(14,k)
4276 end do
4277 end do
4278 end do
4279
4280 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 4288 of file scale_element_operation_tensorprod3D_kernel.F90.

4291 implicit none
4292 real(RP), intent(in) :: Mat(14,14)
4293 real(RP), intent(in) :: Mat_tr(14,14)
4294 real(RP), intent(in) :: vec_in_x(14,14**2)
4295 real(RP), intent(in) :: vec_in_y(14,14,14)
4296 real(RP), intent(in) :: vec_in_z(14,14,14)
4297 real(RP), intent(out) :: vec_out_x(14,14**2)
4298 real(RP), intent(out) :: vec_out_y(14,14**2)
4299 real(RP), intent(out) :: vec_out_z(14,14**2)
4300
4301 integer :: i, j, k, jk
4302 real(RP) :: tmp1, tmp2, tmp3
4303 !----------------------------------------------------------
4304
4305 ! X-dir
4306
4307 do jk=1, 14**2
4308 do i=1, 14
4309 tmp1 = mat(i,1) * vec_in_x(1,jk) &
4310 + mat(i,2) * vec_in_x(2,jk) &
4311 + mat(i,3) * vec_in_x(3,jk) &
4312 + mat(i,4) * vec_in_x(4,jk) &
4313 + mat(i,5) * vec_in_x(5,jk)
4314 tmp2 = mat(i,6) * vec_in_x(6,jk) &
4315 + mat(i,7) * vec_in_x(7,jk) &
4316 + mat(i,8) * vec_in_x(8,jk) &
4317 + mat(i,9) * vec_in_x(9,jk) &
4318 + mat(i,10) * vec_in_x(10,jk)
4319 tmp3 = mat(i,11) * vec_in_x(11,jk) &
4320 + mat(i,12) * vec_in_x(12,jk) &
4321 + mat(i,13) * vec_in_x(13,jk) &
4322 + mat(i,14) * vec_in_x(14,jk)
4323 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
4324 end do
4325 end do
4326
4327 ! Y-dir
4328 do k=1, 14
4329 do j=1, 14
4330 jk = j + (k-1)*14
4331 do i=1, 14
4332 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
4333 + vec_in_y(i,2,k) * mat_tr(2,j) &
4334 + vec_in_y(i,3,k) * mat_tr(3,j) &
4335 + vec_in_y(i,4,k) * mat_tr(4,j) &
4336 + vec_in_y(i,5,k) * mat_tr(5,j)
4337 tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
4338 + vec_in_y(i,7,k) * mat_tr(7,j) &
4339 + vec_in_y(i,8,k) * mat_tr(8,j) &
4340 + vec_in_y(i,9,k) * mat_tr(9,j) &
4341 + vec_in_y(i,10,k) * mat_tr(10,j)
4342 tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
4343 + vec_in_y(i,12,k) * mat_tr(12,j) &
4344 + vec_in_y(i,13,k) * mat_tr(13,j) &
4345 + vec_in_y(i,14,k) * mat_tr(14,j)
4346 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
4347 end do
4348 end do
4349 end do
4350
4351 ! Z-dir
4352 do k=1, 14
4353 do j=1, 14
4354 jk = j + (k-1)*14
4355 do i=1, 14
4356 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
4357 + vec_in_z(i,j,2) * mat_tr(2,k) &
4358 + vec_in_z(i,j,3) * mat_tr(3,k) &
4359 + vec_in_z(i,j,4) * mat_tr(4,k) &
4360 + vec_in_z(i,j,5) * mat_tr(5,k)
4361 tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
4362 + vec_in_z(i,j,7) * mat_tr(7,k) &
4363 + vec_in_z(i,j,8) * mat_tr(8,k) &
4364 + vec_in_z(i,j,9) * mat_tr(9,k) &
4365 + vec_in_z(i,j,10) * mat_tr(10,k)
4366 tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
4367 + vec_in_z(i,j,12) * mat_tr(12,k) &
4368 + vec_in_z(i,j,13) * mat_tr(13,k) &
4369 + vec_in_z(i,j,14) * mat_tr(14,k)
4370 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
4371 end do
4372 end do
4373 end do
4374 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 4380 of file scale_element_operation_tensorprod3D_kernel.F90.

4382 implicit none
4383 real(RP), intent(in) :: Mat_h1D(14,14)
4384 real(RP), intent(in) :: Mat_h1D_tr(14,14)
4385 real(RP), intent(in) :: Mat_v1D_tr(14,14)
4386 real(RP), intent(in) :: vec_in(14,14,14)
4387 real(RP), intent(out) :: vec_work(14,14,14)
4388 real(RP), intent(out) :: vec_out(14,14,14)
4389
4390 integer :: i, j, k
4391 real(RP) :: tmp1, tmp2, tmp3
4392 !----------------------------------------------------------
4393
4394 ! X-dir
4395
4396 do k=1, 14
4397 do j=1, 14
4398 do i=1, 14
4399 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
4400 + mat_h1d(i,2) * vec_in(2,j,k) &
4401 + mat_h1d(i,3) * vec_in(3,j,k) &
4402 + mat_h1d(i,4) * vec_in(4,j,k) &
4403 + mat_h1d(i,5) * vec_in(5,j,k)
4404 tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
4405 + mat_h1d(i,7) * vec_in(7,j,k) &
4406 + mat_h1d(i,8) * vec_in(8,j,k) &
4407 + mat_h1d(i,9) * vec_in(9,j,k) &
4408 + mat_h1d(i,10) * vec_in(10,j,k)
4409 tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
4410 + mat_h1d(i,12) * vec_in(12,j,k) &
4411 + mat_h1d(i,13) * vec_in(13,j,k) &
4412 + mat_h1d(i,14) * vec_in(14,j,k)
4413 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4414 end do
4415 end do
4416 end do
4417
4418 ! Y-dir
4419 do k=1, 14
4420 do j=1, 14
4421 do i=1, 14
4422 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
4423 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
4424 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
4425 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
4426 + vec_out(i,5,k) * mat_h1d_tr(5,j)
4427 tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
4428 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
4429 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
4430 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
4431 + vec_out(i,10,k) * mat_h1d_tr(10,j)
4432 tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
4433 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
4434 + vec_out(i,13,k) * mat_h1d_tr(13,j) &
4435 + vec_out(i,14,k) * mat_h1d_tr(14,j)
4436 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
4437 end do
4438 end do
4439 end do
4440
4441 ! Z-dir
4442 do k=1, 14
4443 do j=1, 14
4444 do i=1, 14
4445 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
4446 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
4447 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
4448 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
4449 + vec_work(i,j,5) * mat_v1d_tr(5,k)
4450 tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
4451 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
4452 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
4453 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
4454 + vec_work(i,j,10) * mat_v1d_tr(10,k)
4455 tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
4456 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
4457 + vec_work(i,j,13) * mat_v1d_tr(13,k) &
4458 + vec_work(i,j,14) * mat_v1d_tr(14,k)
4459 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4460 end do
4461 end do
4462 end do
4463
4464 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 4472 of file scale_element_operation_tensorprod3D_kernel.F90.

4473 implicit none
4474 real(RP), intent(in) :: Mat_x(15,15)
4475 real(RP), intent(in) :: vec_in(15,15**2)
4476 real(RP), intent(out) :: vec_out(15,15**2)
4477
4478 integer :: i, jk
4479 !----------------------------------------------------------
4480
4481 do jk=1, 15**2
4482 do i=1, 15
4483 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
4484 + mat_x(i,2) * vec_in(2,jk) &
4485 + mat_x(i,3) * vec_in(3,jk) &
4486 + mat_x(i,4) * vec_in(4,jk) &
4487 + mat_x(i,5) * vec_in(5,jk) &
4488 + mat_x(i,6) * vec_in(6,jk) &
4489 + mat_x(i,7) * vec_in(7,jk) &
4490 + mat_x(i,8) * vec_in(8,jk) &
4491 + mat_x(i,9) * vec_in(9,jk) &
4492 + mat_x(i,10) * vec_in(10,jk) &
4493 + mat_x(i,11) * vec_in(11,jk) &
4494 + mat_x(i,12) * vec_in(12,jk) &
4495 + mat_x(i,13) * vec_in(13,jk) &
4496 + mat_x(i,14) * vec_in(14,jk) &
4497 + mat_x(i,15) * vec_in(15,jk)
4498 end do
4499 end do
4500
4501 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 4508 of file scale_element_operation_tensorprod3D_kernel.F90.

4509 implicit none
4510 real(RP), intent(in) :: Mat_y_tr(15,15)
4511 real(RP), intent(in) :: vec_in(15,15,15)
4512 real(RP), intent(out) :: vec_out(15,15,15)
4513
4514 integer :: i, j, k
4515 !----------------------------------------------------------
4516
4517 do k=1, 15
4518 do j=1, 15
4519 do i=1, 15
4520 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
4521 + vec_in(i,2,k) * mat_y_tr(2,j) &
4522 + vec_in(i,3,k) * mat_y_tr(3,j) &
4523 + vec_in(i,4,k) * mat_y_tr(4,j) &
4524 + vec_in(i,5,k) * mat_y_tr(5,j) &
4525 + vec_in(i,6,k) * mat_y_tr(6,j) &
4526 + vec_in(i,7,k) * mat_y_tr(7,j) &
4527 + vec_in(i,8,k) * mat_y_tr(8,j) &
4528 + vec_in(i,9,k) * mat_y_tr(9,j) &
4529 + vec_in(i,10,k) * mat_y_tr(10,j) &
4530 + vec_in(i,11,k) * mat_y_tr(11,j) &
4531 + vec_in(i,12,k) * mat_y_tr(12,j) &
4532 + vec_in(i,13,k) * mat_y_tr(13,j) &
4533 + vec_in(i,14,k) * mat_y_tr(14,j) &
4534 + vec_in(i,15,k) * mat_y_tr(15,j)
4535 end do
4536 end do
4537 end do
4538
4539 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 4546 of file scale_element_operation_tensorprod3D_kernel.F90.

4547 implicit none
4548 real(RP), intent(in) :: Mat_z_tr(15,15)
4549 real(RP), intent(in) :: vec_in(15,15,15)
4550 real(RP), intent(out) :: vec_out(15,15,15)
4551
4552 integer :: i, j, k
4553 !----------------------------------------------------------
4554
4555 do k=1, 15
4556 do j=1, 15
4557 do i=1, 15
4558 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
4559 + vec_in(i,j,2) * mat_z_tr(2,k) &
4560 + vec_in(i,j,3) * mat_z_tr(3,k) &
4561 + vec_in(i,j,4) * mat_z_tr(4,k) &
4562 + vec_in(i,j,5) * mat_z_tr(5,k) &
4563 + vec_in(i,j,6) * mat_z_tr(6,k) &
4564 + vec_in(i,j,7) * mat_z_tr(7,k) &
4565 + vec_in(i,j,8) * mat_z_tr(8,k) &
4566 + vec_in(i,j,9) * mat_z_tr(9,k) &
4567 + vec_in(i,j,10) * mat_z_tr(10,k) &
4568 + vec_in(i,j,11) * mat_z_tr(11,k) &
4569 + vec_in(i,j,12) * mat_z_tr(12,k) &
4570 + vec_in(i,j,13) * mat_z_tr(13,k) &
4571 + vec_in(i,j,14) * mat_z_tr(14,k) &
4572 + vec_in(i,j,15) * mat_z_tr(15,k)
4573 end do
4574 end do
4575 end do
4576
4577 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 associated with Lift operations with hexahedral element of p=14.

Definition at line 4583 of file scale_element_operation_tensorprod3D_kernel.F90.

4584 implicit none
4585 real(RP), intent(in) :: Lift(15,15,15,6)
4586 real(RP), intent(in) :: vec_in(15,15,6)
4587 real(RP), intent(out) :: vec_out(15,15,15)
4588
4589 integer :: i, j, k
4590 !----------------------------------------------------------
4591
4592 do k=1, 15
4593 do j=1, 15
4594 do i=1, 15
4595 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
4596 + lift(i,j,k,2) * vec_in(j,k,2) &
4597 + lift(i,j,k,3) * vec_in(i,k,3) &
4598 + lift(i,j,k,4) * vec_in(j,k,4) &
4599 + lift(i,j,k,5) * vec_in(i,j,5) &
4600 + lift(i,j,k,6) * vec_in(i,j,6)
4601 end do
4602 end do
4603 end do
4604
4605 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 4613 of file scale_element_operation_tensorprod3D_kernel.F90.

4615 implicit none
4616 real(RP), intent(in) :: Mat(15,15)
4617 real(RP), intent(in) :: Mat_tr(15,15)
4618 real(RP), intent(in) :: vec_in_(15,15**2)
4619 real(RP), intent(in) :: vec_in(15,15,15)
4620 real(RP), intent(out) :: vec_out_x(15,15**2)
4621 real(RP), intent(out) :: vec_out_y(15,15,15)
4622 real(RP), intent(out) :: vec_out_z(15,15,15)
4623
4624 integer :: i, j, k, jk
4625 !----------------------------------------------------------
4626
4627 ! X-dir
4628
4629 do jk=1, 15**2
4630 do i=1, 15
4631 vec_out_x(i,jk) = mat(i,1) * vec_in_(1,jk) &
4632 + mat(i,2) * vec_in_(2,jk) &
4633 + mat(i,3) * vec_in_(3,jk) &
4634 + mat(i,4) * vec_in_(4,jk) &
4635 + mat(i,5) * vec_in_(5,jk) &
4636 + mat(i,6) * vec_in_(6,jk) &
4637 + mat(i,7) * vec_in_(7,jk) &
4638 + mat(i,8) * vec_in_(8,jk) &
4639 + mat(i,9) * vec_in_(9,jk) &
4640 + mat(i,10) * vec_in_(10,jk) &
4641 + mat(i,11) * vec_in_(11,jk) &
4642 + mat(i,12) * vec_in_(12,jk) &
4643 + mat(i,13) * vec_in_(13,jk) &
4644 + mat(i,14) * vec_in_(14,jk) &
4645 + mat(i,15) * vec_in_(15,jk)
4646 end do
4647 end do
4648
4649 ! Y-dir
4650 do k=1, 15
4651 do j=1, 15
4652 do i=1, 15
4653 vec_out_y(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4654 + vec_in(i,2,k) * mat_tr(2,j) &
4655 + vec_in(i,3,k) * mat_tr(3,j) &
4656 + vec_in(i,4,k) * mat_tr(4,j) &
4657 + vec_in(i,5,k) * mat_tr(5,j) &
4658 + vec_in(i,6,k) * mat_tr(6,j) &
4659 + vec_in(i,7,k) * mat_tr(7,j) &
4660 + vec_in(i,8,k) * mat_tr(8,j) &
4661 + vec_in(i,9,k) * mat_tr(9,j) &
4662 + vec_in(i,10,k) * mat_tr(10,j) &
4663 + vec_in(i,11,k) * mat_tr(11,j) &
4664 + vec_in(i,12,k) * mat_tr(12,j) &
4665 + vec_in(i,13,k) * mat_tr(13,j) &
4666 + vec_in(i,14,k) * mat_tr(14,j) &
4667 + vec_in(i,15,k) * mat_tr(15,j)
4668 end do
4669 end do
4670 end do
4671
4672 ! Z-dir
4673 do k=1, 15
4674 do j=1, 15
4675 do i=1, 15
4676 vec_out_z(i,j,k) = vec_in(i,1,k) * mat_tr(1,j) &
4677 + vec_in(i,j,2) * mat_tr(2,k) &
4678 + vec_in(i,j,3) * mat_tr(3,k) &
4679 + vec_in(i,j,4) * mat_tr(4,k) &
4680 + vec_in(i,j,5) * mat_tr(5,k) &
4681 + vec_in(i,j,6) * mat_tr(6,k) &
4682 + vec_in(i,j,7) * mat_tr(7,k) &
4683 + vec_in(i,j,8) * mat_tr(8,k) &
4684 + vec_in(i,j,9) * mat_tr(9,k) &
4685 + vec_in(i,j,10) * mat_tr(10,k) &
4686 + vec_in(i,j,11) * mat_tr(11,k) &
4687 + vec_in(i,j,12) * mat_tr(12,k) &
4688 + vec_in(i,j,13) * mat_tr(13,k) &
4689 + vec_in(i,j,14) * mat_tr(14,k) &
4690 + vec_in(i,j,15) * mat_tr(15,k)
4691 end do
4692 end do
4693 end do
4694
4695 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 4703 of file scale_element_operation_tensorprod3D_kernel.F90.

4706 implicit none
4707 real(RP), intent(in) :: Mat(15,15)
4708 real(RP), intent(in) :: Mat_tr(15,15)
4709 real(RP), intent(in) :: vec_in_x(15,15**2)
4710 real(RP), intent(in) :: vec_in_y(15,15,15)
4711 real(RP), intent(in) :: vec_in_z(15,15,15)
4712 real(RP), intent(out) :: vec_out_x(15,15**2)
4713 real(RP), intent(out) :: vec_out_y(15,15**2)
4714 real(RP), intent(out) :: vec_out_z(15,15**2)
4715
4716 integer :: i, j, k, jk
4717 real(RP) :: tmp1, tmp2, tmp3
4718 !----------------------------------------------------------
4719
4720 ! X-dir
4721
4722 do jk=1, 15**2
4723 do i=1, 15
4724 tmp1 = mat(i,1) * vec_in_x(1,jk) &
4725 + mat(i,2) * vec_in_x(2,jk) &
4726 + mat(i,3) * vec_in_x(3,jk) &
4727 + mat(i,4) * vec_in_x(4,jk) &
4728 + mat(i,5) * vec_in_x(5,jk)
4729 tmp2 = mat(i,6) * vec_in_x(6,jk) &
4730 + mat(i,7) * vec_in_x(7,jk) &
4731 + mat(i,8) * vec_in_x(8,jk) &
4732 + mat(i,9) * vec_in_x(9,jk) &
4733 + mat(i,10) * vec_in_x(10,jk)
4734 tmp3 = mat(i,11) * vec_in_x(11,jk) &
4735 + mat(i,12) * vec_in_x(12,jk) &
4736 + mat(i,13) * vec_in_x(13,jk) &
4737 + mat(i,14) * vec_in_x(14,jk) &
4738 + mat(i,15) * vec_in_x(15,jk)
4739 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
4740 end do
4741 end do
4742
4743 ! Y-dir
4744 do k=1, 15
4745 do j=1, 15
4746 jk = j + (k-1)*15
4747 do i=1, 15
4748 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
4749 + vec_in_y(i,2,k) * mat_tr(2,j) &
4750 + vec_in_y(i,3,k) * mat_tr(3,j) &
4751 + vec_in_y(i,4,k) * mat_tr(4,j) &
4752 + vec_in_y(i,5,k) * mat_tr(5,j)
4753 tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
4754 + vec_in_y(i,7,k) * mat_tr(7,j) &
4755 + vec_in_y(i,8,k) * mat_tr(8,j) &
4756 + vec_in_y(i,9,k) * mat_tr(9,j) &
4757 + vec_in_y(i,10,k) * mat_tr(10,j)
4758 tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
4759 + vec_in_y(i,12,k) * mat_tr(12,j) &
4760 + vec_in_y(i,13,k) * mat_tr(13,j) &
4761 + vec_in_y(i,14,k) * mat_tr(14,j) &
4762 + vec_in_y(i,15,k) * mat_tr(15,j)
4763 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
4764 end do
4765 end do
4766 end do
4767
4768 ! Z-dir
4769 do k=1, 15
4770 do j=1, 15
4771 jk = j + (k-1)*15
4772 do i=1, 15
4773 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
4774 + vec_in_z(i,j,2) * mat_tr(2,k) &
4775 + vec_in_z(i,j,3) * mat_tr(3,k) &
4776 + vec_in_z(i,j,4) * mat_tr(4,k) &
4777 + vec_in_z(i,j,5) * mat_tr(5,k)
4778 tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
4779 + vec_in_z(i,j,7) * mat_tr(7,k) &
4780 + vec_in_z(i,j,8) * mat_tr(8,k) &
4781 + vec_in_z(i,j,9) * mat_tr(9,k) &
4782 + vec_in_z(i,j,10) * mat_tr(10,k)
4783 tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
4784 + vec_in_z(i,j,12) * mat_tr(12,k) &
4785 + vec_in_z(i,j,13) * mat_tr(13,k) &
4786 + vec_in_z(i,j,14) * mat_tr(14,k) &
4787 + vec_in_z(i,j,15) * mat_tr(15,k)
4788 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
4789 end do
4790 end do
4791 end do
4792 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 4798 of file scale_element_operation_tensorprod3D_kernel.F90.

4800 implicit none
4801 real(RP), intent(in) :: Mat_h1D(15,15)
4802 real(RP), intent(in) :: Mat_h1D_tr(15,15)
4803 real(RP), intent(in) :: Mat_v1D_tr(15,15)
4804 real(RP), intent(in) :: vec_in(15,15,15)
4805 real(RP), intent(out) :: vec_work(15,15,15)
4806 real(RP), intent(out) :: vec_out(15,15,15)
4807
4808 integer :: i, j, k
4809 real(RP) :: tmp1, tmp2, tmp3
4810 !----------------------------------------------------------
4811
4812 ! X-dir
4813
4814 do k=1, 15
4815 do j=1, 15
4816 do i=1, 15
4817 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
4818 + mat_h1d(i,2) * vec_in(2,j,k) &
4819 + mat_h1d(i,3) * vec_in(3,j,k) &
4820 + mat_h1d(i,4) * vec_in(4,j,k) &
4821 + mat_h1d(i,5) * vec_in(5,j,k)
4822 tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
4823 + mat_h1d(i,7) * vec_in(7,j,k) &
4824 + mat_h1d(i,8) * vec_in(8,j,k) &
4825 + mat_h1d(i,9) * vec_in(9,j,k) &
4826 + mat_h1d(i,10) * vec_in(10,j,k)
4827 tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
4828 + mat_h1d(i,12) * vec_in(12,j,k) &
4829 + mat_h1d(i,13) * vec_in(13,j,k) &
4830 + mat_h1d(i,14) * vec_in(14,j,k) &
4831 + mat_h1d(i,15) * vec_in(15,j,k)
4832 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4833 end do
4834 end do
4835 end do
4836
4837 ! Y-dir
4838 do k=1, 15
4839 do j=1, 15
4840 do i=1, 15
4841 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
4842 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
4843 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
4844 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
4845 + vec_out(i,5,k) * mat_h1d_tr(5,j)
4846 tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
4847 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
4848 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
4849 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
4850 + vec_out(i,10,k) * mat_h1d_tr(10,j)
4851 tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
4852 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
4853 + vec_out(i,13,k) * mat_h1d_tr(13,j) &
4854 + vec_out(i,14,k) * mat_h1d_tr(14,j) &
4855 + vec_out(i,15,k) * mat_h1d_tr(15,j)
4856 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
4857 end do
4858 end do
4859 end do
4860
4861 ! Z-dir
4862 do k=1, 15
4863 do j=1, 15
4864 do i=1, 15
4865 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
4866 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
4867 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
4868 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
4869 + vec_work(i,j,5) * mat_v1d_tr(5,k)
4870 tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
4871 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
4872 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
4873 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
4874 + vec_work(i,j,10) * mat_v1d_tr(10,k)
4875 tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
4876 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
4877 + vec_work(i,j,13) * mat_v1d_tr(13,k) &
4878 + vec_work(i,j,14) * mat_v1d_tr(14,k) &
4879 + vec_work(i,j,15) * mat_v1d_tr(15,k)
4880 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
4881 end do
4882 end do
4883 end do
4884
4885 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 4893 of file scale_element_operation_tensorprod3D_kernel.F90.

4894 implicit none
4895 real(RP), intent(in) :: Mat_x(16,16)
4896 real(RP), intent(in) :: vec_in(16,16**2)
4897 real(RP), intent(out) :: vec_out(16,16**2)
4898
4899 integer :: i, jk
4900 !----------------------------------------------------------
4901
4902 do jk=1, 16**2
4903 do i=1, 16
4904 vec_out(i,jk) = mat_x(i,1) * vec_in(1,jk) &
4905 + mat_x(i,2) * vec_in(2,jk) &
4906 + mat_x(i,3) * vec_in(3,jk) &
4907 + mat_x(i,4) * vec_in(4,jk) &
4908 + mat_x(i,5) * vec_in(5,jk) &
4909 + mat_x(i,6) * vec_in(6,jk) &
4910 + mat_x(i,7) * vec_in(7,jk) &
4911 + mat_x(i,8) * vec_in(8,jk) &
4912 + mat_x(i,9) * vec_in(9,jk) &
4913 + mat_x(i,10) * vec_in(10,jk) &
4914 + mat_x(i,11) * vec_in(11,jk) &
4915 + mat_x(i,12) * vec_in(12,jk) &
4916 + mat_x(i,13) * vec_in(13,jk) &
4917 + mat_x(i,14) * vec_in(14,jk) &
4918 + mat_x(i,15) * vec_in(15,jk) &
4919 + mat_x(i,16) * vec_in(16,jk)
4920 end do
4921 end do
4922
4923 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 4930 of file scale_element_operation_tensorprod3D_kernel.F90.

4931 implicit none
4932 real(RP), intent(in) :: Mat_y_tr(16,16)
4933 real(RP), intent(in) :: vec_in(16,16,16)
4934 real(RP), intent(out) :: vec_out(16,16,16)
4935
4936 integer :: i, j, k
4937 !----------------------------------------------------------
4938
4939 do k=1, 16
4940 do j=1, 16
4941 do i=1, 16
4942 vec_out(i,j,k) = vec_in(i,1,k) * mat_y_tr(1,j) &
4943 + vec_in(i,2,k) * mat_y_tr(2,j) &
4944 + vec_in(i,3,k) * mat_y_tr(3,j) &
4945 + vec_in(i,4,k) * mat_y_tr(4,j) &
4946 + vec_in(i,5,k) * mat_y_tr(5,j) &
4947 + vec_in(i,6,k) * mat_y_tr(6,j) &
4948 + vec_in(i,7,k) * mat_y_tr(7,j) &
4949 + vec_in(i,8,k) * mat_y_tr(8,j) &
4950 + vec_in(i,9,k) * mat_y_tr(9,j) &
4951 + vec_in(i,10,k) * mat_y_tr(10,j) &
4952 + vec_in(i,11,k) * mat_y_tr(11,j) &
4953 + vec_in(i,12,k) * mat_y_tr(12,j) &
4954 + vec_in(i,13,k) * mat_y_tr(13,j) &
4955 + vec_in(i,14,k) * mat_y_tr(14,j) &
4956 + vec_in(i,15,k) * mat_y_tr(15,j) &
4957 + vec_in(i,16,k) * mat_y_tr(16,j)
4958 end do
4959 end do
4960 end do
4961
4962 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 4969 of file scale_element_operation_tensorprod3D_kernel.F90.

4970 implicit none
4971 real(RP), intent(in) :: Mat_z_tr(16,16)
4972 real(RP), intent(in) :: vec_in(16,16,16)
4973 real(RP), intent(out) :: vec_out(16,16,16)
4974
4975 integer :: i, j, k
4976 !----------------------------------------------------------
4977
4978 do k=1, 16
4979 do j=1, 16
4980 do i=1, 16
4981 vec_out(i,j,k) = vec_in(i,j,1) * mat_z_tr(1,k) &
4982 + vec_in(i,j,2) * mat_z_tr(2,k) &
4983 + vec_in(i,j,3) * mat_z_tr(3,k) &
4984 + vec_in(i,j,4) * mat_z_tr(4,k) &
4985 + vec_in(i,j,5) * mat_z_tr(5,k) &
4986 + vec_in(i,j,6) * mat_z_tr(6,k) &
4987 + vec_in(i,j,7) * mat_z_tr(7,k) &
4988 + vec_in(i,j,8) * mat_z_tr(8,k) &
4989 + vec_in(i,j,9) * mat_z_tr(9,k) &
4990 + vec_in(i,j,10) * mat_z_tr(10,k) &
4991 + vec_in(i,j,11) * mat_z_tr(11,k) &
4992 + vec_in(i,j,12) * mat_z_tr(12,k) &
4993 + vec_in(i,j,13) * mat_z_tr(13,k) &
4994 + vec_in(i,j,14) * mat_z_tr(14,k) &
4995 + vec_in(i,j,15) * mat_z_tr(15,k) &
4996 + vec_in(i,j,16) * mat_z_tr(16,k)
4997 end do
4998 end do
4999 end do
5000
5001 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 associated with Lift operations with hexahedral element of p=15.

Definition at line 5007 of file scale_element_operation_tensorprod3D_kernel.F90.

5008 implicit none
5009 real(RP), intent(in) :: Lift(16,16,16,6)
5010 real(RP), intent(in) :: vec_in(16,16,6)
5011 real(RP), intent(out) :: vec_out(16,16,16)
5012
5013 integer :: i, j, k
5014 !----------------------------------------------------------
5015
5016 do k=1, 16
5017 do j=1, 16
5018 do i=1, 16
5019 vec_out(i,j,k) = lift(i,j,k,1) * vec_in(i,k,1) &
5020 + lift(i,j,k,2) * vec_in(j,k,2) &
5021 + lift(i,j,k,3) * vec_in(i,k,3) &
5022 + lift(i,j,k,4) * vec_in(j,k,4) &
5023 + lift(i,j,k,5) * vec_in(i,j,5) &
5024 + lift(i,j,k,6) * vec_in(i,j,6)
5025 end do
5026 end do
5027 end do
5028
5029 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 5037 of file scale_element_operation_tensorprod3D_kernel.F90.

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

5133 implicit none
5134 real(RP), intent(in) :: Mat(16,16)
5135 real(RP), intent(in) :: Mat_tr(16,16)
5136 real(RP), intent(in) :: vec_in_x(16,16**2)
5137 real(RP), intent(in) :: vec_in_y(16,16,16)
5138 real(RP), intent(in) :: vec_in_z(16,16,16)
5139 real(RP), intent(out) :: vec_out_x(16,16**2)
5140 real(RP), intent(out) :: vec_out_y(16,16**2)
5141 real(RP), intent(out) :: vec_out_z(16,16**2)
5142
5143 integer :: i, j, k, jk
5144 real(RP) :: tmp1, tmp2, tmp3
5145 !----------------------------------------------------------
5146
5147 ! X-dir
5148
5149 do jk=1, 16**2
5150 do i=1, 16
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 + mat(i,15) * vec_in_x(15,jk) &
5166 + mat(i,16) * vec_in_x(16,jk)
5167 vec_out_x(i,jk) = tmp1 + tmp2 + tmp3
5168 end do
5169 end do
5170
5171 ! Y-dir
5172 do k=1, 16
5173 do j=1, 16
5174 jk = j + (k-1)*16
5175 do i=1, 16
5176 tmp1 = vec_in_y(i,1,k) * mat_tr(1,j) &
5177 + vec_in_y(i,2,k) * mat_tr(2,j) &
5178 + vec_in_y(i,3,k) * mat_tr(3,j) &
5179 + vec_in_y(i,4,k) * mat_tr(4,j) &
5180 + vec_in_y(i,5,k) * mat_tr(5,j)
5181 tmp2 = vec_in_y(i,6,k) * mat_tr(6,j) &
5182 + vec_in_y(i,7,k) * mat_tr(7,j) &
5183 + vec_in_y(i,8,k) * mat_tr(8,j) &
5184 + vec_in_y(i,9,k) * mat_tr(9,j) &
5185 + vec_in_y(i,10,k) * mat_tr(10,j)
5186 tmp3 = vec_in_y(i,11,k) * mat_tr(11,j) &
5187 + vec_in_y(i,12,k) * mat_tr(12,j) &
5188 + vec_in_y(i,13,k) * mat_tr(13,j) &
5189 + vec_in_y(i,14,k) * mat_tr(14,j) &
5190 + vec_in_y(i,15,k) * mat_tr(15,j) &
5191 + vec_in_y(i,16,k) * mat_tr(16,j)
5192 vec_out_y(i,jk) = tmp1 + tmp2 + tmp3
5193 end do
5194 end do
5195 end do
5196
5197 ! Z-dir
5198 do k=1, 16
5199 do j=1, 16
5200 jk = j + (k-1)*16
5201 do i=1, 16
5202 tmp1 = vec_in_z(i,j,1) * mat_tr(1,k) &
5203 + vec_in_z(i,j,2) * mat_tr(2,k) &
5204 + vec_in_z(i,j,3) * mat_tr(3,k) &
5205 + vec_in_z(i,j,4) * mat_tr(4,k) &
5206 + vec_in_z(i,j,5) * mat_tr(5,k)
5207 tmp2 = vec_in_z(i,j,6) * mat_tr(6,k) &
5208 + vec_in_z(i,j,7) * mat_tr(7,k) &
5209 + vec_in_z(i,j,8) * mat_tr(8,k) &
5210 + vec_in_z(i,j,9) * mat_tr(9,k) &
5211 + vec_in_z(i,j,10) * mat_tr(10,k)
5212 tmp3 = vec_in_z(i,j,11) * mat_tr(11,k) &
5213 + vec_in_z(i,j,12) * mat_tr(12,k) &
5214 + vec_in_z(i,j,13) * mat_tr(13,k) &
5215 + vec_in_z(i,j,14) * mat_tr(14,k) &
5216 + vec_in_z(i,j,15) * mat_tr(15,k) &
5217 + vec_in_z(i,j,16) * mat_tr(16,k)
5218 vec_out_z(i,jk) = tmp1 + tmp2 + tmp3
5219 end do
5220 end do
5221 end do
5222 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 5228 of file scale_element_operation_tensorprod3D_kernel.F90.

5230 implicit none
5231 real(RP), intent(in) :: Mat_h1D(16,16)
5232 real(RP), intent(in) :: Mat_h1D_tr(16,16)
5233 real(RP), intent(in) :: Mat_v1D_tr(16,16)
5234 real(RP), intent(in) :: vec_in(16,16,16)
5235 real(RP), intent(out) :: vec_work(16,16,16)
5236 real(RP), intent(out) :: vec_out(16,16,16)
5237
5238 integer :: i, j, k
5239 real(RP) :: tmp1, tmp2, tmp3
5240 !----------------------------------------------------------
5241
5242 ! X-dir
5243
5244 do k=1, 16
5245 do j=1, 16
5246 do i=1, 16
5247 tmp1 = mat_h1d(i,1) * vec_in(1,j,k) &
5248 + mat_h1d(i,2) * vec_in(2,j,k) &
5249 + mat_h1d(i,3) * vec_in(3,j,k) &
5250 + mat_h1d(i,4) * vec_in(4,j,k) &
5251 + mat_h1d(i,5) * vec_in(5,j,k)
5252 tmp2 = mat_h1d(i,6) * vec_in(6,j,k) &
5253 + mat_h1d(i,7) * vec_in(7,j,k) &
5254 + mat_h1d(i,8) * vec_in(8,j,k) &
5255 + mat_h1d(i,9) * vec_in(9,j,k) &
5256 + mat_h1d(i,10) * vec_in(10,j,k)
5257 tmp3 = mat_h1d(i,11) * vec_in(11,j,k) &
5258 + mat_h1d(i,12) * vec_in(12,j,k) &
5259 + mat_h1d(i,13) * vec_in(13,j,k) &
5260 + mat_h1d(i,14) * vec_in(14,j,k) &
5261 + mat_h1d(i,15) * vec_in(15,j,k) &
5262 + mat_h1d(i,16) * vec_in(16,j,k)
5263 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
5264 end do
5265 end do
5266 end do
5267
5268 ! Y-dir
5269 do k=1, 16
5270 do j=1, 16
5271 do i=1, 16
5272 tmp1 = vec_out(i,1,k) * mat_h1d_tr(1,j) &
5273 + vec_out(i,2,k) * mat_h1d_tr(2,j) &
5274 + vec_out(i,3,k) * mat_h1d_tr(3,j) &
5275 + vec_out(i,4,k) * mat_h1d_tr(4,j) &
5276 + vec_out(i,5,k) * mat_h1d_tr(5,j)
5277 tmp2 = vec_out(i,6,k) * mat_h1d_tr(6,j) &
5278 + vec_out(i,7,k) * mat_h1d_tr(7,j) &
5279 + vec_out(i,8,k) * mat_h1d_tr(8,j) &
5280 + vec_out(i,9,k) * mat_h1d_tr(9,j) &
5281 + vec_out(i,10,k) * mat_h1d_tr(10,j)
5282 tmp3 = vec_out(i,11,k) * mat_h1d_tr(11,j) &
5283 + vec_out(i,12,k) * mat_h1d_tr(12,j) &
5284 + vec_out(i,13,k) * mat_h1d_tr(13,j) &
5285 + vec_out(i,14,k) * mat_h1d_tr(14,j) &
5286 + vec_out(i,15,k) * mat_h1d_tr(15,j) &
5287 + vec_out(i,16,k) * mat_h1d_tr(16,j)
5288 vec_work(i,j,k) = tmp1 + tmp2 + tmp3
5289 end do
5290 end do
5291 end do
5292
5293 ! Z-dir
5294 do k=1, 16
5295 do j=1, 16
5296 do i=1, 16
5297 tmp1 = vec_work(i,j,1) * mat_v1d_tr(1,k) &
5298 + vec_work(i,j,2) * mat_v1d_tr(2,k) &
5299 + vec_work(i,j,3) * mat_v1d_tr(3,k) &
5300 + vec_work(i,j,4) * mat_v1d_tr(4,k) &
5301 + vec_work(i,j,5) * mat_v1d_tr(5,k)
5302 tmp2 = vec_work(i,j,6) * mat_v1d_tr(6,k) &
5303 + vec_work(i,j,7) * mat_v1d_tr(7,k) &
5304 + vec_work(i,j,8) * mat_v1d_tr(8,k) &
5305 + vec_work(i,j,9) * mat_v1d_tr(9,k) &
5306 + vec_work(i,j,10) * mat_v1d_tr(10,k)
5307 tmp3 = vec_work(i,j,11) * mat_v1d_tr(11,k) &
5308 + vec_work(i,j,12) * mat_v1d_tr(12,k) &
5309 + vec_work(i,j,13) * mat_v1d_tr(13,k) &
5310 + vec_work(i,j,14) * mat_v1d_tr(14,k) &
5311 + vec_work(i,j,15) * mat_v1d_tr(15,k) &
5312 + vec_work(i,j,16) * mat_v1d_tr(16,k)
5313 vec_out(i,j,k) = tmp1 + tmp2 + tmp3
5314 end do
5315 end do
5316 end do
5317
5318 return

Referenced by scale_element_operation_tensorprod3d::elementoperationtensorprod3d_create().

Generated by doxygen 1.10.0