scale_element_operation_tensorprod3d_kernel_gpu Module Reference
module FElib / Element / Operation with 3D tensor product elements for GPU More...
Functions/Subroutines | |
| subroutine, public | element_operation_kernel_matvec_dirz_p1 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p1 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p1 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p1 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p1 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p1_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p1 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=1. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p2 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p2 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p2 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p2 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p2_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p2 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=2. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p3 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p3 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p3 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p3 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p3 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p3_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p3 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=3. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p4 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p4 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p4 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p4 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p4 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p4_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p4 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=4. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p5 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p5 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p5 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p5 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p5 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p5_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p5 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=5. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p6 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p6 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p6 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p6 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p6 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p6_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p6 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=6. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p7 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p7 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p7 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p7 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p7 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p7_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p7 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=7. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p8 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p8 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p8 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p8 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p8 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p8_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p8 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=8. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p9 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p9 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p9 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p9 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p9 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p9_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p9 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=9. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p10 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p10 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p10 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p10 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p10 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p10_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p10 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=10. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p11 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p11 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p11 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p11 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p11 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p11_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p11 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=11. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p12 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p12 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p12 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p12 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p12 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p12_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p12 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=12. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p13 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p13 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p13 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p13 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p13 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p13_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p13 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=13. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p14 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p14 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p14 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p14 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p14 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p14_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p14 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, vec_out) |
| Calculate a matrix-vector multiplication associated with 3D modal filtering with p=14. | |
| subroutine, public | element_operation_kernel_matvec_dirz_p15 (mat_z_tr, vec_in, ne_in, ne_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. | |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_p15 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirxy_var5_p15 (mat, mat_tr, vec_in_x, vec_in_y, e11, e22, div_out_xy) |
| subroutine, public | element_operation_kernel_matvec_divlike_dirz_lift_var5_p15 (mat_tr, lift, vec_in_z, ebnd_flux, e33, gsqrt, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p15 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_divlike_var5_p15_v2 (mat, mat_tr, lift, vec_in_x, vec_in_y, vec_in_z, ebnd_flux, e11, e22, e33, gsqrt, ne, div3d) |
| subroutine, public | element_operation_kernel_matvec_modalfilter_p15 (mat_h1d, mat_h1d_tr, mat_v1d_tr, vec_in, vec_work, ne, 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 for GPU
- Description
- A module for providing kernels of matrix and vector operations assuming a 3D tensor product element with (p+1)^3 DOF and GPU execution
Function/Subroutine Documentation
◆ element_operation_kernel_matvec_dirz_p1()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p1 | ( | real(rp), dimension(2,2), intent(in) | mat_z_tr, |
| real(rp), dimension(2**2,2,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(2**2,2,ne_out), 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 148 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
149 implicit none
150 integer, intent(in) :: Ne_in
151 integer, intent(in) :: Ne_out
152 real(RP), intent(in) :: Mat_z_tr(2,2)
153 real(RP), intent(in) :: vec_in(2**2,2,Ne_in)
154 real(RP), intent(out) :: vec_out(2**2,2,Ne_out)
155
156 integer :: ij, k, ke
157 !----------------------------------------------------------
158
159 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
160 do ke=1, ne_out
161 do k=1, 2
162 do ij=1, 2**2
163 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
164 + vec_in(ij,2,ke) * mat_z_tr(2,k)
165 end do
166 end do
167 end do
168
169 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p1()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p1 | ( | real(rp), dimension(2,2), intent(in) | mat, |
| real(rp), dimension(2,2), intent(in) | mat_tr, | ||
| real(rp), dimension(2,2), intent(in) | vec_in_x, | ||
| real(rp), dimension(2,2), intent(in) | vec_in_y, | ||
| real(rp), dimension(2,2), intent(in) | e11, | ||
| real(rp), dimension(2,2), intent(in) | e22, | ||
| real(rp), dimension(2,2), intent(out) | div_out_xy ) |
Definition at line 172 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
176 implicit none
177 real(RP), intent(in) :: Mat(2,2)
178 real(RP), intent(in) :: Mat_tr(2,2)
179 real(RP), intent(in) :: vec_in_x(2,2)
180 real(RP), intent(in) :: vec_in_y(2,2)
181 real(RP), intent(in) :: E11(2,2)
182 real(RP), intent(in) :: E22(2,2)
183 real(RP), intent(out) :: div_out_xy(2,2)
184
185 integer :: i, j, jv, jk
186 real(RP) :: tmp1, div_x
187 !----------------------------------------------------------
188 !$acc routine vector
189
190 !$acc loop vector collapse(2)
191 do j=1, 2
192 do i=1, 2
193 ! X-dir
194 div_x = ( mat(i,1) * vec_in_x(1,j) &
195
196 + mat(i,2) * vec_in_x(2,j) ) * e11(i,j)
197
198 ! Y-dir
199 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
200 + vec_in_y(i,2) * mat_tr(2,j)
201 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
202 end do
203 end do
204 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p1()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p1 | ( | real(rp), dimension(2,2), intent(in) | mat, |
| real(rp), dimension(2,2), intent(in) | mat_tr, | ||
| real(rp), dimension(2,2,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(2,2,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(2,2), intent(in) | e11, | ||
| real(rp), dimension(2,2), intent(in) | e22, | ||
| real(rp), dimension(2,2,5), intent(out) | div_out_xy ) |
Definition at line 207 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
211 implicit none
212 real(RP), intent(in) :: Mat(2,2)
213 real(RP), intent(in) :: Mat_tr(2,2)
214 real(RP), intent(in) :: vec_in_x(2,2,5)
215 real(RP), intent(in) :: vec_in_y(2,2,5)
216 real(RP), intent(in) :: E11(2,2)
217 real(RP), intent(in) :: E22(2,2)
218 real(RP), intent(out) :: div_out_xy(2,2,5)
219
220 integer :: i, j, jv, jk, v, kv
221 real(RP) :: tmp1, div_x
222 !----------------------------------------------------------
223 !$acc routine vector
224
225 do v=1, 5
226 !$acc loop vector collapse(2)
227 do j=1, 2
228 do i=1, 2
229 ! X-dir
230 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
231
232 + mat(i,2) * vec_in_x(2,j,v) ) * e11(i,j)
233
234 ! Y-dir
235 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
236 + vec_in_y(i,2,v) * mat_tr(2,j)
237 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
238 end do
239 end do
240 end do
241 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p1()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p1 | ( | real(rp), dimension(2,2), intent(in) | mat_tr, |
| real(rp), dimension(2,2,2,6), intent(in) | lift, | ||
| real(rp), dimension(2,2,5,2), intent(in) | vec_in_z, | ||
| real(rp), dimension(2,2,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(2,2,2), intent(in) | e33, | ||
| real(rp), dimension(2,2,2), intent(in) | gsqrt, | ||
| real(rp), dimension(2,2,5,2), intent(inout) | div3d ) |
Definition at line 244 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
247 implicit none
248 real(RP), intent(in) :: Mat_tr(2,2)
249 real(RP), intent(in) :: Lift(2,2,2,6)
250 real(RP), intent(in) :: vec_in_z(2,2,5,2)
251 real(RP), intent(in) :: ebnd_flux(2,2,6,5)
252 real(RP), intent(in) :: E33(2,2,2)
253 real(RP), intent(in) :: Gsqrt(2,2,2)
254 real(RP), intent(inout) :: div3D(2,2,5,2)
255
256 integer :: i, j, k, v
257 real(RP) :: tmp1
258 real(RP) :: tmp_lift
259 real(RP) :: tmp2, tmp3
260 real(RP) :: invG, e33_
261 !----------------------------------------------------------
262
263 !$acc routine vector
264
265 ! Z-dir
266 do v=1, 5
267 do k=1, 2
268 !$acc loop vector collapse(2)
269 do j=1, 2
270 do i=1, 2
271 invg = 1.0_rp / gsqrt(i,j,k)
272 e33_ = e33(i,j,k)
273
274
275 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
276 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
277 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
278 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
279 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
280 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
281 tmp_lift = tmp1 + tmp2 + tmp3
282
283 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
284 + vec_in_z(i,j,v,2) * mat_tr(2,k)
285! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
286 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
287
288 end do
289 end do
290 end do
291 end do
292 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p1()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p1 | ( | real(rp), dimension(2,2), intent(in) | mat, |
| real(rp), dimension(2,2), intent(in) | mat_tr, | ||
| real(rp), dimension(2,2,2,6), intent(in) | lift, | ||
| real(rp), dimension(2,2,5,2,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(2,2,5,2,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(2,2,5,2,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(2,2,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | e11, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | e22, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | e33, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(2,2,5,2,ne), intent(inout) | div3d ) |
Definition at line 295 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
299 implicit none
300 real(RP), intent(in) :: Mat(2,2)
301 real(RP), intent(in) :: Mat_tr(2,2)
302 real(RP), intent(in) :: Lift(2,2,2,6)
303 integer, intent(in) :: Ne
304 real(RP), intent(in) :: vec_in_x(2,2,5,2,Ne)
305 real(RP), intent(in) :: vec_in_y(2,2,5,2,Ne)
306 real(RP), intent(in) :: vec_in_z(2,2,5,2,Ne)
307 real(RP), intent(in) :: ebnd_flux(2,2,6,5,Ne)
308 real(RP), intent(in) :: E11(2,2,2,Ne)
309 real(RP), intent(in) :: E22(2,2,2,Ne)
310 real(RP), intent(in) :: E33(2,2,2,Ne)
311 real(RP), intent(in) :: Gsqrt(2,2,2,Ne)
312 real(RP), intent(inout) :: div3D(2,2,5,2,Ne)
313
314 integer :: ke
315 integer :: i, j, k, v
316 real(RP) :: tmp1
317 real(RP) :: tmp_lift
318 real(RP) :: tmp2, tmp3
319 real(RP) :: invG, e33_
320 real(RP) :: div_x, div_xy
321 !----------------------------------------------------------
322
323 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
324 do ke=1, ne
325 do k=1, 2
326 do v=1, 5
327 !$acc loop vector collapse(2)
328 do j=1, 2
329 do i=1, 2
330 ! X-dir
331 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
332
333 + mat(i,2) * vec_in_x(2,j,v,k,ke) ) * e11(i,j,k,ke)
334
335 ! Y-dir
336 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
337 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j)
338 div_xy = div_x + tmp1 * e22(i,j,k,ke)
339
340
341 ! Z-dir
342
343 invg = 1.0_rp / gsqrt(i,j,k,ke)
344 e33_ = e33(i,j,k,ke)
345
346
347 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
348 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
349 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
350 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
351 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
352 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
353 tmp_lift = tmp1 + tmp2 + tmp3
354
355 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
356 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k)
357
358 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
359
360 end do
361 end do
362 end do
363 end do
364 end do
365 return
◆ element_operation_kernel_matvec_divlike_var5_p1_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p1_v2 | ( | real(rp), dimension(2,2), intent(in) | mat, |
| real(rp), dimension(2,2), intent(in) | mat_tr, | ||
| real(rp), dimension(2,2,2,6), intent(in) | lift, | ||
| real(rp), dimension(2,2,5,2,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(2,2,5,2,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(2,2,5,2,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(2,2,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | e11, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | e22, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | e33, | ||
| real(rp), dimension(2,2,2,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(2,2,5,2,ne), intent(inout) | div3d ) |
Definition at line 368 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
372 implicit none
373 real(RP), intent(in) :: Mat(2,2)
374 real(RP), intent(in) :: Mat_tr(2,2)
375 real(RP), intent(in) :: Lift(2,2,2,6)
376 integer, intent(in) :: Ne
377 real(RP), intent(in) :: vec_in_x(2,2,5,2,Ne)
378 real(RP), intent(in) :: vec_in_y(2,2,5,2,Ne)
379 real(RP), intent(in) :: vec_in_z(2,2,5,2,Ne)
380 real(RP), intent(in) :: ebnd_flux(2,2,6,5,Ne)
381 real(RP), intent(in) :: E11(2,2,2,Ne)
382 real(RP), intent(in) :: E22(2,2,2,Ne)
383 real(RP), intent(in) :: E33(2,2,2,Ne)
384 real(RP), intent(in) :: Gsqrt(2,2,2,Ne)
385 real(RP), intent(inout) :: div3D(2,2,5,2,Ne)
386
387 integer :: ke
388 integer :: p, i, j, k, v, n
389 real(RP) :: tmp1
390 real(RP) :: tmp_lift
391 real(RP) :: tmp2, tmp3
392
393 real(RP) :: invG, e33_
394 real(RP) :: div_x, div_xy
395
396 real(RP) :: tmp_vec_in_y(2)
397
398 real(RP) :: s1, s2, s3, s4
399 real(RP) :: e11_
400 !----------------------------------------------------------
401
402 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
403 do ke=1, ne
404 do k=1, 2
405 !$acc loop vector collapse(2)
406 do j=1, 2
407 do i=1, 2
408 e11_ = e11(i,j,k,ke)
409 ! X-dir
410 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
411
412 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) )
413 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
414
415 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) )
416 div3d(i,j,1,k,ke) = s1 * e11_
417 div3d(i,j,2,k,ke) = s2 * e11_
418
419 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
420
421 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) )
422 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
423
424 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) )
425 div3d(i,j,3,k,ke) = s1 * e11_
426 div3d(i,j,4,k,ke) = s2 * e11_
427
428 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
429
430 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) )
431 div3d(i,j,5,k,ke) = s1 * e11_
432 end do
433 end do
434 end do
435 end do
436
437 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
438 do ke=1, ne
439 do k=1, 2
440 do v=1, 5
441 !$acc loop vector collapse(2)
442 do j=1, 2
443 do i=1, 2
444
445 ! Y-dir
446 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
447
448 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
449 + tmp_vec_in_y(2) * mat_tr(2,j)
450! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
451 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
452 end do
453 end do
454 end do
455 end do
456 end do
457
458 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
459 do ke=1, ne
460 do k=1, 2
461 do v=1, 5
462 !$acc loop vector collapse(2)
463 do j=1, 2
464 do i=1, 2
465
466 invg = 1.0_rp / gsqrt(i,j,k,ke)
467 e33_ = e33(i,j,k,ke)
468
469
470 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
471 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
472 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
473 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
474 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
475 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
476 tmp_lift = tmp1 + tmp2 + tmp3
477
478 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
479 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k)
480! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
481 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
482
483 end do
484 end do
485 end do
486 end do
487 end do
488
489 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p1()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(2,2,2,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(2,2,2,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=1.
Definition at line 496 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
499 implicit none
500 integer, intent(in) :: Ne
501 real(RP), intent(in) :: Mat_h1D(2,2)
502 real(RP), intent(in) :: Mat_h1D_tr(2,2)
503 real(RP), intent(in) :: Mat_v1D_tr(2,2)
504 real(RP), intent(in) :: vec_in(2,2,2,Ne)
505 real(RP), intent(out) :: vec_work(2,2,2,Ne)
506 real(RP), intent(out) :: vec_out(2,2,2,Ne)
507
508 integer :: ke
509 integer :: i, j, k
510 !----------------------------------------------------------
511
512 ! X-dir
513 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
514 do ke=1, ne
515 do k=1, 2
516 !$acc loop vector collapse(2)
517 do j=1, 2
518 do i=1, 2
519 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
520 + mat_h1d(i,2) * vec_in(2,j,k,ke)
521 end do
522 end do
523 end do
524 end do
525
526 ! Y-dir
527 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
528 do ke=1, ne
529 do k=1, 2
530 !$acc loop vector collapse(2)
531 do j=1, 2
532 do i=1, 2
533 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
534 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j)
535 end do
536 end do
537 end do
538 end do
539
540 ! Z-dir
541 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
542 do ke=1, ne
543 do k=1, 2
544 !$acc loop vector collapse(2)
545 do j=1, 2
546 do i=1, 2
547 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
548 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k)
549 end do
550 end do
551 end do
552 end do
553 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p2 | ( | real(rp), dimension(3,3), intent(in) | mat_z_tr, |
| real(rp), dimension(3**2,3,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(3**2,3,ne_out), 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 562 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
563 implicit none
564 integer, intent(in) :: Ne_in
565 integer, intent(in) :: Ne_out
566 real(RP), intent(in) :: Mat_z_tr(3,3)
567 real(RP), intent(in) :: vec_in(3**2,3,Ne_in)
568 real(RP), intent(out) :: vec_out(3**2,3,Ne_out)
569
570 integer :: ij, k, ke
571 !----------------------------------------------------------
572
573 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
574 do ke=1, ne_out
575 do k=1, 3
576 do ij=1, 3**2
577 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
578 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
579 + vec_in(ij,3,ke) * mat_z_tr(3,k)
580 end do
581 end do
582 end do
583
584 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p2 | ( | real(rp), dimension(3,3), intent(in) | mat, |
| real(rp), dimension(3,3), intent(in) | mat_tr, | ||
| real(rp), dimension(3,3), intent(in) | vec_in_x, | ||
| real(rp), dimension(3,3), intent(in) | vec_in_y, | ||
| real(rp), dimension(3,3), intent(in) | e11, | ||
| real(rp), dimension(3,3), intent(in) | e22, | ||
| real(rp), dimension(3,3), intent(out) | div_out_xy ) |
Definition at line 587 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
591 implicit none
592 real(RP), intent(in) :: Mat(3,3)
593 real(RP), intent(in) :: Mat_tr(3,3)
594 real(RP), intent(in) :: vec_in_x(3,3)
595 real(RP), intent(in) :: vec_in_y(3,3)
596 real(RP), intent(in) :: E11(3,3)
597 real(RP), intent(in) :: E22(3,3)
598 real(RP), intent(out) :: div_out_xy(3,3)
599
600 integer :: i, j, jv, jk
601 real(RP) :: tmp1, div_x
602 !----------------------------------------------------------
603 !$acc routine vector
604
605 !$acc loop vector collapse(2)
606 do j=1, 3
607 do i=1, 3
608 ! X-dir
609 div_x = ( mat(i,1) * vec_in_x(1,j) &
610
611 + mat(i,2) * vec_in_x(2,j) &
612 + mat(i,3) * vec_in_x(3,j) ) * e11(i,j)
613
614 ! Y-dir
615 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
616 + vec_in_y(i,2) * mat_tr(2,j) &
617 + vec_in_y(i,3) * mat_tr(3,j)
618 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
619 end do
620 end do
621 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p2 | ( | real(rp), dimension(3,3), intent(in) | mat, |
| real(rp), dimension(3,3), intent(in) | mat_tr, | ||
| real(rp), dimension(3,3,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(3,3,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(3,3), intent(in) | e11, | ||
| real(rp), dimension(3,3), intent(in) | e22, | ||
| real(rp), dimension(3,3,5), intent(out) | div_out_xy ) |
Definition at line 624 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
628 implicit none
629 real(RP), intent(in) :: Mat(3,3)
630 real(RP), intent(in) :: Mat_tr(3,3)
631 real(RP), intent(in) :: vec_in_x(3,3,5)
632 real(RP), intent(in) :: vec_in_y(3,3,5)
633 real(RP), intent(in) :: E11(3,3)
634 real(RP), intent(in) :: E22(3,3)
635 real(RP), intent(out) :: div_out_xy(3,3,5)
636
637 integer :: i, j, jv, jk, v, kv
638 real(RP) :: tmp1, div_x
639 !----------------------------------------------------------
640 !$acc routine vector
641
642 do v=1, 5
643 !$acc loop vector collapse(2)
644 do j=1, 3
645 do i=1, 3
646 ! X-dir
647 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
648
649 + mat(i,2) * vec_in_x(2,j,v) &
650 + mat(i,3) * vec_in_x(3,j,v) ) * e11(i,j)
651
652 ! Y-dir
653 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
654 + vec_in_y(i,2,v) * mat_tr(2,j) &
655 + vec_in_y(i,3,v) * mat_tr(3,j)
656 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
657 end do
658 end do
659 end do
660 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p2 | ( | real(rp), dimension(3,3), intent(in) | mat_tr, |
| real(rp), dimension(3,3,3,6), intent(in) | lift, | ||
| real(rp), dimension(3,3,5,3), intent(in) | vec_in_z, | ||
| real(rp), dimension(3,3,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(3,3,3), intent(in) | e33, | ||
| real(rp), dimension(3,3,3), intent(in) | gsqrt, | ||
| real(rp), dimension(3,3,5,3), intent(inout) | div3d ) |
Definition at line 663 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
666 implicit none
667 real(RP), intent(in) :: Mat_tr(3,3)
668 real(RP), intent(in) :: Lift(3,3,3,6)
669 real(RP), intent(in) :: vec_in_z(3,3,5,3)
670 real(RP), intent(in) :: ebnd_flux(3,3,6,5)
671 real(RP), intent(in) :: E33(3,3,3)
672 real(RP), intent(in) :: Gsqrt(3,3,3)
673 real(RP), intent(inout) :: div3D(3,3,5,3)
674
675 integer :: i, j, k, v
676 real(RP) :: tmp1
677 real(RP) :: tmp_lift
678 real(RP) :: tmp2, tmp3
679 real(RP) :: invG, e33_
680 !----------------------------------------------------------
681
682 !$acc routine vector
683
684 ! Z-dir
685 do v=1, 5
686 do k=1, 3
687 !$acc loop vector collapse(2)
688 do j=1, 3
689 do i=1, 3
690 invg = 1.0_rp / gsqrt(i,j,k)
691 e33_ = e33(i,j,k)
692
693
694 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
695 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
696 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
697 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
698 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
699 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
700 tmp_lift = tmp1 + tmp2 + tmp3
701
702 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
703 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
704 + vec_in_z(i,j,v,3) * mat_tr(3,k)
705! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
706 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
707
708 end do
709 end do
710 end do
711 end do
712 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p2 | ( | real(rp), dimension(3,3), intent(in) | mat, |
| real(rp), dimension(3,3), intent(in) | mat_tr, | ||
| real(rp), dimension(3,3,3,6), intent(in) | lift, | ||
| real(rp), dimension(3,3,5,3,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(3,3,5,3,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(3,3,5,3,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(3,3,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | e11, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | e22, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | e33, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(3,3,5,3,ne), intent(inout) | div3d ) |
Definition at line 715 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
719 implicit none
720 real(RP), intent(in) :: Mat(3,3)
721 real(RP), intent(in) :: Mat_tr(3,3)
722 real(RP), intent(in) :: Lift(3,3,3,6)
723 integer, intent(in) :: Ne
724 real(RP), intent(in) :: vec_in_x(3,3,5,3,Ne)
725 real(RP), intent(in) :: vec_in_y(3,3,5,3,Ne)
726 real(RP), intent(in) :: vec_in_z(3,3,5,3,Ne)
727 real(RP), intent(in) :: ebnd_flux(3,3,6,5,Ne)
728 real(RP), intent(in) :: E11(3,3,3,Ne)
729 real(RP), intent(in) :: E22(3,3,3,Ne)
730 real(RP), intent(in) :: E33(3,3,3,Ne)
731 real(RP), intent(in) :: Gsqrt(3,3,3,Ne)
732 real(RP), intent(inout) :: div3D(3,3,5,3,Ne)
733
734 integer :: ke
735 integer :: i, j, k, v
736 real(RP) :: tmp1
737 real(RP) :: tmp_lift
738 real(RP) :: tmp2, tmp3
739 real(RP) :: invG, e33_
740 real(RP) :: div_x, div_xy
741 !----------------------------------------------------------
742
743 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
744 do ke=1, ne
745 do k=1, 3
746 do v=1, 5
747 !$acc loop vector collapse(2)
748 do j=1, 3
749 do i=1, 3
750 ! X-dir
751 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
752
753 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
754 + mat(i,3) * vec_in_x(3,j,v,k,ke) ) * e11(i,j,k,ke)
755
756 ! Y-dir
757 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
758 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
759 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j)
760 div_xy = div_x + tmp1 * e22(i,j,k,ke)
761
762
763 ! Z-dir
764
765 invg = 1.0_rp / gsqrt(i,j,k,ke)
766 e33_ = e33(i,j,k,ke)
767
768
769 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
770 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
771 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
772 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
773 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
774 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
775 tmp_lift = tmp1 + tmp2 + tmp3
776
777 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
778 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
779 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k)
780
781 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
782
783 end do
784 end do
785 end do
786 end do
787 end do
788 return
◆ element_operation_kernel_matvec_divlike_var5_p2_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p2_v2 | ( | real(rp), dimension(3,3), intent(in) | mat, |
| real(rp), dimension(3,3), intent(in) | mat_tr, | ||
| real(rp), dimension(3,3,3,6), intent(in) | lift, | ||
| real(rp), dimension(3,3,5,3,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(3,3,5,3,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(3,3,5,3,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(3,3,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | e11, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | e22, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | e33, | ||
| real(rp), dimension(3,3,3,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(3,3,5,3,ne), intent(inout) | div3d ) |
Definition at line 791 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
795 implicit none
796 real(RP), intent(in) :: Mat(3,3)
797 real(RP), intent(in) :: Mat_tr(3,3)
798 real(RP), intent(in) :: Lift(3,3,3,6)
799 integer, intent(in) :: Ne
800 real(RP), intent(in) :: vec_in_x(3,3,5,3,Ne)
801 real(RP), intent(in) :: vec_in_y(3,3,5,3,Ne)
802 real(RP), intent(in) :: vec_in_z(3,3,5,3,Ne)
803 real(RP), intent(in) :: ebnd_flux(3,3,6,5,Ne)
804 real(RP), intent(in) :: E11(3,3,3,Ne)
805 real(RP), intent(in) :: E22(3,3,3,Ne)
806 real(RP), intent(in) :: E33(3,3,3,Ne)
807 real(RP), intent(in) :: Gsqrt(3,3,3,Ne)
808 real(RP), intent(inout) :: div3D(3,3,5,3,Ne)
809
810 integer :: ke
811 integer :: p, i, j, k, v, n
812 real(RP) :: tmp1
813 real(RP) :: tmp_lift
814 real(RP) :: tmp2, tmp3
815
816 real(RP) :: invG, e33_
817 real(RP) :: div_x, div_xy
818
819 real(RP) :: tmp_vec_in_y(3)
820
821 real(RP) :: s1, s2, s3, s4
822 real(RP) :: e11_
823 !----------------------------------------------------------
824
825 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
826 do ke=1, ne
827 do k=1, 3
828 !$acc loop vector collapse(2)
829 do j=1, 3
830 do i=1, 3
831 e11_ = e11(i,j,k,ke)
832 ! X-dir
833 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
834
835 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
836 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) )
837 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
838
839 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
840 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) )
841 div3d(i,j,1,k,ke) = s1 * e11_
842 div3d(i,j,2,k,ke) = s2 * e11_
843
844 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
845
846 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
847 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) )
848 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
849
850 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
851 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) )
852 div3d(i,j,3,k,ke) = s1 * e11_
853 div3d(i,j,4,k,ke) = s2 * e11_
854
855 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
856
857 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
858 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) )
859 div3d(i,j,5,k,ke) = s1 * e11_
860 end do
861 end do
862 end do
863 end do
864
865 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
866 do ke=1, ne
867 do k=1, 3
868 do v=1, 5
869 !$acc loop vector collapse(2)
870 do j=1, 3
871 do i=1, 3
872
873 ! Y-dir
874 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
875
876 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
877 + tmp_vec_in_y(2) * mat_tr(2,j) &
878 + tmp_vec_in_y(3) * mat_tr(3,j)
879! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
880 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
881 end do
882 end do
883 end do
884 end do
885 end do
886
887 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
888 do ke=1, ne
889 do k=1, 3
890 do v=1, 5
891 !$acc loop vector collapse(2)
892 do j=1, 3
893 do i=1, 3
894
895 invg = 1.0_rp / gsqrt(i,j,k,ke)
896 e33_ = e33(i,j,k,ke)
897
898
899 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
900 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
901 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
902 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
903 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
904 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
905 tmp_lift = tmp1 + tmp2 + tmp3
906
907 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
908 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
909 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k)
910! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
911 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
912
913 end do
914 end do
915 end do
916 end do
917 end do
918
919 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(3,3,3,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(3,3,3,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=2.
Definition at line 926 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
929 implicit none
930 integer, intent(in) :: Ne
931 real(RP), intent(in) :: Mat_h1D(3,3)
932 real(RP), intent(in) :: Mat_h1D_tr(3,3)
933 real(RP), intent(in) :: Mat_v1D_tr(3,3)
934 real(RP), intent(in) :: vec_in(3,3,3,Ne)
935 real(RP), intent(out) :: vec_work(3,3,3,Ne)
936 real(RP), intent(out) :: vec_out(3,3,3,Ne)
937
938 integer :: ke
939 integer :: i, j, k
940 !----------------------------------------------------------
941
942 ! X-dir
943 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
944 do ke=1, ne
945 do k=1, 3
946 !$acc loop vector collapse(2)
947 do j=1, 3
948 do i=1, 3
949 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
950 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
951 + mat_h1d(i,3) * vec_in(3,j,k,ke)
952 end do
953 end do
954 end do
955 end do
956
957 ! Y-dir
958 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
959 do ke=1, ne
960 do k=1, 3
961 !$acc loop vector collapse(2)
962 do j=1, 3
963 do i=1, 3
964 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
965 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
966 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j)
967 end do
968 end do
969 end do
970 end do
971
972 ! Z-dir
973 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
974 do ke=1, ne
975 do k=1, 3
976 !$acc loop vector collapse(2)
977 do j=1, 3
978 do i=1, 3
979 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
980 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
981 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k)
982 end do
983 end do
984 end do
985 end do
986 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p3()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p3 | ( | real(rp), dimension(4,4), intent(in) | mat_z_tr, |
| real(rp), dimension(4**2,4,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(4**2,4,ne_out), 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 995 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
996 implicit none
997 integer, intent(in) :: Ne_in
998 integer, intent(in) :: Ne_out
999 real(RP), intent(in) :: Mat_z_tr(4,4)
1000 real(RP), intent(in) :: vec_in(4**2,4,Ne_in)
1001 real(RP), intent(out) :: vec_out(4**2,4,Ne_out)
1002
1003 integer :: ij, k, ke
1004 !----------------------------------------------------------
1005
1006 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
1007 do ke=1, ne_out
1008 do k=1, 4
1009 do ij=1, 4**2
1010 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
1011 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
1012 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
1013 + vec_in(ij,4,ke) * mat_z_tr(4,k)
1014 end do
1015 end do
1016 end do
1017
1018 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p3()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p3 | ( | real(rp), dimension(4,4), intent(in) | mat, |
| real(rp), dimension(4,4), intent(in) | mat_tr, | ||
| real(rp), dimension(4,4), intent(in) | vec_in_x, | ||
| real(rp), dimension(4,4), intent(in) | vec_in_y, | ||
| real(rp), dimension(4,4), intent(in) | e11, | ||
| real(rp), dimension(4,4), intent(in) | e22, | ||
| real(rp), dimension(4,4), intent(out) | div_out_xy ) |
Definition at line 1021 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1025 implicit none
1026 real(RP), intent(in) :: Mat(4,4)
1027 real(RP), intent(in) :: Mat_tr(4,4)
1028 real(RP), intent(in) :: vec_in_x(4,4)
1029 real(RP), intent(in) :: vec_in_y(4,4)
1030 real(RP), intent(in) :: E11(4,4)
1031 real(RP), intent(in) :: E22(4,4)
1032 real(RP), intent(out) :: div_out_xy(4,4)
1033
1034 integer :: i, j, jv, jk
1035 real(RP) :: tmp1, div_x
1036 !----------------------------------------------------------
1037 !$acc routine vector
1038
1039 !$acc loop vector collapse(2)
1040 do j=1, 4
1041 do i=1, 4
1042 ! X-dir
1043 div_x = ( mat(i,1) * vec_in_x(1,j) &
1044
1045 + mat(i,2) * vec_in_x(2,j) &
1046 + mat(i,3) * vec_in_x(3,j) &
1047 + mat(i,4) * vec_in_x(4,j) ) * e11(i,j)
1048
1049 ! Y-dir
1050 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
1051 + vec_in_y(i,2) * mat_tr(2,j) &
1052 + vec_in_y(i,3) * mat_tr(3,j) &
1053 + vec_in_y(i,4) * mat_tr(4,j)
1054 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
1055 end do
1056 end do
1057 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p3()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p3 | ( | real(rp), dimension(4,4), intent(in) | mat, |
| real(rp), dimension(4,4), intent(in) | mat_tr, | ||
| real(rp), dimension(4,4,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(4,4,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(4,4), intent(in) | e11, | ||
| real(rp), dimension(4,4), intent(in) | e22, | ||
| real(rp), dimension(4,4,5), intent(out) | div_out_xy ) |
Definition at line 1060 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1064 implicit none
1065 real(RP), intent(in) :: Mat(4,4)
1066 real(RP), intent(in) :: Mat_tr(4,4)
1067 real(RP), intent(in) :: vec_in_x(4,4,5)
1068 real(RP), intent(in) :: vec_in_y(4,4,5)
1069 real(RP), intent(in) :: E11(4,4)
1070 real(RP), intent(in) :: E22(4,4)
1071 real(RP), intent(out) :: div_out_xy(4,4,5)
1072
1073 integer :: i, j, jv, jk, v, kv
1074 real(RP) :: tmp1, div_x
1075 !----------------------------------------------------------
1076 !$acc routine vector
1077
1078 do v=1, 5
1079 !$acc loop vector collapse(2)
1080 do j=1, 4
1081 do i=1, 4
1082 ! X-dir
1083 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
1084
1085 + mat(i,2) * vec_in_x(2,j,v) &
1086 + mat(i,3) * vec_in_x(3,j,v) &
1087 + mat(i,4) * vec_in_x(4,j,v) ) * e11(i,j)
1088
1089 ! Y-dir
1090 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
1091 + vec_in_y(i,2,v) * mat_tr(2,j) &
1092 + vec_in_y(i,3,v) * mat_tr(3,j) &
1093 + vec_in_y(i,4,v) * mat_tr(4,j)
1094 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
1095 end do
1096 end do
1097 end do
1098 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p3()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p3 | ( | real(rp), dimension(4,4), intent(in) | mat_tr, |
| real(rp), dimension(4,4,4,6), intent(in) | lift, | ||
| real(rp), dimension(4,4,5,4), intent(in) | vec_in_z, | ||
| real(rp), dimension(4,4,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(4,4,4), intent(in) | e33, | ||
| real(rp), dimension(4,4,4), intent(in) | gsqrt, | ||
| real(rp), dimension(4,4,5,4), intent(inout) | div3d ) |
Definition at line 1101 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1104 implicit none
1105 real(RP), intent(in) :: Mat_tr(4,4)
1106 real(RP), intent(in) :: Lift(4,4,4,6)
1107 real(RP), intent(in) :: vec_in_z(4,4,5,4)
1108 real(RP), intent(in) :: ebnd_flux(4,4,6,5)
1109 real(RP), intent(in) :: E33(4,4,4)
1110 real(RP), intent(in) :: Gsqrt(4,4,4)
1111 real(RP), intent(inout) :: div3D(4,4,5,4)
1112
1113 integer :: i, j, k, v
1114 real(RP) :: tmp1
1115 real(RP) :: tmp_lift
1116 real(RP) :: tmp2, tmp3
1117 real(RP) :: invG, e33_
1118 !----------------------------------------------------------
1119
1120 !$acc routine vector
1121
1122 ! Z-dir
1123 do v=1, 5
1124 do k=1, 4
1125 !$acc loop vector collapse(2)
1126 do j=1, 4
1127 do i=1, 4
1128 invg = 1.0_rp / gsqrt(i,j,k)
1129 e33_ = e33(i,j,k)
1130
1131
1132 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
1133 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
1134 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
1135 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
1136 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
1137 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
1138 tmp_lift = tmp1 + tmp2 + tmp3
1139
1140 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
1141 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
1142 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
1143 + vec_in_z(i,j,v,4) * mat_tr(4,k)
1144! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
1145 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
1146
1147 end do
1148 end do
1149 end do
1150 end do
1151 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p3()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p3 | ( | real(rp), dimension(4,4), intent(in) | mat, |
| real(rp), dimension(4,4), intent(in) | mat_tr, | ||
| real(rp), dimension(4,4,4,6), intent(in) | lift, | ||
| real(rp), dimension(4,4,5,4,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(4,4,5,4,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(4,4,5,4,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(4,4,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | e11, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | e22, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | e33, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(4,4,5,4,ne), intent(inout) | div3d ) |
Definition at line 1154 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1158 implicit none
1159 real(RP), intent(in) :: Mat(4,4)
1160 real(RP), intent(in) :: Mat_tr(4,4)
1161 real(RP), intent(in) :: Lift(4,4,4,6)
1162 integer, intent(in) :: Ne
1163 real(RP), intent(in) :: vec_in_x(4,4,5,4,Ne)
1164 real(RP), intent(in) :: vec_in_y(4,4,5,4,Ne)
1165 real(RP), intent(in) :: vec_in_z(4,4,5,4,Ne)
1166 real(RP), intent(in) :: ebnd_flux(4,4,6,5,Ne)
1167 real(RP), intent(in) :: E11(4,4,4,Ne)
1168 real(RP), intent(in) :: E22(4,4,4,Ne)
1169 real(RP), intent(in) :: E33(4,4,4,Ne)
1170 real(RP), intent(in) :: Gsqrt(4,4,4,Ne)
1171 real(RP), intent(inout) :: div3D(4,4,5,4,Ne)
1172
1173 integer :: ke
1174 integer :: i, j, k, v
1175 real(RP) :: tmp1
1176 real(RP) :: tmp_lift
1177 real(RP) :: tmp2, tmp3
1178 real(RP) :: invG, e33_
1179 real(RP) :: div_x, div_xy
1180 !----------------------------------------------------------
1181
1182 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
1183 do ke=1, ne
1184 do k=1, 4
1185 do v=1, 5
1186 !$acc loop vector collapse(2)
1187 do j=1, 4
1188 do i=1, 4
1189 ! X-dir
1190 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
1191
1192 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
1193 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
1194 + mat(i,4) * vec_in_x(4,j,v,k,ke) ) * e11(i,j,k,ke)
1195
1196 ! Y-dir
1197 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
1198 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
1199 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
1200 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j)
1201 div_xy = div_x + tmp1 * e22(i,j,k,ke)
1202
1203
1204 ! Z-dir
1205
1206 invg = 1.0_rp / gsqrt(i,j,k,ke)
1207 e33_ = e33(i,j,k,ke)
1208
1209
1210 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
1211 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
1212 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
1213 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
1214 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
1215 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
1216 tmp_lift = tmp1 + tmp2 + tmp3
1217
1218 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
1219 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
1220 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
1221 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
1222
1223 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
1224
1225 end do
1226 end do
1227 end do
1228 end do
1229 end do
1230 return
◆ element_operation_kernel_matvec_divlike_var5_p3_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p3_v2 | ( | real(rp), dimension(4,4), intent(in) | mat, |
| real(rp), dimension(4,4), intent(in) | mat_tr, | ||
| real(rp), dimension(4,4,4,6), intent(in) | lift, | ||
| real(rp), dimension(4,4,5,4,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(4,4,5,4,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(4,4,5,4,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(4,4,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | e11, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | e22, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | e33, | ||
| real(rp), dimension(4,4,4,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(4,4,5,4,ne), intent(inout) | div3d ) |
Definition at line 1233 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1237 implicit none
1238 real(RP), intent(in) :: Mat(4,4)
1239 real(RP), intent(in) :: Mat_tr(4,4)
1240 real(RP), intent(in) :: Lift(4,4,4,6)
1241 integer, intent(in) :: Ne
1242 real(RP), intent(in) :: vec_in_x(4,4,5,4,Ne)
1243 real(RP), intent(in) :: vec_in_y(4,4,5,4,Ne)
1244 real(RP), intent(in) :: vec_in_z(4,4,5,4,Ne)
1245 real(RP), intent(in) :: ebnd_flux(4,4,6,5,Ne)
1246 real(RP), intent(in) :: E11(4,4,4,Ne)
1247 real(RP), intent(in) :: E22(4,4,4,Ne)
1248 real(RP), intent(in) :: E33(4,4,4,Ne)
1249 real(RP), intent(in) :: Gsqrt(4,4,4,Ne)
1250 real(RP), intent(inout) :: div3D(4,4,5,4,Ne)
1251
1252 integer :: ke
1253 integer :: p, i, j, k, v, n
1254 real(RP) :: tmp1
1255 real(RP) :: tmp_lift
1256 real(RP) :: tmp2, tmp3
1257
1258 real(RP) :: invG, e33_
1259 real(RP) :: div_x, div_xy
1260
1261 real(RP) :: tmp_vec_in_y(4)
1262
1263 real(RP) :: s1, s2, s3, s4
1264 real(RP) :: e11_
1265 !----------------------------------------------------------
1266
1267 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
1268 do ke=1, ne
1269 do k=1, 4
1270 !$acc loop vector collapse(2)
1271 do j=1, 4
1272 do i=1, 4
1273 e11_ = e11(i,j,k,ke)
1274 ! X-dir
1275 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
1276
1277 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
1278 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
1279 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) )
1280 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
1281
1282 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
1283 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
1284 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) )
1285 div3d(i,j,1,k,ke) = s1 * e11_
1286 div3d(i,j,2,k,ke) = s2 * e11_
1287
1288 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
1289
1290 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
1291 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
1292 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) )
1293 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
1294
1295 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
1296 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
1297 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) )
1298 div3d(i,j,3,k,ke) = s1 * e11_
1299 div3d(i,j,4,k,ke) = s2 * e11_
1300
1301 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
1302
1303 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
1304 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
1305 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) )
1306 div3d(i,j,5,k,ke) = s1 * e11_
1307 end do
1308 end do
1309 end do
1310 end do
1311
1312 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
1313 do ke=1, ne
1314 do k=1, 4
1315 do v=1, 5
1316 !$acc loop vector collapse(2)
1317 do j=1, 4
1318 do i=1, 4
1319
1320 ! Y-dir
1321 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
1322
1323 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
1324 + tmp_vec_in_y(2) * mat_tr(2,j) &
1325 + tmp_vec_in_y(3) * mat_tr(3,j) &
1326 + tmp_vec_in_y(4) * mat_tr(4,j)
1327! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
1328 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
1329 end do
1330 end do
1331 end do
1332 end do
1333 end do
1334
1335 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
1336 do ke=1, ne
1337 do k=1, 4
1338 do v=1, 5
1339 !$acc loop vector collapse(2)
1340 do j=1, 4
1341 do i=1, 4
1342
1343 invg = 1.0_rp / gsqrt(i,j,k,ke)
1344 e33_ = e33(i,j,k,ke)
1345
1346
1347 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
1348 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
1349 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
1350 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
1351 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
1352 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
1353 tmp_lift = tmp1 + tmp2 + tmp3
1354
1355 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
1356 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
1357 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
1358 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
1359! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
1360 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
1361
1362 end do
1363 end do
1364 end do
1365 end do
1366 end do
1367
1368 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p3()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(4,4,4,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(4,4,4,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=3.
Definition at line 1375 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1378 implicit none
1379 integer, intent(in) :: Ne
1380 real(RP), intent(in) :: Mat_h1D(4,4)
1381 real(RP), intent(in) :: Mat_h1D_tr(4,4)
1382 real(RP), intent(in) :: Mat_v1D_tr(4,4)
1383 real(RP), intent(in) :: vec_in(4,4,4,Ne)
1384 real(RP), intent(out) :: vec_work(4,4,4,Ne)
1385 real(RP), intent(out) :: vec_out(4,4,4,Ne)
1386
1387 integer :: ke
1388 integer :: i, j, k
1389 !----------------------------------------------------------
1390
1391 ! X-dir
1392 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
1393 do ke=1, ne
1394 do k=1, 4
1395 !$acc loop vector collapse(2)
1396 do j=1, 4
1397 do i=1, 4
1398 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
1399 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
1400 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
1401 + mat_h1d(i,4) * vec_in(4,j,k,ke)
1402 end do
1403 end do
1404 end do
1405 end do
1406
1407 ! Y-dir
1408 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
1409 do ke=1, ne
1410 do k=1, 4
1411 !$acc loop vector collapse(2)
1412 do j=1, 4
1413 do i=1, 4
1414 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
1415 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
1416 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
1417 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j)
1418 end do
1419 end do
1420 end do
1421 end do
1422
1423 ! Z-dir
1424 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
1425 do ke=1, ne
1426 do k=1, 4
1427 !$acc loop vector collapse(2)
1428 do j=1, 4
1429 do i=1, 4
1430 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
1431 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
1432 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
1433 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k)
1434 end do
1435 end do
1436 end do
1437 end do
1438 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p4()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p4 | ( | real(rp), dimension(5,5), intent(in) | mat_z_tr, |
| real(rp), dimension(5**2,5,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(5**2,5,ne_out), 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 1447 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1448 implicit none
1449 integer, intent(in) :: Ne_in
1450 integer, intent(in) :: Ne_out
1451 real(RP), intent(in) :: Mat_z_tr(5,5)
1452 real(RP), intent(in) :: vec_in(5**2,5,Ne_in)
1453 real(RP), intent(out) :: vec_out(5**2,5,Ne_out)
1454
1455 integer :: ij, k, ke
1456 !----------------------------------------------------------
1457
1458 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
1459 do ke=1, ne_out
1460 do k=1, 5
1461 do ij=1, 5**2
1462 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
1463 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
1464 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
1465 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
1466 + vec_in(ij,5,ke) * mat_z_tr(5,k)
1467 end do
1468 end do
1469 end do
1470
1471 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p4()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p4 | ( | real(rp), dimension(5,5), intent(in) | mat, |
| real(rp), dimension(5,5), intent(in) | mat_tr, | ||
| real(rp), dimension(5,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(5,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(5,5), intent(in) | e11, | ||
| real(rp), dimension(5,5), intent(in) | e22, | ||
| real(rp), dimension(5,5), intent(out) | div_out_xy ) |
Definition at line 1474 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1478 implicit none
1479 real(RP), intent(in) :: Mat(5,5)
1480 real(RP), intent(in) :: Mat_tr(5,5)
1481 real(RP), intent(in) :: vec_in_x(5,5)
1482 real(RP), intent(in) :: vec_in_y(5,5)
1483 real(RP), intent(in) :: E11(5,5)
1484 real(RP), intent(in) :: E22(5,5)
1485 real(RP), intent(out) :: div_out_xy(5,5)
1486
1487 integer :: i, j, jv, jk
1488 real(RP) :: tmp1, div_x
1489 !----------------------------------------------------------
1490 !$acc routine vector
1491
1492 !$acc loop vector collapse(2)
1493 do j=1, 5
1494 do i=1, 5
1495 ! X-dir
1496 div_x = ( mat(i,1) * vec_in_x(1,j) &
1497
1498 + mat(i,2) * vec_in_x(2,j) &
1499 + mat(i,3) * vec_in_x(3,j) &
1500 + mat(i,4) * vec_in_x(4,j) &
1501 + mat(i,5) * vec_in_x(5,j) ) * e11(i,j)
1502
1503 ! Y-dir
1504 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
1505 + vec_in_y(i,2) * mat_tr(2,j) &
1506 + vec_in_y(i,3) * mat_tr(3,j) &
1507 + vec_in_y(i,4) * mat_tr(4,j) &
1508 + vec_in_y(i,5) * mat_tr(5,j)
1509 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
1510 end do
1511 end do
1512 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p4()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_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_x, | ||
| real(rp), dimension(5,5,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(5,5), intent(in) | e11, | ||
| real(rp), dimension(5,5), intent(in) | e22, | ||
| real(rp), dimension(5,5,5), intent(out) | div_out_xy ) |
Definition at line 1515 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1519 implicit none
1520 real(RP), intent(in) :: Mat(5,5)
1521 real(RP), intent(in) :: Mat_tr(5,5)
1522 real(RP), intent(in) :: vec_in_x(5,5,5)
1523 real(RP), intent(in) :: vec_in_y(5,5,5)
1524 real(RP), intent(in) :: E11(5,5)
1525 real(RP), intent(in) :: E22(5,5)
1526 real(RP), intent(out) :: div_out_xy(5,5,5)
1527
1528 integer :: i, j, jv, jk, v, kv
1529 real(RP) :: tmp1, div_x
1530 !----------------------------------------------------------
1531 !$acc routine vector
1532
1533 do v=1, 5
1534 !$acc loop vector collapse(2)
1535 do j=1, 5
1536 do i=1, 5
1537 ! X-dir
1538 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
1539
1540 + mat(i,2) * vec_in_x(2,j,v) &
1541 + mat(i,3) * vec_in_x(3,j,v) &
1542 + mat(i,4) * vec_in_x(4,j,v) &
1543 + mat(i,5) * vec_in_x(5,j,v) ) * e11(i,j)
1544
1545 ! Y-dir
1546 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
1547 + vec_in_y(i,2,v) * mat_tr(2,j) &
1548 + vec_in_y(i,3,v) * mat_tr(3,j) &
1549 + vec_in_y(i,4,v) * mat_tr(4,j) &
1550 + vec_in_y(i,5,v) * mat_tr(5,j)
1551 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
1552 end do
1553 end do
1554 end do
1555 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p4()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p4 | ( | real(rp), dimension(5,5), intent(in) | mat_tr, |
| real(rp), dimension(5,5,5,6), intent(in) | lift, | ||
| real(rp), dimension(5,5,5,5), intent(in) | vec_in_z, | ||
| real(rp), dimension(5,5,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(5,5,5), intent(in) | e33, | ||
| real(rp), dimension(5,5,5), intent(in) | gsqrt, | ||
| real(rp), dimension(5,5,5,5), intent(inout) | div3d ) |
Definition at line 1558 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1561 implicit none
1562 real(RP), intent(in) :: Mat_tr(5,5)
1563 real(RP), intent(in) :: Lift(5,5,5,6)
1564 real(RP), intent(in) :: vec_in_z(5,5,5,5)
1565 real(RP), intent(in) :: ebnd_flux(5,5,6,5)
1566 real(RP), intent(in) :: E33(5,5,5)
1567 real(RP), intent(in) :: Gsqrt(5,5,5)
1568 real(RP), intent(inout) :: div3D(5,5,5,5)
1569
1570 integer :: i, j, k, v
1571 real(RP) :: tmp1
1572 real(RP) :: tmp_lift
1573 real(RP) :: tmp2, tmp3
1574 real(RP) :: invG, e33_
1575 !----------------------------------------------------------
1576
1577 !$acc routine vector
1578
1579 ! Z-dir
1580 do v=1, 5
1581 do k=1, 5
1582 !$acc loop vector collapse(2)
1583 do j=1, 5
1584 do i=1, 5
1585 invg = 1.0_rp / gsqrt(i,j,k)
1586 e33_ = e33(i,j,k)
1587
1588
1589 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
1590 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
1591 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
1592 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
1593 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
1594 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
1595 tmp_lift = tmp1 + tmp2 + tmp3
1596
1597 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
1598 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
1599 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
1600 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
1601 + vec_in_z(i,j,v,5) * mat_tr(5,k)
1602! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
1603 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
1604
1605 end do
1606 end do
1607 end do
1608 end do
1609 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p4()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p4 | ( | real(rp), dimension(5,5), intent(in) | mat, |
| real(rp), dimension(5,5), intent(in) | mat_tr, | ||
| real(rp), dimension(5,5,5,6), intent(in) | lift, | ||
| real(rp), dimension(5,5,5,5,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(5,5,5,5,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(5,5,5,5,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(5,5,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | e11, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | e22, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | e33, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(5,5,5,5,ne), intent(inout) | div3d ) |
Definition at line 1612 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1616 implicit none
1617 real(RP), intent(in) :: Mat(5,5)
1618 real(RP), intent(in) :: Mat_tr(5,5)
1619 real(RP), intent(in) :: Lift(5,5,5,6)
1620 integer, intent(in) :: Ne
1621 real(RP), intent(in) :: vec_in_x(5,5,5,5,Ne)
1622 real(RP), intent(in) :: vec_in_y(5,5,5,5,Ne)
1623 real(RP), intent(in) :: vec_in_z(5,5,5,5,Ne)
1624 real(RP), intent(in) :: ebnd_flux(5,5,6,5,Ne)
1625 real(RP), intent(in) :: E11(5,5,5,Ne)
1626 real(RP), intent(in) :: E22(5,5,5,Ne)
1627 real(RP), intent(in) :: E33(5,5,5,Ne)
1628 real(RP), intent(in) :: Gsqrt(5,5,5,Ne)
1629 real(RP), intent(inout) :: div3D(5,5,5,5,Ne)
1630
1631 integer :: ke
1632 integer :: i, j, k, v
1633 real(RP) :: tmp1
1634 real(RP) :: tmp_lift
1635 real(RP) :: tmp2, tmp3
1636 real(RP) :: invG, e33_
1637 real(RP) :: div_x, div_xy
1638 !----------------------------------------------------------
1639
1640 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
1641 do ke=1, ne
1642 do k=1, 5
1643 do v=1, 5
1644 !$acc loop vector collapse(2)
1645 do j=1, 5
1646 do i=1, 5
1647 ! X-dir
1648 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
1649
1650 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
1651 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
1652 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
1653 + mat(i,5) * vec_in_x(5,j,v,k,ke) ) * e11(i,j,k,ke)
1654
1655 ! Y-dir
1656 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
1657 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
1658 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
1659 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
1660 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j)
1661 div_xy = div_x + tmp1 * e22(i,j,k,ke)
1662
1663
1664 ! Z-dir
1665
1666 invg = 1.0_rp / gsqrt(i,j,k,ke)
1667 e33_ = e33(i,j,k,ke)
1668
1669
1670 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
1671 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
1672 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
1673 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
1674 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
1675 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
1676 tmp_lift = tmp1 + tmp2 + tmp3
1677
1678 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
1679 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
1680 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
1681 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
1682 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
1683
1684 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
1685
1686 end do
1687 end do
1688 end do
1689 end do
1690 end do
1691 return
◆ element_operation_kernel_matvec_divlike_var5_p4_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p4_v2 | ( | real(rp), dimension(5,5), intent(in) | mat, |
| real(rp), dimension(5,5), intent(in) | mat_tr, | ||
| real(rp), dimension(5,5,5,6), intent(in) | lift, | ||
| real(rp), dimension(5,5,5,5,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(5,5,5,5,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(5,5,5,5,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(5,5,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | e11, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | e22, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | e33, | ||
| real(rp), dimension(5,5,5,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(5,5,5,5,ne), intent(inout) | div3d ) |
Definition at line 1694 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1698 implicit none
1699 real(RP), intent(in) :: Mat(5,5)
1700 real(RP), intent(in) :: Mat_tr(5,5)
1701 real(RP), intent(in) :: Lift(5,5,5,6)
1702 integer, intent(in) :: Ne
1703 real(RP), intent(in) :: vec_in_x(5,5,5,5,Ne)
1704 real(RP), intent(in) :: vec_in_y(5,5,5,5,Ne)
1705 real(RP), intent(in) :: vec_in_z(5,5,5,5,Ne)
1706 real(RP), intent(in) :: ebnd_flux(5,5,6,5,Ne)
1707 real(RP), intent(in) :: E11(5,5,5,Ne)
1708 real(RP), intent(in) :: E22(5,5,5,Ne)
1709 real(RP), intent(in) :: E33(5,5,5,Ne)
1710 real(RP), intent(in) :: Gsqrt(5,5,5,Ne)
1711 real(RP), intent(inout) :: div3D(5,5,5,5,Ne)
1712
1713 integer :: ke
1714 integer :: p, i, j, k, v, n
1715 real(RP) :: tmp1
1716 real(RP) :: tmp_lift
1717 real(RP) :: tmp2, tmp3
1718
1719 real(RP) :: invG, e33_
1720 real(RP) :: div_x, div_xy
1721
1722 real(RP) :: tmp_vec_in_y(5)
1723
1724 real(RP) :: s1, s2, s3, s4
1725 real(RP) :: e11_
1726 !----------------------------------------------------------
1727
1728 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
1729 do ke=1, ne
1730 do k=1, 5
1731 !$acc loop vector collapse(2)
1732 do j=1, 5
1733 do i=1, 5
1734 e11_ = e11(i,j,k,ke)
1735 ! X-dir
1736 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
1737
1738 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
1739 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
1740 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
1741 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) )
1742 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
1743
1744 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
1745 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
1746 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
1747 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) )
1748 div3d(i,j,1,k,ke) = s1 * e11_
1749 div3d(i,j,2,k,ke) = s2 * e11_
1750
1751 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
1752
1753 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
1754 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
1755 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
1756 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) )
1757 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
1758
1759 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
1760 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
1761 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
1762 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) )
1763 div3d(i,j,3,k,ke) = s1 * e11_
1764 div3d(i,j,4,k,ke) = s2 * e11_
1765
1766 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
1767
1768 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
1769 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
1770 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
1771 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) )
1772 div3d(i,j,5,k,ke) = s1 * e11_
1773 end do
1774 end do
1775 end do
1776 end do
1777
1778 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
1779 do ke=1, ne
1780 do k=1, 5
1781 do v=1, 5
1782 !$acc loop vector collapse(2)
1783 do j=1, 5
1784 do i=1, 5
1785
1786 ! Y-dir
1787 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
1788
1789 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
1790 + tmp_vec_in_y(2) * mat_tr(2,j) &
1791 + tmp_vec_in_y(3) * mat_tr(3,j) &
1792 + tmp_vec_in_y(4) * mat_tr(4,j) &
1793 + tmp_vec_in_y(5) * mat_tr(5,j)
1794! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
1795 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
1796 end do
1797 end do
1798 end do
1799 end do
1800 end do
1801
1802 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
1803 do ke=1, ne
1804 do k=1, 5
1805 do v=1, 5
1806 !$acc loop vector collapse(2)
1807 do j=1, 5
1808 do i=1, 5
1809
1810 invg = 1.0_rp / gsqrt(i,j,k,ke)
1811 e33_ = e33(i,j,k,ke)
1812
1813
1814 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
1815 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
1816 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
1817 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
1818 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
1819 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
1820 tmp_lift = tmp1 + tmp2 + tmp3
1821
1822 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
1823 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
1824 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
1825 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
1826 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
1827! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
1828 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
1829
1830 end do
1831 end do
1832 end do
1833 end do
1834 end do
1835
1836 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p4()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(5,5,5,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(5,5,5,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=4.
Definition at line 1843 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1846 implicit none
1847 integer, intent(in) :: Ne
1848 real(RP), intent(in) :: Mat_h1D(5,5)
1849 real(RP), intent(in) :: Mat_h1D_tr(5,5)
1850 real(RP), intent(in) :: Mat_v1D_tr(5,5)
1851 real(RP), intent(in) :: vec_in(5,5,5,Ne)
1852 real(RP), intent(out) :: vec_work(5,5,5,Ne)
1853 real(RP), intent(out) :: vec_out(5,5,5,Ne)
1854
1855 integer :: ke
1856 integer :: i, j, k
1857 !----------------------------------------------------------
1858
1859 ! X-dir
1860 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
1861 do ke=1, ne
1862 do k=1, 5
1863 !$acc loop vector collapse(2)
1864 do j=1, 5
1865 do i=1, 5
1866 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
1867 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
1868 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
1869 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
1870 + mat_h1d(i,5) * vec_in(5,j,k,ke)
1871 end do
1872 end do
1873 end do
1874 end do
1875
1876 ! Y-dir
1877 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
1878 do ke=1, ne
1879 do k=1, 5
1880 !$acc loop vector collapse(2)
1881 do j=1, 5
1882 do i=1, 5
1883 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
1884 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
1885 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
1886 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
1887 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j)
1888 end do
1889 end do
1890 end do
1891 end do
1892
1893 ! Z-dir
1894 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
1895 do ke=1, ne
1896 do k=1, 5
1897 !$acc loop vector collapse(2)
1898 do j=1, 5
1899 do i=1, 5
1900 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
1901 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
1902 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
1903 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
1904 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k)
1905 end do
1906 end do
1907 end do
1908 end do
1909 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p5()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p5 | ( | real(rp), dimension(6,6), intent(in) | mat_z_tr, |
| real(rp), dimension(6**2,6,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(6**2,6,ne_out), 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 1918 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1919 implicit none
1920 integer, intent(in) :: Ne_in
1921 integer, intent(in) :: Ne_out
1922 real(RP), intent(in) :: Mat_z_tr(6,6)
1923 real(RP), intent(in) :: vec_in(6**2,6,Ne_in)
1924 real(RP), intent(out) :: vec_out(6**2,6,Ne_out)
1925
1926 integer :: ij, k, ke
1927 !----------------------------------------------------------
1928
1929 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
1930 do ke=1, ne_out
1931 do k=1, 6
1932 do ij=1, 6**2
1933 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
1934 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
1935 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
1936 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
1937 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
1938 + vec_in(ij,6,ke) * mat_z_tr(6,k)
1939 end do
1940 end do
1941 end do
1942
1943 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p5()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p5 | ( | real(rp), dimension(6,6), intent(in) | mat, |
| real(rp), dimension(6,6), intent(in) | mat_tr, | ||
| real(rp), dimension(6,6), intent(in) | vec_in_x, | ||
| real(rp), dimension(6,6), intent(in) | vec_in_y, | ||
| real(rp), dimension(6,6), intent(in) | e11, | ||
| real(rp), dimension(6,6), intent(in) | e22, | ||
| real(rp), dimension(6,6), intent(out) | div_out_xy ) |
Definition at line 1946 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1950 implicit none
1951 real(RP), intent(in) :: Mat(6,6)
1952 real(RP), intent(in) :: Mat_tr(6,6)
1953 real(RP), intent(in) :: vec_in_x(6,6)
1954 real(RP), intent(in) :: vec_in_y(6,6)
1955 real(RP), intent(in) :: E11(6,6)
1956 real(RP), intent(in) :: E22(6,6)
1957 real(RP), intent(out) :: div_out_xy(6,6)
1958
1959 integer :: i, j, jv, jk
1960 real(RP) :: tmp1, div_x
1961 !----------------------------------------------------------
1962 !$acc routine vector
1963
1964 !$acc loop vector collapse(2)
1965 do j=1, 6
1966 do i=1, 6
1967 ! X-dir
1968 div_x = ( mat(i,1) * vec_in_x(1,j) &
1969
1970 + mat(i,2) * vec_in_x(2,j) &
1971 + mat(i,3) * vec_in_x(3,j) &
1972 + mat(i,4) * vec_in_x(4,j) &
1973 + mat(i,5) * vec_in_x(5,j) &
1974 + mat(i,6) * vec_in_x(6,j) ) * e11(i,j)
1975
1976 ! Y-dir
1977 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
1978 + vec_in_y(i,2) * mat_tr(2,j) &
1979 + vec_in_y(i,3) * mat_tr(3,j) &
1980 + vec_in_y(i,4) * mat_tr(4,j) &
1981 + vec_in_y(i,5) * mat_tr(5,j) &
1982 + vec_in_y(i,6) * mat_tr(6,j)
1983 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
1984 end do
1985 end do
1986 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p5()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p5 | ( | real(rp), dimension(6,6), intent(in) | mat, |
| real(rp), dimension(6,6), intent(in) | mat_tr, | ||
| real(rp), dimension(6,6,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(6,6,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(6,6), intent(in) | e11, | ||
| real(rp), dimension(6,6), intent(in) | e22, | ||
| real(rp), dimension(6,6,5), intent(out) | div_out_xy ) |
Definition at line 1989 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
1993 implicit none
1994 real(RP), intent(in) :: Mat(6,6)
1995 real(RP), intent(in) :: Mat_tr(6,6)
1996 real(RP), intent(in) :: vec_in_x(6,6,5)
1997 real(RP), intent(in) :: vec_in_y(6,6,5)
1998 real(RP), intent(in) :: E11(6,6)
1999 real(RP), intent(in) :: E22(6,6)
2000 real(RP), intent(out) :: div_out_xy(6,6,5)
2001
2002 integer :: i, j, jv, jk, v, kv
2003 real(RP) :: tmp1, div_x
2004 !----------------------------------------------------------
2005 !$acc routine vector
2006
2007 do v=1, 5
2008 !$acc loop vector collapse(2)
2009 do j=1, 6
2010 do i=1, 6
2011 ! X-dir
2012 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
2013
2014 + mat(i,2) * vec_in_x(2,j,v) &
2015 + mat(i,3) * vec_in_x(3,j,v) &
2016 + mat(i,4) * vec_in_x(4,j,v) &
2017 + mat(i,5) * vec_in_x(5,j,v) &
2018 + mat(i,6) * vec_in_x(6,j,v) ) * e11(i,j)
2019
2020 ! Y-dir
2021 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
2022 + vec_in_y(i,2,v) * mat_tr(2,j) &
2023 + vec_in_y(i,3,v) * mat_tr(3,j) &
2024 + vec_in_y(i,4,v) * mat_tr(4,j) &
2025 + vec_in_y(i,5,v) * mat_tr(5,j) &
2026 + vec_in_y(i,6,v) * mat_tr(6,j)
2027 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
2028 end do
2029 end do
2030 end do
2031 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p5()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p5 | ( | real(rp), dimension(6,6), intent(in) | mat_tr, |
| real(rp), dimension(6,6,6,6), intent(in) | lift, | ||
| real(rp), dimension(6,6,5,6), intent(in) | vec_in_z, | ||
| real(rp), dimension(6,6,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(6,6,6), intent(in) | e33, | ||
| real(rp), dimension(6,6,6), intent(in) | gsqrt, | ||
| real(rp), dimension(6,6,5,6), intent(inout) | div3d ) |
Definition at line 2034 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2037 implicit none
2038 real(RP), intent(in) :: Mat_tr(6,6)
2039 real(RP), intent(in) :: Lift(6,6,6,6)
2040 real(RP), intent(in) :: vec_in_z(6,6,5,6)
2041 real(RP), intent(in) :: ebnd_flux(6,6,6,5)
2042 real(RP), intent(in) :: E33(6,6,6)
2043 real(RP), intent(in) :: Gsqrt(6,6,6)
2044 real(RP), intent(inout) :: div3D(6,6,5,6)
2045
2046 integer :: i, j, k, v
2047 real(RP) :: tmp1
2048 real(RP) :: tmp_lift
2049 real(RP) :: tmp2, tmp3
2050 real(RP) :: invG, e33_
2051 !----------------------------------------------------------
2052
2053 !$acc routine vector
2054
2055 ! Z-dir
2056 do v=1, 5
2057 do k=1, 6
2058 !$acc loop vector collapse(2)
2059 do j=1, 6
2060 do i=1, 6
2061 invg = 1.0_rp / gsqrt(i,j,k)
2062 e33_ = e33(i,j,k)
2063
2064
2065 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
2066 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
2067 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
2068 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
2069 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
2070 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
2071 tmp_lift = tmp1 + tmp2 + tmp3
2072
2073 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
2074 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
2075 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
2076 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
2077 + vec_in_z(i,j,v,5) * mat_tr(5,k) &
2078 + vec_in_z(i,j,v,6) * mat_tr(6,k)
2079! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
2080 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
2081
2082 end do
2083 end do
2084 end do
2085 end do
2086 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p5()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p5 | ( | real(rp), dimension(6,6), intent(in) | mat, |
| real(rp), dimension(6,6), intent(in) | mat_tr, | ||
| real(rp), dimension(6,6,6,6), intent(in) | lift, | ||
| real(rp), dimension(6,6,5,6,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(6,6,5,6,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(6,6,5,6,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(6,6,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | e11, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | e22, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | e33, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(6,6,5,6,ne), intent(inout) | div3d ) |
Definition at line 2089 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2093 implicit none
2094 real(RP), intent(in) :: Mat(6,6)
2095 real(RP), intent(in) :: Mat_tr(6,6)
2096 real(RP), intent(in) :: Lift(6,6,6,6)
2097 integer, intent(in) :: Ne
2098 real(RP), intent(in) :: vec_in_x(6,6,5,6,Ne)
2099 real(RP), intent(in) :: vec_in_y(6,6,5,6,Ne)
2100 real(RP), intent(in) :: vec_in_z(6,6,5,6,Ne)
2101 real(RP), intent(in) :: ebnd_flux(6,6,6,5,Ne)
2102 real(RP), intent(in) :: E11(6,6,6,Ne)
2103 real(RP), intent(in) :: E22(6,6,6,Ne)
2104 real(RP), intent(in) :: E33(6,6,6,Ne)
2105 real(RP), intent(in) :: Gsqrt(6,6,6,Ne)
2106 real(RP), intent(inout) :: div3D(6,6,5,6,Ne)
2107
2108 integer :: ke
2109 integer :: i, j, k, v
2110 real(RP) :: tmp1
2111 real(RP) :: tmp_lift
2112 real(RP) :: tmp2, tmp3
2113 real(RP) :: invG, e33_
2114 real(RP) :: div_x, div_xy
2115 !----------------------------------------------------------
2116
2117 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
2118 do ke=1, ne
2119 do k=1, 6
2120 do v=1, 5
2121 !$acc loop vector collapse(2)
2122 do j=1, 6
2123 do i=1, 6
2124 ! X-dir
2125 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
2126
2127 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
2128 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
2129 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
2130 + mat(i,5) * vec_in_x(5,j,v,k,ke) &
2131 + mat(i,6) * vec_in_x(6,j,v,k,ke) ) * e11(i,j,k,ke)
2132
2133 ! Y-dir
2134 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
2135 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
2136 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
2137 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
2138 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
2139 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j)
2140 div_xy = div_x + tmp1 * e22(i,j,k,ke)
2141
2142
2143 ! Z-dir
2144
2145 invg = 1.0_rp / gsqrt(i,j,k,ke)
2146 e33_ = e33(i,j,k,ke)
2147
2148
2149 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
2150 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
2151 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
2152 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
2153 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
2154 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
2155 tmp_lift = tmp1 + tmp2 + tmp3
2156
2157 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
2158 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
2159 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
2160 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
2161 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
2162 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k)
2163
2164 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
2165
2166 end do
2167 end do
2168 end do
2169 end do
2170 end do
2171 return
◆ element_operation_kernel_matvec_divlike_var5_p5_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p5_v2 | ( | real(rp), dimension(6,6), intent(in) | mat, |
| real(rp), dimension(6,6), intent(in) | mat_tr, | ||
| real(rp), dimension(6,6,6,6), intent(in) | lift, | ||
| real(rp), dimension(6,6,5,6,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(6,6,5,6,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(6,6,5,6,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(6,6,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | e11, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | e22, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | e33, | ||
| real(rp), dimension(6,6,6,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(6,6,5,6,ne), intent(inout) | div3d ) |
Definition at line 2174 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2178 implicit none
2179 real(RP), intent(in) :: Mat(6,6)
2180 real(RP), intent(in) :: Mat_tr(6,6)
2181 real(RP), intent(in) :: Lift(6,6,6,6)
2182 integer, intent(in) :: Ne
2183 real(RP), intent(in) :: vec_in_x(6,6,5,6,Ne)
2184 real(RP), intent(in) :: vec_in_y(6,6,5,6,Ne)
2185 real(RP), intent(in) :: vec_in_z(6,6,5,6,Ne)
2186 real(RP), intent(in) :: ebnd_flux(6,6,6,5,Ne)
2187 real(RP), intent(in) :: E11(6,6,6,Ne)
2188 real(RP), intent(in) :: E22(6,6,6,Ne)
2189 real(RP), intent(in) :: E33(6,6,6,Ne)
2190 real(RP), intent(in) :: Gsqrt(6,6,6,Ne)
2191 real(RP), intent(inout) :: div3D(6,6,5,6,Ne)
2192
2193 integer :: ke
2194 integer :: p, i, j, k, v, n
2195 real(RP) :: tmp1
2196 real(RP) :: tmp_lift
2197 real(RP) :: tmp2, tmp3
2198
2199 real(RP) :: invG, e33_
2200 real(RP) :: div_x, div_xy
2201
2202 real(RP) :: tmp_vec_in_y(6)
2203
2204 real(RP) :: s1, s2, s3, s4
2205 real(RP) :: e11_
2206 !----------------------------------------------------------
2207
2208 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
2209 do ke=1, ne
2210 do k=1, 6
2211 !$acc loop vector collapse(2)
2212 do j=1, 6
2213 do i=1, 6
2214 e11_ = e11(i,j,k,ke)
2215 ! X-dir
2216 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
2217
2218 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
2219 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
2220 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
2221 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
2222 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) )
2223 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
2224
2225 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
2226 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
2227 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
2228 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
2229 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) )
2230 div3d(i,j,1,k,ke) = s1 * e11_
2231 div3d(i,j,2,k,ke) = s2 * e11_
2232
2233 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
2234
2235 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
2236 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
2237 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
2238 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
2239 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) )
2240 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
2241
2242 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
2243 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
2244 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
2245 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
2246 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) )
2247 div3d(i,j,3,k,ke) = s1 * e11_
2248 div3d(i,j,4,k,ke) = s2 * e11_
2249
2250 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
2251
2252 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
2253 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
2254 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
2255 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
2256 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) )
2257 div3d(i,j,5,k,ke) = s1 * e11_
2258 end do
2259 end do
2260 end do
2261 end do
2262
2263 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
2264 do ke=1, ne
2265 do k=1, 6
2266 do v=1, 5
2267 !$acc loop vector collapse(2)
2268 do j=1, 6
2269 do i=1, 6
2270
2271 ! Y-dir
2272 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
2273
2274 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
2275 + tmp_vec_in_y(2) * mat_tr(2,j) &
2276 + tmp_vec_in_y(3) * mat_tr(3,j) &
2277 + tmp_vec_in_y(4) * mat_tr(4,j) &
2278 + tmp_vec_in_y(5) * mat_tr(5,j) &
2279 + tmp_vec_in_y(6) * mat_tr(6,j)
2280! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
2281 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
2282 end do
2283 end do
2284 end do
2285 end do
2286 end do
2287
2288 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
2289 do ke=1, ne
2290 do k=1, 6
2291 do v=1, 5
2292 !$acc loop vector collapse(2)
2293 do j=1, 6
2294 do i=1, 6
2295
2296 invg = 1.0_rp / gsqrt(i,j,k,ke)
2297 e33_ = e33(i,j,k,ke)
2298
2299
2300 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
2301 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
2302 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
2303 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
2304 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
2305 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
2306 tmp_lift = tmp1 + tmp2 + tmp3
2307
2308 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
2309 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
2310 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
2311 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
2312 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
2313 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k)
2314! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
2315 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
2316
2317 end do
2318 end do
2319 end do
2320 end do
2321 end do
2322
2323 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p5()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(6,6,6,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(6,6,6,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=5.
Definition at line 2330 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2333 implicit none
2334 integer, intent(in) :: Ne
2335 real(RP), intent(in) :: Mat_h1D(6,6)
2336 real(RP), intent(in) :: Mat_h1D_tr(6,6)
2337 real(RP), intent(in) :: Mat_v1D_tr(6,6)
2338 real(RP), intent(in) :: vec_in(6,6,6,Ne)
2339 real(RP), intent(out) :: vec_work(6,6,6,Ne)
2340 real(RP), intent(out) :: vec_out(6,6,6,Ne)
2341
2342 integer :: ke
2343 integer :: i, j, k
2344 !----------------------------------------------------------
2345
2346 ! X-dir
2347 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
2348 do ke=1, ne
2349 do k=1, 6
2350 !$acc loop vector collapse(2)
2351 do j=1, 6
2352 do i=1, 6
2353 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
2354 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
2355 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
2356 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
2357 + mat_h1d(i,5) * vec_in(5,j,k,ke) &
2358 + mat_h1d(i,6) * vec_in(6,j,k,ke)
2359 end do
2360 end do
2361 end do
2362 end do
2363
2364 ! Y-dir
2365 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
2366 do ke=1, ne
2367 do k=1, 6
2368 !$acc loop vector collapse(2)
2369 do j=1, 6
2370 do i=1, 6
2371 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
2372 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
2373 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
2374 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
2375 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
2376 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j)
2377 end do
2378 end do
2379 end do
2380 end do
2381
2382 ! Z-dir
2383 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
2384 do ke=1, ne
2385 do k=1, 6
2386 !$acc loop vector collapse(2)
2387 do j=1, 6
2388 do i=1, 6
2389 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
2390 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
2391 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
2392 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
2393 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
2394 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k)
2395 end do
2396 end do
2397 end do
2398 end do
2399 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p6()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p6 | ( | real(rp), dimension(7,7), intent(in) | mat_z_tr, |
| real(rp), dimension(7**2,7,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(7**2,7,ne_out), 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 2408 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2409 implicit none
2410 integer, intent(in) :: Ne_in
2411 integer, intent(in) :: Ne_out
2412 real(RP), intent(in) :: Mat_z_tr(7,7)
2413 real(RP), intent(in) :: vec_in(7**2,7,Ne_in)
2414 real(RP), intent(out) :: vec_out(7**2,7,Ne_out)
2415
2416 integer :: ij, k, ke
2417 !----------------------------------------------------------
2418
2419 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
2420 do ke=1, ne_out
2421 do k=1, 7
2422 do ij=1, 7**2
2423 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
2424 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
2425 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
2426 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
2427 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
2428 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
2429 + vec_in(ij,7,ke) * mat_z_tr(7,k)
2430 end do
2431 end do
2432 end do
2433
2434 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p6()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p6 | ( | real(rp), dimension(7,7), intent(in) | mat, |
| real(rp), dimension(7,7), intent(in) | mat_tr, | ||
| real(rp), dimension(7,7), intent(in) | vec_in_x, | ||
| real(rp), dimension(7,7), intent(in) | vec_in_y, | ||
| real(rp), dimension(7,7), intent(in) | e11, | ||
| real(rp), dimension(7,7), intent(in) | e22, | ||
| real(rp), dimension(7,7), intent(out) | div_out_xy ) |
Definition at line 2437 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2441 implicit none
2442 real(RP), intent(in) :: Mat(7,7)
2443 real(RP), intent(in) :: Mat_tr(7,7)
2444 real(RP), intent(in) :: vec_in_x(7,7)
2445 real(RP), intent(in) :: vec_in_y(7,7)
2446 real(RP), intent(in) :: E11(7,7)
2447 real(RP), intent(in) :: E22(7,7)
2448 real(RP), intent(out) :: div_out_xy(7,7)
2449
2450 integer :: i, j, jv, jk
2451 real(RP) :: tmp1, div_x
2452 !----------------------------------------------------------
2453 !$acc routine vector
2454
2455 !$acc loop vector collapse(2)
2456 do j=1, 7
2457 do i=1, 7
2458 ! X-dir
2459 div_x = ( mat(i,1) * vec_in_x(1,j) &
2460
2461 + mat(i,2) * vec_in_x(2,j) &
2462 + mat(i,3) * vec_in_x(3,j) &
2463 + mat(i,4) * vec_in_x(4,j) &
2464 + mat(i,5) * vec_in_x(5,j) &
2465 + mat(i,6) * vec_in_x(6,j) &
2466 + mat(i,7) * vec_in_x(7,j) ) * e11(i,j)
2467
2468 ! Y-dir
2469 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
2470 + vec_in_y(i,2) * mat_tr(2,j) &
2471 + vec_in_y(i,3) * mat_tr(3,j) &
2472 + vec_in_y(i,4) * mat_tr(4,j) &
2473 + vec_in_y(i,5) * mat_tr(5,j) &
2474 + vec_in_y(i,6) * mat_tr(6,j) &
2475 + vec_in_y(i,7) * mat_tr(7,j)
2476 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
2477 end do
2478 end do
2479 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p6()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p6 | ( | real(rp), dimension(7,7), intent(in) | mat, |
| real(rp), dimension(7,7), intent(in) | mat_tr, | ||
| real(rp), dimension(7,7,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(7,7,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(7,7), intent(in) | e11, | ||
| real(rp), dimension(7,7), intent(in) | e22, | ||
| real(rp), dimension(7,7,5), intent(out) | div_out_xy ) |
Definition at line 2482 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2486 implicit none
2487 real(RP), intent(in) :: Mat(7,7)
2488 real(RP), intent(in) :: Mat_tr(7,7)
2489 real(RP), intent(in) :: vec_in_x(7,7,5)
2490 real(RP), intent(in) :: vec_in_y(7,7,5)
2491 real(RP), intent(in) :: E11(7,7)
2492 real(RP), intent(in) :: E22(7,7)
2493 real(RP), intent(out) :: div_out_xy(7,7,5)
2494
2495 integer :: i, j, jv, jk, v, kv
2496 real(RP) :: tmp1, div_x
2497 !----------------------------------------------------------
2498 !$acc routine vector
2499
2500 do v=1, 5
2501 !$acc loop vector collapse(2)
2502 do j=1, 7
2503 do i=1, 7
2504 ! X-dir
2505 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
2506
2507 + mat(i,2) * vec_in_x(2,j,v) &
2508 + mat(i,3) * vec_in_x(3,j,v) &
2509 + mat(i,4) * vec_in_x(4,j,v) &
2510 + mat(i,5) * vec_in_x(5,j,v) &
2511 + mat(i,6) * vec_in_x(6,j,v) &
2512 + mat(i,7) * vec_in_x(7,j,v) ) * e11(i,j)
2513
2514 ! Y-dir
2515 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
2516 + vec_in_y(i,2,v) * mat_tr(2,j) &
2517 + vec_in_y(i,3,v) * mat_tr(3,j) &
2518 + vec_in_y(i,4,v) * mat_tr(4,j) &
2519 + vec_in_y(i,5,v) * mat_tr(5,j) &
2520 + vec_in_y(i,6,v) * mat_tr(6,j) &
2521 + vec_in_y(i,7,v) * mat_tr(7,j)
2522 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
2523 end do
2524 end do
2525 end do
2526 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p6()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p6 | ( | real(rp), dimension(7,7), intent(in) | mat_tr, |
| real(rp), dimension(7,7,7,6), intent(in) | lift, | ||
| real(rp), dimension(7,7,5,7), intent(in) | vec_in_z, | ||
| real(rp), dimension(7,7,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(7,7,7), intent(in) | e33, | ||
| real(rp), dimension(7,7,7), intent(in) | gsqrt, | ||
| real(rp), dimension(7,7,5,7), intent(inout) | div3d ) |
Definition at line 2529 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2532 implicit none
2533 real(RP), intent(in) :: Mat_tr(7,7)
2534 real(RP), intent(in) :: Lift(7,7,7,6)
2535 real(RP), intent(in) :: vec_in_z(7,7,5,7)
2536 real(RP), intent(in) :: ebnd_flux(7,7,6,5)
2537 real(RP), intent(in) :: E33(7,7,7)
2538 real(RP), intent(in) :: Gsqrt(7,7,7)
2539 real(RP), intent(inout) :: div3D(7,7,5,7)
2540
2541 integer :: i, j, k, v
2542 real(RP) :: tmp1
2543 real(RP) :: tmp_lift
2544 real(RP) :: tmp2, tmp3
2545 real(RP) :: invG, e33_
2546 !----------------------------------------------------------
2547
2548 !$acc routine vector
2549
2550 ! Z-dir
2551 do v=1, 5
2552 do k=1, 7
2553 !$acc loop vector collapse(2)
2554 do j=1, 7
2555 do i=1, 7
2556 invg = 1.0_rp / gsqrt(i,j,k)
2557 e33_ = e33(i,j,k)
2558
2559
2560 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
2561 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
2562 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
2563 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
2564 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
2565 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
2566 tmp_lift = tmp1 + tmp2 + tmp3
2567
2568 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
2569 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
2570 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
2571 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
2572 + vec_in_z(i,j,v,5) * mat_tr(5,k) &
2573 + vec_in_z(i,j,v,6) * mat_tr(6,k) &
2574 + vec_in_z(i,j,v,7) * mat_tr(7,k)
2575! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
2576 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
2577
2578 end do
2579 end do
2580 end do
2581 end do
2582 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p6()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p6 | ( | real(rp), dimension(7,7), intent(in) | mat, |
| real(rp), dimension(7,7), intent(in) | mat_tr, | ||
| real(rp), dimension(7,7,7,6), intent(in) | lift, | ||
| real(rp), dimension(7,7,5,7,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(7,7,5,7,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(7,7,5,7,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(7,7,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | e11, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | e22, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | e33, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(7,7,5,7,ne), intent(inout) | div3d ) |
Definition at line 2585 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2589 implicit none
2590 real(RP), intent(in) :: Mat(7,7)
2591 real(RP), intent(in) :: Mat_tr(7,7)
2592 real(RP), intent(in) :: Lift(7,7,7,6)
2593 integer, intent(in) :: Ne
2594 real(RP), intent(in) :: vec_in_x(7,7,5,7,Ne)
2595 real(RP), intent(in) :: vec_in_y(7,7,5,7,Ne)
2596 real(RP), intent(in) :: vec_in_z(7,7,5,7,Ne)
2597 real(RP), intent(in) :: ebnd_flux(7,7,6,5,Ne)
2598 real(RP), intent(in) :: E11(7,7,7,Ne)
2599 real(RP), intent(in) :: E22(7,7,7,Ne)
2600 real(RP), intent(in) :: E33(7,7,7,Ne)
2601 real(RP), intent(in) :: Gsqrt(7,7,7,Ne)
2602 real(RP), intent(inout) :: div3D(7,7,5,7,Ne)
2603
2604 integer :: ke
2605 integer :: i, j, k, v
2606 real(RP) :: tmp1
2607 real(RP) :: tmp_lift
2608 real(RP) :: tmp2, tmp3
2609 real(RP) :: invG, e33_
2610 real(RP) :: div_x, div_xy
2611 !----------------------------------------------------------
2612
2613 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
2614 do ke=1, ne
2615 do k=1, 7
2616 do v=1, 5
2617 !$acc loop vector collapse(2)
2618 do j=1, 7
2619 do i=1, 7
2620 ! X-dir
2621 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
2622
2623 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
2624 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
2625 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
2626 + mat(i,5) * vec_in_x(5,j,v,k,ke) &
2627 + mat(i,6) * vec_in_x(6,j,v,k,ke) &
2628 + mat(i,7) * vec_in_x(7,j,v,k,ke) ) * e11(i,j,k,ke)
2629
2630 ! Y-dir
2631 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
2632 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
2633 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
2634 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
2635 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
2636 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
2637 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j)
2638 div_xy = div_x + tmp1 * e22(i,j,k,ke)
2639
2640
2641 ! Z-dir
2642
2643 invg = 1.0_rp / gsqrt(i,j,k,ke)
2644 e33_ = e33(i,j,k,ke)
2645
2646
2647 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
2648 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
2649 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
2650 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
2651 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
2652 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
2653 tmp_lift = tmp1 + tmp2 + tmp3
2654
2655 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
2656 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
2657 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
2658 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
2659 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
2660 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
2661 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k)
2662
2663 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
2664
2665 end do
2666 end do
2667 end do
2668 end do
2669 end do
2670 return
◆ element_operation_kernel_matvec_divlike_var5_p6_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p6_v2 | ( | real(rp), dimension(7,7), intent(in) | mat, |
| real(rp), dimension(7,7), intent(in) | mat_tr, | ||
| real(rp), dimension(7,7,7,6), intent(in) | lift, | ||
| real(rp), dimension(7,7,5,7,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(7,7,5,7,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(7,7,5,7,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(7,7,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | e11, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | e22, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | e33, | ||
| real(rp), dimension(7,7,7,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(7,7,5,7,ne), intent(inout) | div3d ) |
Definition at line 2673 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2677 implicit none
2678 real(RP), intent(in) :: Mat(7,7)
2679 real(RP), intent(in) :: Mat_tr(7,7)
2680 real(RP), intent(in) :: Lift(7,7,7,6)
2681 integer, intent(in) :: Ne
2682 real(RP), intent(in) :: vec_in_x(7,7,5,7,Ne)
2683 real(RP), intent(in) :: vec_in_y(7,7,5,7,Ne)
2684 real(RP), intent(in) :: vec_in_z(7,7,5,7,Ne)
2685 real(RP), intent(in) :: ebnd_flux(7,7,6,5,Ne)
2686 real(RP), intent(in) :: E11(7,7,7,Ne)
2687 real(RP), intent(in) :: E22(7,7,7,Ne)
2688 real(RP), intent(in) :: E33(7,7,7,Ne)
2689 real(RP), intent(in) :: Gsqrt(7,7,7,Ne)
2690 real(RP), intent(inout) :: div3D(7,7,5,7,Ne)
2691
2692 integer :: ke
2693 integer :: p, i, j, k, v, n
2694 real(RP) :: tmp1
2695 real(RP) :: tmp_lift
2696 real(RP) :: tmp2, tmp3
2697
2698 real(RP) :: invG, e33_
2699 real(RP) :: div_x, div_xy
2700
2701 real(RP) :: tmp_vec_in_y(7)
2702
2703 real(RP) :: s1, s2, s3, s4
2704 real(RP) :: e11_
2705 !----------------------------------------------------------
2706
2707 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
2708 do ke=1, ne
2709 do k=1, 7
2710 !$acc loop vector collapse(2)
2711 do j=1, 7
2712 do i=1, 7
2713 e11_ = e11(i,j,k,ke)
2714 ! X-dir
2715 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
2716
2717 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
2718 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
2719 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
2720 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
2721 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
2722 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) )
2723 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
2724
2725 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
2726 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
2727 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
2728 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
2729 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
2730 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) )
2731 div3d(i,j,1,k,ke) = s1 * e11_
2732 div3d(i,j,2,k,ke) = s2 * e11_
2733
2734 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
2735
2736 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
2737 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
2738 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
2739 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
2740 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
2741 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) )
2742 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
2743
2744 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
2745 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
2746 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
2747 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
2748 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
2749 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) )
2750 div3d(i,j,3,k,ke) = s1 * e11_
2751 div3d(i,j,4,k,ke) = s2 * e11_
2752
2753 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
2754
2755 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
2756 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
2757 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
2758 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
2759 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
2760 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) )
2761 div3d(i,j,5,k,ke) = s1 * e11_
2762 end do
2763 end do
2764 end do
2765 end do
2766
2767 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
2768 do ke=1, ne
2769 do k=1, 7
2770 do v=1, 5
2771 !$acc loop vector collapse(2)
2772 do j=1, 7
2773 do i=1, 7
2774
2775 ! Y-dir
2776 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
2777
2778 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
2779 + tmp_vec_in_y(2) * mat_tr(2,j) &
2780 + tmp_vec_in_y(3) * mat_tr(3,j) &
2781 + tmp_vec_in_y(4) * mat_tr(4,j) &
2782 + tmp_vec_in_y(5) * mat_tr(5,j) &
2783 + tmp_vec_in_y(6) * mat_tr(6,j) &
2784 + tmp_vec_in_y(7) * mat_tr(7,j)
2785! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
2786 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
2787 end do
2788 end do
2789 end do
2790 end do
2791 end do
2792
2793 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
2794 do ke=1, ne
2795 do k=1, 7
2796 do v=1, 5
2797 !$acc loop vector collapse(2)
2798 do j=1, 7
2799 do i=1, 7
2800
2801 invg = 1.0_rp / gsqrt(i,j,k,ke)
2802 e33_ = e33(i,j,k,ke)
2803
2804
2805 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
2806 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
2807 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
2808 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
2809 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
2810 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
2811 tmp_lift = tmp1 + tmp2 + tmp3
2812
2813 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
2814 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
2815 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
2816 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
2817 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
2818 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
2819 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k)
2820! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
2821 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
2822
2823 end do
2824 end do
2825 end do
2826 end do
2827 end do
2828
2829 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p6()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(7,7,7,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(7,7,7,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=6.
Definition at line 2836 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2839 implicit none
2840 integer, intent(in) :: Ne
2841 real(RP), intent(in) :: Mat_h1D(7,7)
2842 real(RP), intent(in) :: Mat_h1D_tr(7,7)
2843 real(RP), intent(in) :: Mat_v1D_tr(7,7)
2844 real(RP), intent(in) :: vec_in(7,7,7,Ne)
2845 real(RP), intent(out) :: vec_work(7,7,7,Ne)
2846 real(RP), intent(out) :: vec_out(7,7,7,Ne)
2847
2848 integer :: ke
2849 integer :: i, j, k
2850 !----------------------------------------------------------
2851
2852 ! X-dir
2853 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
2854 do ke=1, ne
2855 do k=1, 7
2856 !$acc loop vector collapse(2)
2857 do j=1, 7
2858 do i=1, 7
2859 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
2860 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
2861 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
2862 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
2863 + mat_h1d(i,5) * vec_in(5,j,k,ke) &
2864 + mat_h1d(i,6) * vec_in(6,j,k,ke) &
2865 + mat_h1d(i,7) * vec_in(7,j,k,ke)
2866 end do
2867 end do
2868 end do
2869 end do
2870
2871 ! Y-dir
2872 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
2873 do ke=1, ne
2874 do k=1, 7
2875 !$acc loop vector collapse(2)
2876 do j=1, 7
2877 do i=1, 7
2878 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
2879 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
2880 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
2881 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
2882 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
2883 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
2884 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j)
2885 end do
2886 end do
2887 end do
2888 end do
2889
2890 ! Z-dir
2891 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
2892 do ke=1, ne
2893 do k=1, 7
2894 !$acc loop vector collapse(2)
2895 do j=1, 7
2896 do i=1, 7
2897 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
2898 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
2899 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
2900 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
2901 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
2902 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
2903 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k)
2904 end do
2905 end do
2906 end do
2907 end do
2908 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p7()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p7 | ( | real(rp), dimension(8,8), intent(in) | mat_z_tr, |
| real(rp), dimension(8**2,8,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(8**2,8,ne_out), 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 2917 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2918 implicit none
2919 integer, intent(in) :: Ne_in
2920 integer, intent(in) :: Ne_out
2921 real(RP), intent(in) :: Mat_z_tr(8,8)
2922 real(RP), intent(in) :: vec_in(8**2,8,Ne_in)
2923 real(RP), intent(out) :: vec_out(8**2,8,Ne_out)
2924
2925 integer :: ij, k, ke
2926 !----------------------------------------------------------
2927
2928 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
2929 do ke=1, ne_out
2930 do k=1, 8
2931 do ij=1, 8**2
2932 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
2933 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
2934 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
2935 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
2936 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
2937 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
2938 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
2939 + vec_in(ij,8,ke) * mat_z_tr(8,k)
2940 end do
2941 end do
2942 end do
2943
2944 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p7()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p7 | ( | real(rp), dimension(8,8), intent(in) | mat, |
| real(rp), dimension(8,8), intent(in) | mat_tr, | ||
| real(rp), dimension(8,8), intent(in) | vec_in_x, | ||
| real(rp), dimension(8,8), intent(in) | vec_in_y, | ||
| real(rp), dimension(8,8), intent(in) | e11, | ||
| real(rp), dimension(8,8), intent(in) | e22, | ||
| real(rp), dimension(8,8), intent(out) | div_out_xy ) |
Definition at line 2947 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2951 implicit none
2952 real(RP), intent(in) :: Mat(8,8)
2953 real(RP), intent(in) :: Mat_tr(8,8)
2954 real(RP), intent(in) :: vec_in_x(8,8)
2955 real(RP), intent(in) :: vec_in_y(8,8)
2956 real(RP), intent(in) :: E11(8,8)
2957 real(RP), intent(in) :: E22(8,8)
2958 real(RP), intent(out) :: div_out_xy(8,8)
2959
2960 integer :: i, j, jv, jk
2961 real(RP) :: tmp1, div_x
2962 !----------------------------------------------------------
2963 !$acc routine vector
2964
2965 !$acc loop vector collapse(2)
2966 do j=1, 8
2967 do i=1, 8
2968 ! X-dir
2969 div_x = ( mat(i,1) * vec_in_x(1,j) &
2970
2971 + mat(i,2) * vec_in_x(2,j) &
2972 + mat(i,3) * vec_in_x(3,j) &
2973 + mat(i,4) * vec_in_x(4,j) &
2974 + mat(i,5) * vec_in_x(5,j) &
2975 + mat(i,6) * vec_in_x(6,j) &
2976 + mat(i,7) * vec_in_x(7,j) &
2977 + mat(i,8) * vec_in_x(8,j) ) * e11(i,j)
2978
2979 ! Y-dir
2980 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
2981 + vec_in_y(i,2) * mat_tr(2,j) &
2982 + vec_in_y(i,3) * mat_tr(3,j) &
2983 + vec_in_y(i,4) * mat_tr(4,j) &
2984 + vec_in_y(i,5) * mat_tr(5,j) &
2985 + vec_in_y(i,6) * mat_tr(6,j) &
2986 + vec_in_y(i,7) * mat_tr(7,j) &
2987 + vec_in_y(i,8) * mat_tr(8,j)
2988 div_out_xy(i,j) = div_x + tmp1 * e22(i,j)
2989 end do
2990 end do
2991 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p7()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p7 | ( | real(rp), dimension(8,8), intent(in) | mat, |
| real(rp), dimension(8,8), intent(in) | mat_tr, | ||
| real(rp), dimension(8,8,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(8,8,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(8,8), intent(in) | e11, | ||
| real(rp), dimension(8,8), intent(in) | e22, | ||
| real(rp), dimension(8,8,5), intent(out) | div_out_xy ) |
Definition at line 2994 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
2998 implicit none
2999 real(RP), intent(in) :: Mat(8,8)
3000 real(RP), intent(in) :: Mat_tr(8,8)
3001 real(RP), intent(in) :: vec_in_x(8,8,5)
3002 real(RP), intent(in) :: vec_in_y(8,8,5)
3003 real(RP), intent(in) :: E11(8,8)
3004 real(RP), intent(in) :: E22(8,8)
3005 real(RP), intent(out) :: div_out_xy(8,8,5)
3006
3007 integer :: i, j, jv, jk, v, kv
3008 real(RP) :: tmp1, div_x
3009 !----------------------------------------------------------
3010 !$acc routine vector
3011
3012 do v=1, 5
3013 !$acc loop vector collapse(2)
3014 do j=1, 8
3015 do i=1, 8
3016 ! X-dir
3017 div_x = ( mat(i,1) * vec_in_x(1,j,v) &
3018
3019 + mat(i,2) * vec_in_x(2,j,v) &
3020 + mat(i,3) * vec_in_x(3,j,v) &
3021 + mat(i,4) * vec_in_x(4,j,v) &
3022 + mat(i,5) * vec_in_x(5,j,v) &
3023 + mat(i,6) * vec_in_x(6,j,v) &
3024 + mat(i,7) * vec_in_x(7,j,v) &
3025 + mat(i,8) * vec_in_x(8,j,v) ) * e11(i,j)
3026
3027 ! Y-dir
3028 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
3029 + vec_in_y(i,2,v) * mat_tr(2,j) &
3030 + vec_in_y(i,3,v) * mat_tr(3,j) &
3031 + vec_in_y(i,4,v) * mat_tr(4,j) &
3032 + vec_in_y(i,5,v) * mat_tr(5,j) &
3033 + vec_in_y(i,6,v) * mat_tr(6,j) &
3034 + vec_in_y(i,7,v) * mat_tr(7,j) &
3035 + vec_in_y(i,8,v) * mat_tr(8,j)
3036 div_out_xy(i,j,v) = div_x + tmp1 * e22(i,j)
3037 end do
3038 end do
3039 end do
3040 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p7()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p7 | ( | real(rp), dimension(8,8), intent(in) | mat_tr, |
| real(rp), dimension(8,8,8,6), intent(in) | lift, | ||
| real(rp), dimension(8,8,5,8), intent(in) | vec_in_z, | ||
| real(rp), dimension(8,8,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(8,8,8), intent(in) | e33, | ||
| real(rp), dimension(8,8,8), intent(in) | gsqrt, | ||
| real(rp), dimension(8,8,5,8), intent(inout) | div3d ) |
Definition at line 3043 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3046 implicit none
3047 real(RP), intent(in) :: Mat_tr(8,8)
3048 real(RP), intent(in) :: Lift(8,8,8,6)
3049 real(RP), intent(in) :: vec_in_z(8,8,5,8)
3050 real(RP), intent(in) :: ebnd_flux(8,8,6,5)
3051 real(RP), intent(in) :: E33(8,8,8)
3052 real(RP), intent(in) :: Gsqrt(8,8,8)
3053 real(RP), intent(inout) :: div3D(8,8,5,8)
3054
3055 integer :: i, j, k, v
3056 real(RP) :: tmp1
3057 real(RP) :: tmp_lift
3058 real(RP) :: tmp2, tmp3
3059 real(RP) :: invG, e33_
3060 !----------------------------------------------------------
3061
3062 !$acc routine vector
3063
3064 ! Z-dir
3065 do v=1, 5
3066 do k=1, 8
3067 !$acc loop vector collapse(2)
3068 do j=1, 8
3069 do i=1, 8
3070 invg = 1.0_rp / gsqrt(i,j,k)
3071 e33_ = e33(i,j,k)
3072
3073
3074 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
3075 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
3076 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
3077 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
3078 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
3079 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
3080 tmp_lift = tmp1 + tmp2 + tmp3
3081
3082 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
3083 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
3084 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
3085 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
3086 + vec_in_z(i,j,v,5) * mat_tr(5,k) &
3087 + vec_in_z(i,j,v,6) * mat_tr(6,k) &
3088 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
3089 + vec_in_z(i,j,v,8) * mat_tr(8,k)
3090! div3D(i,j,v,k) = ( div3D(i,j,v,k) + tmp1 * E33(i,j,k) ) / Gsqrt(i,j,k)
3091 div3d(i,j,v,k) = ( div3d(i,j,v,k) + tmp1 * e33_ + tmp_lift ) * invg
3092
3093 end do
3094 end do
3095 end do
3096 end do
3097 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p7()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p7 | ( | real(rp), dimension(8,8), intent(in) | mat, |
| real(rp), dimension(8,8), intent(in) | mat_tr, | ||
| real(rp), dimension(8,8,8,6), intent(in) | lift, | ||
| real(rp), dimension(8,8,5,8,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(8,8,5,8,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(8,8,5,8,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(8,8,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | e11, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | e22, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | e33, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(8,8,5,8,ne), intent(inout) | div3d ) |
Definition at line 3100 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3104 implicit none
3105 real(RP), intent(in) :: Mat(8,8)
3106 real(RP), intent(in) :: Mat_tr(8,8)
3107 real(RP), intent(in) :: Lift(8,8,8,6)
3108 integer, intent(in) :: Ne
3109 real(RP), intent(in) :: vec_in_x(8,8,5,8,Ne)
3110 real(RP), intent(in) :: vec_in_y(8,8,5,8,Ne)
3111 real(RP), intent(in) :: vec_in_z(8,8,5,8,Ne)
3112 real(RP), intent(in) :: ebnd_flux(8,8,6,5,Ne)
3113 real(RP), intent(in) :: E11(8,8,8,Ne)
3114 real(RP), intent(in) :: E22(8,8,8,Ne)
3115 real(RP), intent(in) :: E33(8,8,8,Ne)
3116 real(RP), intent(in) :: Gsqrt(8,8,8,Ne)
3117 real(RP), intent(inout) :: div3D(8,8,5,8,Ne)
3118
3119 integer :: ke
3120 integer :: i, j, k, v
3121 real(RP) :: tmp1
3122 real(RP) :: tmp_lift
3123 real(RP) :: tmp2, tmp3
3124 real(RP) :: invG, e33_
3125 real(RP) :: div_x, div_xy
3126 !----------------------------------------------------------
3127
3128 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
3129 do ke=1, ne
3130 do k=1, 8
3131 do v=1, 5
3132 !$acc loop vector collapse(2)
3133 do j=1, 8
3134 do i=1, 8
3135 ! X-dir
3136 div_x = ( mat(i,1) * vec_in_x(1,j,v,k,ke) &
3137
3138 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
3139 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
3140 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
3141 + mat(i,5) * vec_in_x(5,j,v,k,ke) &
3142 + mat(i,6) * vec_in_x(6,j,v,k,ke) &
3143 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
3144 + mat(i,8) * vec_in_x(8,j,v,k,ke) ) * e11(i,j,k,ke)
3145
3146 ! Y-dir
3147 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
3148 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
3149 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
3150 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
3151 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
3152 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
3153 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
3154 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j)
3155 div_xy = div_x + tmp1 * e22(i,j,k,ke)
3156
3157
3158 ! Z-dir
3159
3160 invg = 1.0_rp / gsqrt(i,j,k,ke)
3161 e33_ = e33(i,j,k,ke)
3162
3163
3164 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
3165 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
3166 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
3167 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
3168 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
3169 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
3170 tmp_lift = tmp1 + tmp2 + tmp3
3171
3172 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
3173 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
3174 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
3175 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
3176 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
3177 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
3178 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
3179 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
3180
3181 div3d(i,j,v,k,ke) = ( div_xy + tmp1 * e33_ + tmp_lift ) * invg
3182
3183 end do
3184 end do
3185 end do
3186 end do
3187 end do
3188 return
◆ element_operation_kernel_matvec_divlike_var5_p7_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p7_v2 | ( | real(rp), dimension(8,8), intent(in) | mat, |
| real(rp), dimension(8,8), intent(in) | mat_tr, | ||
| real(rp), dimension(8,8,8,6), intent(in) | lift, | ||
| real(rp), dimension(8,8,5,8,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(8,8,5,8,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(8,8,5,8,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(8,8,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | e11, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | e22, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | e33, | ||
| real(rp), dimension(8,8,8,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(8,8,5,8,ne), intent(inout) | div3d ) |
Definition at line 3191 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3195 implicit none
3196 real(RP), intent(in) :: Mat(8,8)
3197 real(RP), intent(in) :: Mat_tr(8,8)
3198 real(RP), intent(in) :: Lift(8,8,8,6)
3199 integer, intent(in) :: Ne
3200 real(RP), intent(in) :: vec_in_x(8,8,5,8,Ne)
3201 real(RP), intent(in) :: vec_in_y(8,8,5,8,Ne)
3202 real(RP), intent(in) :: vec_in_z(8,8,5,8,Ne)
3203 real(RP), intent(in) :: ebnd_flux(8,8,6,5,Ne)
3204 real(RP), intent(in) :: E11(8,8,8,Ne)
3205 real(RP), intent(in) :: E22(8,8,8,Ne)
3206 real(RP), intent(in) :: E33(8,8,8,Ne)
3207 real(RP), intent(in) :: Gsqrt(8,8,8,Ne)
3208 real(RP), intent(inout) :: div3D(8,8,5,8,Ne)
3209
3210 integer :: ke
3211 integer :: p, i, j, k, v, n
3212 real(RP) :: tmp1
3213 real(RP) :: tmp_lift
3214 real(RP) :: tmp2, tmp3
3215
3216 real(RP) :: invG, e33_
3217 real(RP) :: div_x, div_xy
3218
3219 real(RP) :: tmp_vec_in_y(8)
3220
3221 real(RP) :: s1, s2, s3, s4
3222 real(RP) :: e11_
3223 !----------------------------------------------------------
3224
3225 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
3226 do ke=1, ne
3227 do k=1, 8
3228 !$acc loop vector collapse(2)
3229 do j=1, 8
3230 do i=1, 8
3231 e11_ = e11(i,j,k,ke)
3232 ! X-dir
3233 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
3234
3235 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
3236 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
3237 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
3238 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
3239 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
3240 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
3241 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) )
3242 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
3243
3244 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
3245 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
3246 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
3247 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
3248 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
3249 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
3250 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) )
3251 div3d(i,j,1,k,ke) = s1 * e11_
3252 div3d(i,j,2,k,ke) = s2 * e11_
3253
3254 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
3255
3256 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
3257 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
3258 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
3259 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
3260 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
3261 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
3262 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) )
3263 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
3264
3265 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
3266 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
3267 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
3268 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
3269 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
3270 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
3271 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) )
3272 div3d(i,j,3,k,ke) = s1 * e11_
3273 div3d(i,j,4,k,ke) = s2 * e11_
3274
3275 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
3276
3277 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
3278 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
3279 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
3280 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
3281 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
3282 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
3283 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) )
3284 div3d(i,j,5,k,ke) = s1 * e11_
3285 end do
3286 end do
3287 end do
3288 end do
3289
3290 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
3291 do ke=1, ne
3292 do k=1, 8
3293 do v=1, 5
3294 !$acc loop vector collapse(2)
3295 do j=1, 8
3296 do i=1, 8
3297
3298 ! Y-dir
3299 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
3300
3301 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
3302 + tmp_vec_in_y(2) * mat_tr(2,j) &
3303 + tmp_vec_in_y(3) * mat_tr(3,j) &
3304 + tmp_vec_in_y(4) * mat_tr(4,j) &
3305 + tmp_vec_in_y(5) * mat_tr(5,j) &
3306 + tmp_vec_in_y(6) * mat_tr(6,j) &
3307 + tmp_vec_in_y(7) * mat_tr(7,j) &
3308 + tmp_vec_in_y(8) * mat_tr(8,j)
3309! div3D(i,j,v,k,ke) = div_x + tmp1 * E22(i,j,k,ke)
3310 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + tmp1 * e22(i,j,k,ke)
3311 end do
3312 end do
3313 end do
3314 end do
3315 end do
3316
3317 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
3318 do ke=1, ne
3319 do k=1, 8
3320 do v=1, 5
3321 !$acc loop vector collapse(2)
3322 do j=1, 8
3323 do i=1, 8
3324
3325 invg = 1.0_rp / gsqrt(i,j,k,ke)
3326 e33_ = e33(i,j,k,ke)
3327
3328
3329 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
3330 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
3331 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
3332 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
3333 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
3334 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
3335 tmp_lift = tmp1 + tmp2 + tmp3
3336
3337 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
3338 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
3339 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
3340 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
3341 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
3342 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
3343 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
3344 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
3345! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invG
3346 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + tmp1 * e33_ + tmp_lift ) * invg
3347
3348 end do
3349 end do
3350 end do
3351 end do
3352 end do
3353
3354 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p7()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(8,8,8,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(8,8,8,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=7.
Definition at line 3361 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3364 implicit none
3365 integer, intent(in) :: Ne
3366 real(RP), intent(in) :: Mat_h1D(8,8)
3367 real(RP), intent(in) :: Mat_h1D_tr(8,8)
3368 real(RP), intent(in) :: Mat_v1D_tr(8,8)
3369 real(RP), intent(in) :: vec_in(8,8,8,Ne)
3370 real(RP), intent(out) :: vec_work(8,8,8,Ne)
3371 real(RP), intent(out) :: vec_out(8,8,8,Ne)
3372
3373 integer :: ke
3374 integer :: i, j, k
3375 !----------------------------------------------------------
3376
3377 ! X-dir
3378 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
3379 do ke=1, ne
3380 do k=1, 8
3381 !$acc loop vector collapse(2)
3382 do j=1, 8
3383 do i=1, 8
3384 vec_out(i,j,k,ke) = mat_h1d(i,1) * vec_in(1,j,k,ke) &
3385 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
3386 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
3387 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
3388 + mat_h1d(i,5) * vec_in(5,j,k,ke) &
3389 + mat_h1d(i,6) * vec_in(6,j,k,ke) &
3390 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
3391 + mat_h1d(i,8) * vec_in(8,j,k,ke)
3392 end do
3393 end do
3394 end do
3395 end do
3396
3397 ! Y-dir
3398 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
3399 do ke=1, ne
3400 do k=1, 8
3401 !$acc loop vector collapse(2)
3402 do j=1, 8
3403 do i=1, 8
3404 vec_work(i,j,k,ke) = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
3405 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
3406 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
3407 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
3408 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
3409 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
3410 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
3411 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j)
3412 end do
3413 end do
3414 end do
3415 end do
3416
3417 ! Z-dir
3418 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
3419 do ke=1, ne
3420 do k=1, 8
3421 !$acc loop vector collapse(2)
3422 do j=1, 8
3423 do i=1, 8
3424 vec_out(i,j,k,ke) = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
3425 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
3426 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
3427 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
3428 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
3429 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
3430 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
3431 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k)
3432 end do
3433 end do
3434 end do
3435 end do
3436 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p8()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p8 | ( | real(rp), dimension(9,9), intent(in) | mat_z_tr, |
| real(rp), dimension(9**2,9,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(9**2,9,ne_out), 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 3445 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3446 implicit none
3447 integer, intent(in) :: Ne_in
3448 integer, intent(in) :: Ne_out
3449 real(RP), intent(in) :: Mat_z_tr(9,9)
3450 real(RP), intent(in) :: vec_in(9**2,9,Ne_in)
3451 real(RP), intent(out) :: vec_out(9**2,9,Ne_out)
3452
3453 integer :: ij, k, ke
3454 !----------------------------------------------------------
3455
3456 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
3457 do ke=1, ne_out
3458 do k=1, 9
3459 do ij=1, 9**2
3460 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
3461 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
3462 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
3463 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
3464 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
3465 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
3466 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
3467 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
3468 + vec_in(ij,9,ke) * mat_z_tr(9,k)
3469 end do
3470 end do
3471 end do
3472
3473 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p8()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p8 | ( | real(rp), dimension(9,9), intent(in) | mat, |
| real(rp), dimension(9,9), intent(in) | mat_tr, | ||
| real(rp), dimension(9,9), intent(in) | vec_in_x, | ||
| real(rp), dimension(9,9), intent(in) | vec_in_y, | ||
| real(rp), dimension(9,9), intent(in) | e11, | ||
| real(rp), dimension(9,9), intent(in) | e22, | ||
| real(rp), dimension(9,9), intent(out) | div_out_xy ) |
Definition at line 3476 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3480 implicit none
3481 real(RP), intent(in) :: Mat(9,9)
3482 real(RP), intent(in) :: Mat_tr(9,9)
3483 real(RP), intent(in) :: vec_in_x(9,9)
3484 real(RP), intent(in) :: vec_in_y(9,9)
3485 real(RP), intent(in) :: E11(9,9)
3486 real(RP), intent(in) :: E22(9,9)
3487 real(RP), intent(out) :: div_out_xy(9,9)
3488
3489 integer :: i, j, jv, jk
3490 real(RP) :: tmp1, div_x
3491 real(RP) :: tmp2, tmp3
3492 !----------------------------------------------------------
3493 !$acc routine vector
3494
3495 !$acc loop vector collapse(2)
3496 do j=1, 9
3497 do i=1, 9
3498 ! X-dir
3499 tmp1 = mat(i,1) * vec_in_x(1,j) &
3500 + mat(i,2) * vec_in_x(2,j) &
3501 + mat(i,3) * vec_in_x(3,j)
3502 tmp2 = mat(i,4) * vec_in_x(4,j) &
3503 + mat(i,5) * vec_in_x(5,j) &
3504 + mat(i,6) * vec_in_x(6,j)
3505 tmp3 = mat(i,7) * vec_in_x(7,j) &
3506 + mat(i,8) * vec_in_x(8,j) &
3507 + mat(i,9) * vec_in_x(9,j)
3508 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
3509
3510 ! Y-dir
3511 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
3512 + vec_in_y(i,2) * mat_tr(2,j) &
3513 + vec_in_y(i,3) * mat_tr(3,j)
3514 tmp2 = vec_in_y(i,4) * mat_tr(4,j) &
3515 + vec_in_y(i,5) * mat_tr(5,j) &
3516 + vec_in_y(i,6) * mat_tr(6,j)
3517 tmp3 = vec_in_y(i,7) * mat_tr(7,j) &
3518 + vec_in_y(i,8) * mat_tr(8,j) &
3519 + vec_in_y(i,9) * mat_tr(9,j)
3520 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
3521 end do
3522 end do
3523 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p8()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p8 | ( | real(rp), dimension(9,9), intent(in) | mat, |
| real(rp), dimension(9,9), intent(in) | mat_tr, | ||
| real(rp), dimension(9,9,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(9,9,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(9,9), intent(in) | e11, | ||
| real(rp), dimension(9,9), intent(in) | e22, | ||
| real(rp), dimension(9,9,5), intent(out) | div_out_xy ) |
Definition at line 3526 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3530 implicit none
3531 real(RP), intent(in) :: Mat(9,9)
3532 real(RP), intent(in) :: Mat_tr(9,9)
3533 real(RP), intent(in) :: vec_in_x(9,9,5)
3534 real(RP), intent(in) :: vec_in_y(9,9,5)
3535 real(RP), intent(in) :: E11(9,9)
3536 real(RP), intent(in) :: E22(9,9)
3537 real(RP), intent(out) :: div_out_xy(9,9,5)
3538
3539 integer :: i, j, jv, jk, v, kv
3540 real(RP) :: tmp1, div_x
3541 real(RP) :: tmp2, tmp3
3542 !----------------------------------------------------------
3543 !$acc routine vector
3544
3545 do v=1, 5
3546 !$acc loop vector collapse(2)
3547 do j=1, 9
3548 do i=1, 9
3549 ! X-dir
3550 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
3551 + mat(i,2) * vec_in_x(2,j,v) &
3552 + mat(i,3) * vec_in_x(3,j,v)
3553 tmp2 = mat(i,4) * vec_in_x(4,j,v) &
3554 + mat(i,5) * vec_in_x(5,j,v) &
3555 + mat(i,6) * vec_in_x(6,j,v)
3556 tmp3 = mat(i,7) * vec_in_x(7,j,v) &
3557 + mat(i,8) * vec_in_x(8,j,v) &
3558 + mat(i,9) * vec_in_x(9,j,v)
3559 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
3560
3561 ! Y-dir
3562 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
3563 + vec_in_y(i,2,v) * mat_tr(2,j) &
3564 + vec_in_y(i,3,v) * mat_tr(3,j)
3565 tmp2 = vec_in_y(i,4,v) * mat_tr(4,j) &
3566 + vec_in_y(i,5,v) * mat_tr(5,j) &
3567 + vec_in_y(i,6,v) * mat_tr(6,j)
3568 tmp3 = vec_in_y(i,7,v) * mat_tr(7,j) &
3569 + vec_in_y(i,8,v) * mat_tr(8,j) &
3570 + vec_in_y(i,9,v) * mat_tr(9,j)
3571 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
3572 end do
3573 end do
3574 end do
3575 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p8()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p8 | ( | real(rp), dimension(9,9), intent(in) | mat_tr, |
| real(rp), dimension(9,9,9,6), intent(in) | lift, | ||
| real(rp), dimension(9,9,5,9), intent(in) | vec_in_z, | ||
| real(rp), dimension(9,9,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(9,9,9), intent(in) | e33, | ||
| real(rp), dimension(9,9,9), intent(in) | gsqrt, | ||
| real(rp), dimension(9,9,5,9), intent(inout) | div3d ) |
Definition at line 3578 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3581 implicit none
3582 real(RP), intent(in) :: Mat_tr(9,9)
3583 real(RP), intent(in) :: Lift(9,9,9,6)
3584 real(RP), intent(in) :: vec_in_z(9,9,5,9)
3585 real(RP), intent(in) :: ebnd_flux(9,9,6,5)
3586 real(RP), intent(in) :: E33(9,9,9)
3587 real(RP), intent(in) :: Gsqrt(9,9,9)
3588 real(RP), intent(inout) :: div3D(9,9,5,9)
3589
3590 integer :: i, j, k, v
3591 real(RP) :: tmp1
3592 real(RP) :: tmp_lift
3593 real(RP) :: tmp2, tmp3
3594 real(RP) :: invG, e33_
3595 !----------------------------------------------------------
3596
3597 !$acc routine vector
3598
3599 ! Z-dir
3600 do v=1, 5
3601 do k=1, 9
3602 !$acc loop vector collapse(2)
3603 do j=1, 9
3604 do i=1, 9
3605 invg = 1.0_rp / gsqrt(i,j,k)
3606 e33_ = e33(i,j,k)
3607
3608
3609 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
3610 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
3611 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
3612 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
3613 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
3614 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
3615 tmp_lift = tmp1 + tmp2 + tmp3
3616
3617 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
3618 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
3619 + vec_in_z(i,j,v,3) * mat_tr(3,k)
3620 tmp2 = vec_in_z(i,j,v,4) * mat_tr(4,k) &
3621 + vec_in_z(i,j,v,5) * mat_tr(5,k) &
3622 + vec_in_z(i,j,v,6) * mat_tr(6,k)
3623 tmp3 = vec_in_z(i,j,v,7) * mat_tr(7,k) &
3624 + vec_in_z(i,j,v,8) * mat_tr(8,k) &
3625 + vec_in_z(i,j,v,9) * mat_tr(9,k)
3626! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
3627 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
3628 end do
3629 end do
3630 end do
3631 end do
3632 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p8()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p8 | ( | real(rp), dimension(9,9), intent(in) | mat, |
| real(rp), dimension(9,9), intent(in) | mat_tr, | ||
| real(rp), dimension(9,9,9,6), intent(in) | lift, | ||
| real(rp), dimension(9,9,5,9,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(9,9,5,9,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(9,9,5,9,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(9,9,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | e11, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | e22, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | e33, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(9,9,5,9,ne), intent(inout) | div3d ) |
Definition at line 3635 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3639 implicit none
3640 real(RP), intent(in) :: Mat(9,9)
3641 real(RP), intent(in) :: Mat_tr(9,9)
3642 real(RP), intent(in) :: Lift(9,9,9,6)
3643 integer, intent(in) :: Ne
3644 real(RP), intent(in) :: vec_in_x(9,9,5,9,Ne)
3645 real(RP), intent(in) :: vec_in_y(9,9,5,9,Ne)
3646 real(RP), intent(in) :: vec_in_z(9,9,5,9,Ne)
3647 real(RP), intent(in) :: ebnd_flux(9,9,6,5,Ne)
3648 real(RP), intent(in) :: E11(9,9,9,Ne)
3649 real(RP), intent(in) :: E22(9,9,9,Ne)
3650 real(RP), intent(in) :: E33(9,9,9,Ne)
3651 real(RP), intent(in) :: Gsqrt(9,9,9,Ne)
3652 real(RP), intent(inout) :: div3D(9,9,5,9,Ne)
3653
3654 integer :: ke
3655 integer :: i, j, k, v
3656 real(RP) :: tmp1
3657 real(RP) :: tmp_lift
3658 real(RP) :: tmp2, tmp3
3659 real(RP) :: invG, e33_
3660 real(RP) :: div_x, div_xy
3661 !----------------------------------------------------------
3662
3663 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
3664 do ke=1, ne
3665 do k=1, 9
3666 do v=1, 5
3667 !$acc loop vector collapse(2)
3668 do j=1, 9
3669 do i=1, 9
3670 ! X-dir
3671 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
3672 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
3673 + mat(i,3) * vec_in_x(3,j,v,k,ke)
3674 tmp2 = mat(i,4) * vec_in_x(4,j,v,k,ke) &
3675 + mat(i,5) * vec_in_x(5,j,v,k,ke) &
3676 + mat(i,6) * vec_in_x(6,j,v,k,ke)
3677 tmp3 = mat(i,7) * vec_in_x(7,j,v,k,ke) &
3678 + mat(i,8) * vec_in_x(8,j,v,k,ke) &
3679 + mat(i,9) * vec_in_x(9,j,v,k,ke)
3680 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
3681
3682 ! Y-dir
3683 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
3684 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
3685 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j)
3686 tmp2 = vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
3687 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
3688 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j)
3689 tmp3 = vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
3690 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j) &
3691 + vec_in_y(i,9,v,k,ke) * mat_tr(9,j)
3692 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
3693
3694
3695 ! Z-dir
3696
3697 invg = 1.0_rp / gsqrt(i,j,k,ke)
3698 e33_ = e33(i,j,k,ke)
3699
3700
3701 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
3702 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
3703 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
3704 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
3705 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
3706 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
3707 tmp_lift = tmp1 + tmp2 + tmp3
3708
3709 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
3710 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
3711 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k)
3712 tmp2 = vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
3713 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
3714 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k)
3715 tmp3 = vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
3716 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
3717 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k)
3718
3719 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
3720
3721 end do
3722 end do
3723 end do
3724 end do
3725 end do
3726 return
◆ element_operation_kernel_matvec_divlike_var5_p8_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p8_v2 | ( | real(rp), dimension(9,9), intent(in) | mat, |
| real(rp), dimension(9,9), intent(in) | mat_tr, | ||
| real(rp), dimension(9,9,9,6), intent(in) | lift, | ||
| real(rp), dimension(9,9,5,9,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(9,9,5,9,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(9,9,5,9,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(9,9,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | e11, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | e22, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | e33, | ||
| real(rp), dimension(9,9,9,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(9,9,5,9,ne), intent(inout) | div3d ) |
Definition at line 3729 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3733 implicit none
3734 real(RP), intent(in) :: Mat(9,9)
3735 real(RP), intent(in) :: Mat_tr(9,9)
3736 real(RP), intent(in) :: Lift(9,9,9,6)
3737 integer, intent(in) :: Ne
3738 real(RP), intent(in) :: vec_in_x(9,9,5,9,Ne)
3739 real(RP), intent(in) :: vec_in_y(9,9,5,9,Ne)
3740 real(RP), intent(in) :: vec_in_z(9,9,5,9,Ne)
3741 real(RP), intent(in) :: ebnd_flux(9,9,6,5,Ne)
3742 real(RP), intent(in) :: E11(9,9,9,Ne)
3743 real(RP), intent(in) :: E22(9,9,9,Ne)
3744 real(RP), intent(in) :: E33(9,9,9,Ne)
3745 real(RP), intent(in) :: Gsqrt(9,9,9,Ne)
3746 real(RP), intent(inout) :: div3D(9,9,5,9,Ne)
3747
3748 integer :: ke
3749 integer :: p, i, j, k, v, n
3750 real(RP) :: tmp1
3751 real(RP) :: tmp_lift
3752 real(RP) :: tmp2, tmp3
3753
3754 real(RP) :: invG, e33_
3755 real(RP) :: div_x, div_xy
3756
3757 real(RP) :: tmp_vec_in_y(9)
3758
3759 real(RP) :: s1, s2, s3, s4
3760 real(RP) :: e11_
3761 !----------------------------------------------------------
3762
3763 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
3764 do ke=1, ne
3765 do k=1, 9
3766 !$acc loop vector collapse(2)
3767 do j=1, 9
3768 do i=1, 9
3769 e11_ = e11(i,j,k,ke)
3770 ! X-dir
3771 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
3772
3773 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
3774 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
3775 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
3776 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
3777 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
3778 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
3779 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
3780 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) )
3781 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
3782
3783 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
3784 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
3785 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
3786 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
3787 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
3788 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
3789 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
3790 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) )
3791 div3d(i,j,1,k,ke) = s1 * e11_
3792 div3d(i,j,2,k,ke) = s2 * e11_
3793
3794 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
3795
3796 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
3797 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
3798 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
3799 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
3800 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
3801 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
3802 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
3803 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) )
3804 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
3805
3806 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
3807 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
3808 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
3809 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
3810 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
3811 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
3812 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
3813 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) )
3814 div3d(i,j,3,k,ke) = s1 * e11_
3815 div3d(i,j,4,k,ke) = s2 * e11_
3816
3817 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
3818
3819 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
3820 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
3821 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
3822 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
3823 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
3824 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
3825 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
3826 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) )
3827 div3d(i,j,5,k,ke) = s1 * e11_
3828 end do
3829 end do
3830 end do
3831 end do
3832
3833 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
3834 do ke=1, ne
3835 do k=1, 9
3836 do v=1, 5
3837 !$acc loop vector collapse(2)
3838 do j=1, 9
3839 do i=1, 9
3840
3841 ! Y-dir
3842 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
3843
3844 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
3845 + tmp_vec_in_y(2) * mat_tr(2,j) &
3846 + tmp_vec_in_y(6) * mat_tr(6,j)
3847 tmp3 = tmp_vec_in_y(7) * mat_tr(7,j) &
3848 + tmp_vec_in_y(8) * mat_tr(8,j) &
3849 + tmp_vec_in_y(9) * mat_tr(9,j)
3850 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
3851 end do
3852 end do
3853 end do
3854 end do
3855 end do
3856
3857 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
3858 do ke=1, ne
3859 do k=1, 9
3860 do v=1, 5
3861 !$acc loop vector collapse(2)
3862 do j=1, 9
3863 do i=1, 9
3864
3865 invg = 1.0_rp / gsqrt(i,j,k,ke)
3866 e33_ = e33(i,j,k,ke)
3867
3868
3869 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
3870 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
3871 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
3872 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
3873 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
3874 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
3875 tmp_lift = tmp1 + tmp2 + tmp3
3876
3877 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
3878 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
3879 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k)
3880 tmp2 = vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
3881 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
3882 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k)
3883 tmp3 = vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
3884 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
3885 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k)
3886! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
3887 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
3888
3889 end do
3890 end do
3891 end do
3892 end do
3893 end do
3894
3895 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p8()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(9,9,9,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(9,9,9,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=8.
Definition at line 3902 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3905 implicit none
3906 integer, intent(in) :: Ne
3907 real(RP), intent(in) :: Mat_h1D(9,9)
3908 real(RP), intent(in) :: Mat_h1D_tr(9,9)
3909 real(RP), intent(in) :: Mat_v1D_tr(9,9)
3910 real(RP), intent(in) :: vec_in(9,9,9,Ne)
3911 real(RP), intent(out) :: vec_work(9,9,9,Ne)
3912 real(RP), intent(out) :: vec_out(9,9,9,Ne)
3913
3914 integer :: ke
3915 integer :: i, j, k
3916 real(RP) :: tmp1, tmp2, tmp3
3917 !----------------------------------------------------------
3918
3919 ! X-dir
3920 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
3921 do ke=1, ne
3922 do k=1, 9
3923 !$acc loop vector collapse(2)
3924 do j=1, 9
3925 do i=1, 9
3926 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
3927 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
3928 + mat_h1d(i,3) * vec_in(3,j,k,ke)
3929 tmp2 = mat_h1d(i,4) * vec_in(4,j,k,ke) &
3930 + mat_h1d(i,5) * vec_in(5,j,k,ke) &
3931 + mat_h1d(i,6) * vec_in(6,j,k,ke)
3932 tmp3 = mat_h1d(i,7) * vec_in(7,j,k,ke) &
3933 + mat_h1d(i,8) * vec_in(8,j,k,ke) &
3934 + mat_h1d(i,9) * vec_in(9,j,k,ke)
3935 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
3936 end do
3937 end do
3938 end do
3939 end do
3940
3941 ! Y-dir
3942 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
3943 do ke=1, ne
3944 do k=1, 9
3945 !$acc loop vector collapse(2)
3946 do j=1, 9
3947 do i=1, 9
3948 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
3949 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
3950 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j)
3951 tmp2 = vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
3952 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
3953 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j)
3954 tmp3 = vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
3955 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j) &
3956 + vec_out(i,9,k,ke) * mat_h1d_tr(9,j)
3957 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
3958 end do
3959 end do
3960 end do
3961 end do
3962
3963 ! Z-dir
3964 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
3965 do ke=1, ne
3966 do k=1, 9
3967 !$acc loop vector collapse(2)
3968 do j=1, 9
3969 do i=1, 9
3970 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
3971 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
3972 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k)
3973 tmp2 = vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
3974 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
3975 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k)
3976 tmp3 = vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
3977 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k) &
3978 + vec_work(i,j,9,ke) * mat_v1d_tr(9,k)
3979 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
3980 end do
3981 end do
3982 end do
3983 end do
3984 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p9()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p9 | ( | real(rp), dimension(10,10), intent(in) | mat_z_tr, |
| real(rp), dimension(10**2,10,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(10**2,10,ne_out), 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 3993 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
3994 implicit none
3995 integer, intent(in) :: Ne_in
3996 integer, intent(in) :: Ne_out
3997 real(RP), intent(in) :: Mat_z_tr(10,10)
3998 real(RP), intent(in) :: vec_in(10**2,10,Ne_in)
3999 real(RP), intent(out) :: vec_out(10**2,10,Ne_out)
4000
4001 integer :: ij, k, ke
4002 !----------------------------------------------------------
4003
4004 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
4005 do ke=1, ne_out
4006 do k=1, 10
4007 do ij=1, 10**2
4008 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
4009 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
4010 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
4011 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
4012 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
4013 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
4014 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
4015 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
4016 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
4017 + vec_in(ij,10,ke) * mat_z_tr(10,k)
4018 end do
4019 end do
4020 end do
4021
4022 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p9()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p9 | ( | real(rp), dimension(10,10), intent(in) | mat, |
| real(rp), dimension(10,10), intent(in) | mat_tr, | ||
| real(rp), dimension(10,10), intent(in) | vec_in_x, | ||
| real(rp), dimension(10,10), intent(in) | vec_in_y, | ||
| real(rp), dimension(10,10), intent(in) | e11, | ||
| real(rp), dimension(10,10), intent(in) | e22, | ||
| real(rp), dimension(10,10), intent(out) | div_out_xy ) |
Definition at line 4025 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4029 implicit none
4030 real(RP), intent(in) :: Mat(10,10)
4031 real(RP), intent(in) :: Mat_tr(10,10)
4032 real(RP), intent(in) :: vec_in_x(10,10)
4033 real(RP), intent(in) :: vec_in_y(10,10)
4034 real(RP), intent(in) :: E11(10,10)
4035 real(RP), intent(in) :: E22(10,10)
4036 real(RP), intent(out) :: div_out_xy(10,10)
4037
4038 integer :: i, j, jv, jk
4039 real(RP) :: tmp1, div_x
4040 real(RP) :: tmp2, tmp3
4041 !----------------------------------------------------------
4042 !$acc routine vector
4043
4044 !$acc loop vector collapse(2)
4045 do j=1, 10
4046 do i=1, 10
4047 ! X-dir
4048 tmp1 = mat(i,1) * vec_in_x(1,j) &
4049 + mat(i,2) * vec_in_x(2,j) &
4050 + mat(i,3) * vec_in_x(3,j)
4051 tmp2 = mat(i,4) * vec_in_x(4,j) &
4052 + mat(i,5) * vec_in_x(5,j) &
4053 + mat(i,6) * vec_in_x(6,j)
4054 tmp3 = mat(i,7) * vec_in_x(7,j) &
4055 + mat(i,8) * vec_in_x(8,j) &
4056 + mat(i,9) * vec_in_x(9,j) &
4057 + mat(i,10) * vec_in_x(10,j)
4058 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
4059
4060 ! Y-dir
4061 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
4062 + vec_in_y(i,2) * mat_tr(2,j) &
4063 + vec_in_y(i,3) * mat_tr(3,j)
4064 tmp2 = vec_in_y(i,4) * mat_tr(4,j) &
4065 + vec_in_y(i,5) * mat_tr(5,j) &
4066 + vec_in_y(i,6) * mat_tr(6,j)
4067 tmp3 = vec_in_y(i,7) * mat_tr(7,j) &
4068 + vec_in_y(i,8) * mat_tr(8,j) &
4069 + vec_in_y(i,9) * mat_tr(9,j) &
4070 + vec_in_y(i,10) * mat_tr(10,j)
4071 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
4072 end do
4073 end do
4074 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p9()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p9 | ( | real(rp), dimension(10,10), intent(in) | mat, |
| real(rp), dimension(10,10), intent(in) | mat_tr, | ||
| real(rp), dimension(10,10,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(10,10,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(10,10), intent(in) | e11, | ||
| real(rp), dimension(10,10), intent(in) | e22, | ||
| real(rp), dimension(10,10,5), intent(out) | div_out_xy ) |
Definition at line 4077 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4081 implicit none
4082 real(RP), intent(in) :: Mat(10,10)
4083 real(RP), intent(in) :: Mat_tr(10,10)
4084 real(RP), intent(in) :: vec_in_x(10,10,5)
4085 real(RP), intent(in) :: vec_in_y(10,10,5)
4086 real(RP), intent(in) :: E11(10,10)
4087 real(RP), intent(in) :: E22(10,10)
4088 real(RP), intent(out) :: div_out_xy(10,10,5)
4089
4090 integer :: i, j, jv, jk, v, kv
4091 real(RP) :: tmp1, div_x
4092 real(RP) :: tmp2, tmp3
4093 !----------------------------------------------------------
4094 !$acc routine vector
4095
4096 do v=1, 5
4097 !$acc loop vector collapse(2)
4098 do j=1, 10
4099 do i=1, 10
4100 ! X-dir
4101 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
4102 + mat(i,2) * vec_in_x(2,j,v) &
4103 + mat(i,3) * vec_in_x(3,j,v)
4104 tmp2 = mat(i,4) * vec_in_x(4,j,v) &
4105 + mat(i,5) * vec_in_x(5,j,v) &
4106 + mat(i,6) * vec_in_x(6,j,v)
4107 tmp3 = mat(i,7) * vec_in_x(7,j,v) &
4108 + mat(i,8) * vec_in_x(8,j,v) &
4109 + mat(i,9) * vec_in_x(9,j,v) &
4110 + mat(i,10) * vec_in_x(10,j,v)
4111 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
4112
4113 ! Y-dir
4114 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
4115 + vec_in_y(i,2,v) * mat_tr(2,j) &
4116 + vec_in_y(i,3,v) * mat_tr(3,j)
4117 tmp2 = vec_in_y(i,4,v) * mat_tr(4,j) &
4118 + vec_in_y(i,5,v) * mat_tr(5,j) &
4119 + vec_in_y(i,6,v) * mat_tr(6,j)
4120 tmp3 = vec_in_y(i,7,v) * mat_tr(7,j) &
4121 + vec_in_y(i,8,v) * mat_tr(8,j) &
4122 + vec_in_y(i,9,v) * mat_tr(9,j) &
4123 + vec_in_y(i,10,v) * mat_tr(10,j)
4124 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
4125 end do
4126 end do
4127 end do
4128 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p9()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p9 | ( | real(rp), dimension(10,10), intent(in) | mat_tr, |
| real(rp), dimension(10,10,10,6), intent(in) | lift, | ||
| real(rp), dimension(10,10,5,10), intent(in) | vec_in_z, | ||
| real(rp), dimension(10,10,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(10,10,10), intent(in) | e33, | ||
| real(rp), dimension(10,10,10), intent(in) | gsqrt, | ||
| real(rp), dimension(10,10,5,10), intent(inout) | div3d ) |
Definition at line 4131 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4134 implicit none
4135 real(RP), intent(in) :: Mat_tr(10,10)
4136 real(RP), intent(in) :: Lift(10,10,10,6)
4137 real(RP), intent(in) :: vec_in_z(10,10,5,10)
4138 real(RP), intent(in) :: ebnd_flux(10,10,6,5)
4139 real(RP), intent(in) :: E33(10,10,10)
4140 real(RP), intent(in) :: Gsqrt(10,10,10)
4141 real(RP), intent(inout) :: div3D(10,10,5,10)
4142
4143 integer :: i, j, k, v
4144 real(RP) :: tmp1
4145 real(RP) :: tmp_lift
4146 real(RP) :: tmp2, tmp3
4147 real(RP) :: invG, e33_
4148 !----------------------------------------------------------
4149
4150 !$acc routine vector
4151
4152 ! Z-dir
4153 do v=1, 5
4154 do k=1, 10
4155 !$acc loop vector collapse(2)
4156 do j=1, 10
4157 do i=1, 10
4158 invg = 1.0_rp / gsqrt(i,j,k)
4159 e33_ = e33(i,j,k)
4160
4161
4162 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
4163 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
4164 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
4165 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
4166 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
4167 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
4168 tmp_lift = tmp1 + tmp2 + tmp3
4169
4170 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
4171 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
4172 + vec_in_z(i,j,v,3) * mat_tr(3,k)
4173 tmp2 = vec_in_z(i,j,v,4) * mat_tr(4,k) &
4174 + vec_in_z(i,j,v,5) * mat_tr(5,k) &
4175 + vec_in_z(i,j,v,6) * mat_tr(6,k)
4176 tmp3 = vec_in_z(i,j,v,7) * mat_tr(7,k) &
4177 + vec_in_z(i,j,v,8) * mat_tr(8,k) &
4178 + vec_in_z(i,j,v,9) * mat_tr(9,k) &
4179 + vec_in_z(i,j,v,10) * mat_tr(10,k)
4180! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
4181 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
4182 end do
4183 end do
4184 end do
4185 end do
4186 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p9()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p9 | ( | real(rp), dimension(10,10), intent(in) | mat, |
| real(rp), dimension(10,10), intent(in) | mat_tr, | ||
| real(rp), dimension(10,10,10,6), intent(in) | lift, | ||
| real(rp), dimension(10,10,5,10,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(10,10,5,10,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(10,10,5,10,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(10,10,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | e11, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | e22, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | e33, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(10,10,5,10,ne), intent(inout) | div3d ) |
Definition at line 4189 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4193 implicit none
4194 real(RP), intent(in) :: Mat(10,10)
4195 real(RP), intent(in) :: Mat_tr(10,10)
4196 real(RP), intent(in) :: Lift(10,10,10,6)
4197 integer, intent(in) :: Ne
4198 real(RP), intent(in) :: vec_in_x(10,10,5,10,Ne)
4199 real(RP), intent(in) :: vec_in_y(10,10,5,10,Ne)
4200 real(RP), intent(in) :: vec_in_z(10,10,5,10,Ne)
4201 real(RP), intent(in) :: ebnd_flux(10,10,6,5,Ne)
4202 real(RP), intent(in) :: E11(10,10,10,Ne)
4203 real(RP), intent(in) :: E22(10,10,10,Ne)
4204 real(RP), intent(in) :: E33(10,10,10,Ne)
4205 real(RP), intent(in) :: Gsqrt(10,10,10,Ne)
4206 real(RP), intent(inout) :: div3D(10,10,5,10,Ne)
4207
4208 integer :: ke
4209 integer :: i, j, k, v
4210 real(RP) :: tmp1
4211 real(RP) :: tmp_lift
4212 real(RP) :: tmp2, tmp3
4213 real(RP) :: invG, e33_
4214 real(RP) :: div_x, div_xy
4215 !----------------------------------------------------------
4216
4217 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
4218 do ke=1, ne
4219 do k=1, 10
4220 do v=1, 5
4221 !$acc loop vector collapse(2)
4222 do j=1, 10
4223 do i=1, 10
4224 ! X-dir
4225 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
4226 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
4227 + mat(i,3) * vec_in_x(3,j,v,k,ke)
4228 tmp2 = mat(i,4) * vec_in_x(4,j,v,k,ke) &
4229 + mat(i,5) * vec_in_x(5,j,v,k,ke) &
4230 + mat(i,6) * vec_in_x(6,j,v,k,ke)
4231 tmp3 = mat(i,7) * vec_in_x(7,j,v,k,ke) &
4232 + mat(i,8) * vec_in_x(8,j,v,k,ke) &
4233 + mat(i,9) * vec_in_x(9,j,v,k,ke) &
4234 + mat(i,10) * vec_in_x(10,j,v,k,ke)
4235 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
4236
4237 ! Y-dir
4238 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
4239 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
4240 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j)
4241 tmp2 = vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
4242 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
4243 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j)
4244 tmp3 = vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
4245 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j) &
4246 + vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
4247 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j)
4248 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
4249
4250
4251 ! Z-dir
4252
4253 invg = 1.0_rp / gsqrt(i,j,k,ke)
4254 e33_ = e33(i,j,k,ke)
4255
4256
4257 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
4258 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
4259 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
4260 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
4261 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
4262 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
4263 tmp_lift = tmp1 + tmp2 + tmp3
4264
4265 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
4266 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
4267 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k)
4268 tmp2 = vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
4269 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
4270 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k)
4271 tmp3 = vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
4272 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
4273 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
4274 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
4275
4276 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
4277
4278 end do
4279 end do
4280 end do
4281 end do
4282 end do
4283 return
◆ element_operation_kernel_matvec_divlike_var5_p9_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p9_v2 | ( | real(rp), dimension(10,10), intent(in) | mat, |
| real(rp), dimension(10,10), intent(in) | mat_tr, | ||
| real(rp), dimension(10,10,10,6), intent(in) | lift, | ||
| real(rp), dimension(10,10,5,10,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(10,10,5,10,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(10,10,5,10,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(10,10,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | e11, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | e22, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | e33, | ||
| real(rp), dimension(10,10,10,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(10,10,5,10,ne), intent(inout) | div3d ) |
Definition at line 4286 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4290 implicit none
4291 real(RP), intent(in) :: Mat(10,10)
4292 real(RP), intent(in) :: Mat_tr(10,10)
4293 real(RP), intent(in) :: Lift(10,10,10,6)
4294 integer, intent(in) :: Ne
4295 real(RP), intent(in) :: vec_in_x(10,10,5,10,Ne)
4296 real(RP), intent(in) :: vec_in_y(10,10,5,10,Ne)
4297 real(RP), intent(in) :: vec_in_z(10,10,5,10,Ne)
4298 real(RP), intent(in) :: ebnd_flux(10,10,6,5,Ne)
4299 real(RP), intent(in) :: E11(10,10,10,Ne)
4300 real(RP), intent(in) :: E22(10,10,10,Ne)
4301 real(RP), intent(in) :: E33(10,10,10,Ne)
4302 real(RP), intent(in) :: Gsqrt(10,10,10,Ne)
4303 real(RP), intent(inout) :: div3D(10,10,5,10,Ne)
4304
4305 integer :: ke
4306 integer :: p, i, j, k, v, n
4307 real(RP) :: tmp1
4308 real(RP) :: tmp_lift
4309 real(RP) :: tmp2, tmp3
4310
4311 real(RP) :: invG, e33_
4312 real(RP) :: div_x, div_xy
4313
4314 real(RP) :: tmp_vec_in_y(10)
4315
4316 real(RP) :: s1, s2, s3, s4
4317 real(RP) :: e11_
4318 !----------------------------------------------------------
4319
4320 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
4321 do ke=1, ne
4322 do k=1, 10
4323 !$acc loop vector collapse(2)
4324 do j=1, 10
4325 do i=1, 10
4326 e11_ = e11(i,j,k,ke)
4327 ! X-dir
4328 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
4329
4330 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
4331 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
4332 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
4333 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
4334 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
4335 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
4336 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
4337 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
4338 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) )
4339 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
4340
4341 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
4342 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
4343 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
4344 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
4345 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
4346 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
4347 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
4348 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
4349 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) )
4350 div3d(i,j,1,k,ke) = s1 * e11_
4351 div3d(i,j,2,k,ke) = s2 * e11_
4352
4353 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
4354
4355 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
4356 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
4357 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
4358 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
4359 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
4360 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
4361 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
4362 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
4363 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) )
4364 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
4365
4366 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
4367 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
4368 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
4369 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
4370 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
4371 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
4372 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
4373 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
4374 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) )
4375 div3d(i,j,3,k,ke) = s1 * e11_
4376 div3d(i,j,4,k,ke) = s2 * e11_
4377
4378 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
4379
4380 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
4381 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
4382 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
4383 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
4384 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
4385 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
4386 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
4387 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
4388 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) )
4389 div3d(i,j,5,k,ke) = s1 * e11_
4390 end do
4391 end do
4392 end do
4393 end do
4394
4395 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
4396 do ke=1, ne
4397 do k=1, 10
4398 do v=1, 5
4399 !$acc loop vector collapse(2)
4400 do j=1, 10
4401 do i=1, 10
4402
4403 ! Y-dir
4404 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
4405
4406 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
4407 + tmp_vec_in_y(2) * mat_tr(2,j) &
4408 + tmp_vec_in_y(6) * mat_tr(6,j)
4409 tmp3 = tmp_vec_in_y(7) * mat_tr(7,j) &
4410 + tmp_vec_in_y(8) * mat_tr(8,j) &
4411 + tmp_vec_in_y(9) * mat_tr(9,j) &
4412 + tmp_vec_in_y(10) * mat_tr(10,j)
4413 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
4414 end do
4415 end do
4416 end do
4417 end do
4418 end do
4419
4420 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
4421 do ke=1, ne
4422 do k=1, 10
4423 do v=1, 5
4424 !$acc loop vector collapse(2)
4425 do j=1, 10
4426 do i=1, 10
4427
4428 invg = 1.0_rp / gsqrt(i,j,k,ke)
4429 e33_ = e33(i,j,k,ke)
4430
4431
4432 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
4433 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
4434 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
4435 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
4436 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
4437 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
4438 tmp_lift = tmp1 + tmp2 + tmp3
4439
4440 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
4441 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
4442 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k)
4443 tmp2 = vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
4444 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
4445 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k)
4446 tmp3 = vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
4447 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
4448 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
4449 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
4450! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
4451 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
4452
4453 end do
4454 end do
4455 end do
4456 end do
4457 end do
4458
4459 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p9()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(10,10,10,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(10,10,10,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=9.
Definition at line 4466 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4469 implicit none
4470 integer, intent(in) :: Ne
4471 real(RP), intent(in) :: Mat_h1D(10,10)
4472 real(RP), intent(in) :: Mat_h1D_tr(10,10)
4473 real(RP), intent(in) :: Mat_v1D_tr(10,10)
4474 real(RP), intent(in) :: vec_in(10,10,10,Ne)
4475 real(RP), intent(out) :: vec_work(10,10,10,Ne)
4476 real(RP), intent(out) :: vec_out(10,10,10,Ne)
4477
4478 integer :: ke
4479 integer :: i, j, k
4480 real(RP) :: tmp1, tmp2, tmp3
4481 !----------------------------------------------------------
4482
4483 ! X-dir
4484 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
4485 do ke=1, ne
4486 do k=1, 10
4487 !$acc loop vector collapse(2)
4488 do j=1, 10
4489 do i=1, 10
4490 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
4491 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
4492 + mat_h1d(i,3) * vec_in(3,j,k,ke)
4493 tmp2 = mat_h1d(i,4) * vec_in(4,j,k,ke) &
4494 + mat_h1d(i,5) * vec_in(5,j,k,ke) &
4495 + mat_h1d(i,6) * vec_in(6,j,k,ke)
4496 tmp3 = mat_h1d(i,7) * vec_in(7,j,k,ke) &
4497 + mat_h1d(i,8) * vec_in(8,j,k,ke) &
4498 + mat_h1d(i,9) * vec_in(9,j,k,ke) &
4499 + mat_h1d(i,10) * vec_in(10,j,k,ke)
4500 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
4501 end do
4502 end do
4503 end do
4504 end do
4505
4506 ! Y-dir
4507 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
4508 do ke=1, ne
4509 do k=1, 10
4510 !$acc loop vector collapse(2)
4511 do j=1, 10
4512 do i=1, 10
4513 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
4514 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
4515 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j)
4516 tmp2 = vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
4517 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
4518 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j)
4519 tmp3 = vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
4520 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j) &
4521 + vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
4522 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j)
4523 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
4524 end do
4525 end do
4526 end do
4527 end do
4528
4529 ! Z-dir
4530 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
4531 do ke=1, ne
4532 do k=1, 10
4533 !$acc loop vector collapse(2)
4534 do j=1, 10
4535 do i=1, 10
4536 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
4537 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
4538 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k)
4539 tmp2 = vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
4540 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
4541 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k)
4542 tmp3 = vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
4543 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k) &
4544 + vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
4545 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k)
4546 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
4547 end do
4548 end do
4549 end do
4550 end do
4551 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p10()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p10 | ( | real(rp), dimension(11,11), intent(in) | mat_z_tr, |
| real(rp), dimension(11**2,11,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(11**2,11,ne_out), 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 4560 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4561 implicit none
4562 integer, intent(in) :: Ne_in
4563 integer, intent(in) :: Ne_out
4564 real(RP), intent(in) :: Mat_z_tr(11,11)
4565 real(RP), intent(in) :: vec_in(11**2,11,Ne_in)
4566 real(RP), intent(out) :: vec_out(11**2,11,Ne_out)
4567
4568 integer :: ij, k, ke
4569 !----------------------------------------------------------
4570
4571 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
4572 do ke=1, ne_out
4573 do k=1, 11
4574 do ij=1, 11**2
4575 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
4576 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
4577 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
4578 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
4579 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
4580 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
4581 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
4582 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
4583 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
4584 + vec_in(ij,10,ke) * mat_z_tr(10,k) &
4585 + vec_in(ij,11,ke) * mat_z_tr(11,k)
4586 end do
4587 end do
4588 end do
4589
4590 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p10()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p10 | ( | real(rp), dimension(11,11), intent(in) | mat, |
| real(rp), dimension(11,11), intent(in) | mat_tr, | ||
| real(rp), dimension(11,11), intent(in) | vec_in_x, | ||
| real(rp), dimension(11,11), intent(in) | vec_in_y, | ||
| real(rp), dimension(11,11), intent(in) | e11, | ||
| real(rp), dimension(11,11), intent(in) | e22, | ||
| real(rp), dimension(11,11), intent(out) | div_out_xy ) |
Definition at line 4593 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4597 implicit none
4598 real(RP), intent(in) :: Mat(11,11)
4599 real(RP), intent(in) :: Mat_tr(11,11)
4600 real(RP), intent(in) :: vec_in_x(11,11)
4601 real(RP), intent(in) :: vec_in_y(11,11)
4602 real(RP), intent(in) :: E11(11,11)
4603 real(RP), intent(in) :: E22(11,11)
4604 real(RP), intent(out) :: div_out_xy(11,11)
4605
4606 integer :: i, j, jv, jk
4607 real(RP) :: tmp1, div_x
4608 real(RP) :: tmp2, tmp3
4609 !----------------------------------------------------------
4610 !$acc routine vector
4611
4612 !$acc loop vector collapse(2)
4613 do j=1, 11
4614 do i=1, 11
4615 ! X-dir
4616 tmp1 = mat(i,1) * vec_in_x(1,j) &
4617 + mat(i,2) * vec_in_x(2,j) &
4618 + mat(i,3) * vec_in_x(3,j) &
4619 + mat(i,4) * vec_in_x(4,j)
4620 tmp2 = mat(i,5) * vec_in_x(5,j) &
4621 + mat(i,6) * vec_in_x(6,j) &
4622 + mat(i,7) * vec_in_x(7,j) &
4623 + mat(i,8) * vec_in_x(8,j)
4624 tmp3 = mat(i,9) * vec_in_x(9,j) &
4625 + mat(i,10) * vec_in_x(10,j) &
4626 + mat(i,11) * vec_in_x(11,j)
4627 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
4628
4629 ! Y-dir
4630 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
4631 + vec_in_y(i,2) * mat_tr(2,j) &
4632 + vec_in_y(i,3) * mat_tr(3,j) &
4633 + vec_in_y(i,4) * mat_tr(4,j)
4634 tmp2 = vec_in_y(i,5) * mat_tr(5,j) &
4635 + vec_in_y(i,6) * mat_tr(6,j) &
4636 + vec_in_y(i,7) * mat_tr(7,j) &
4637 + vec_in_y(i,8) * mat_tr(8,j)
4638 tmp3 = vec_in_y(i,9) * mat_tr(9,j) &
4639 + vec_in_y(i,10) * mat_tr(10,j) &
4640 + vec_in_y(i,11) * mat_tr(11,j)
4641 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
4642 end do
4643 end do
4644 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p10()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p10 | ( | real(rp), dimension(11,11), intent(in) | mat, |
| real(rp), dimension(11,11), intent(in) | mat_tr, | ||
| real(rp), dimension(11,11,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(11,11,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(11,11), intent(in) | e11, | ||
| real(rp), dimension(11,11), intent(in) | e22, | ||
| real(rp), dimension(11,11,5), intent(out) | div_out_xy ) |
Definition at line 4647 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4651 implicit none
4652 real(RP), intent(in) :: Mat(11,11)
4653 real(RP), intent(in) :: Mat_tr(11,11)
4654 real(RP), intent(in) :: vec_in_x(11,11,5)
4655 real(RP), intent(in) :: vec_in_y(11,11,5)
4656 real(RP), intent(in) :: E11(11,11)
4657 real(RP), intent(in) :: E22(11,11)
4658 real(RP), intent(out) :: div_out_xy(11,11,5)
4659
4660 integer :: i, j, jv, jk, v, kv
4661 real(RP) :: tmp1, div_x
4662 real(RP) :: tmp2, tmp3
4663 !----------------------------------------------------------
4664 !$acc routine vector
4665
4666 do v=1, 5
4667 !$acc loop vector collapse(2)
4668 do j=1, 11
4669 do i=1, 11
4670 ! X-dir
4671 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
4672 + mat(i,2) * vec_in_x(2,j,v) &
4673 + mat(i,3) * vec_in_x(3,j,v) &
4674 + mat(i,4) * vec_in_x(4,j,v)
4675 tmp2 = mat(i,5) * vec_in_x(5,j,v) &
4676 + mat(i,6) * vec_in_x(6,j,v) &
4677 + mat(i,7) * vec_in_x(7,j,v) &
4678 + mat(i,8) * vec_in_x(8,j,v)
4679 tmp3 = mat(i,9) * vec_in_x(9,j,v) &
4680 + mat(i,10) * vec_in_x(10,j,v) &
4681 + mat(i,11) * vec_in_x(11,j,v)
4682 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
4683
4684 ! Y-dir
4685 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
4686 + vec_in_y(i,2,v) * mat_tr(2,j) &
4687 + vec_in_y(i,3,v) * mat_tr(3,j) &
4688 + vec_in_y(i,4,v) * mat_tr(4,j)
4689 tmp2 = vec_in_y(i,5,v) * mat_tr(5,j) &
4690 + vec_in_y(i,6,v) * mat_tr(6,j) &
4691 + vec_in_y(i,7,v) * mat_tr(7,j) &
4692 + vec_in_y(i,8,v) * mat_tr(8,j)
4693 tmp3 = vec_in_y(i,9,v) * mat_tr(9,j) &
4694 + vec_in_y(i,10,v) * mat_tr(10,j) &
4695 + vec_in_y(i,11,v) * mat_tr(11,j)
4696 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
4697 end do
4698 end do
4699 end do
4700 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p10()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p10 | ( | real(rp), dimension(11,11), intent(in) | mat_tr, |
| real(rp), dimension(11,11,11,6), intent(in) | lift, | ||
| real(rp), dimension(11,11,5,11), intent(in) | vec_in_z, | ||
| real(rp), dimension(11,11,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(11,11,11), intent(in) | e33, | ||
| real(rp), dimension(11,11,11), intent(in) | gsqrt, | ||
| real(rp), dimension(11,11,5,11), intent(inout) | div3d ) |
Definition at line 4703 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4706 implicit none
4707 real(RP), intent(in) :: Mat_tr(11,11)
4708 real(RP), intent(in) :: Lift(11,11,11,6)
4709 real(RP), intent(in) :: vec_in_z(11,11,5,11)
4710 real(RP), intent(in) :: ebnd_flux(11,11,6,5)
4711 real(RP), intent(in) :: E33(11,11,11)
4712 real(RP), intent(in) :: Gsqrt(11,11,11)
4713 real(RP), intent(inout) :: div3D(11,11,5,11)
4714
4715 integer :: i, j, k, v
4716 real(RP) :: tmp1
4717 real(RP) :: tmp_lift
4718 real(RP) :: tmp2, tmp3
4719 real(RP) :: invG, e33_
4720 !----------------------------------------------------------
4721
4722 !$acc routine vector
4723
4724 ! Z-dir
4725 do v=1, 5
4726 do k=1, 11
4727 !$acc loop vector collapse(2)
4728 do j=1, 11
4729 do i=1, 11
4730 invg = 1.0_rp / gsqrt(i,j,k)
4731 e33_ = e33(i,j,k)
4732
4733
4734 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
4735 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
4736 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
4737 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
4738 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
4739 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
4740 tmp_lift = tmp1 + tmp2 + tmp3
4741
4742 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
4743 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
4744 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
4745 + vec_in_z(i,j,v,4) * mat_tr(4,k)
4746 tmp2 = vec_in_z(i,j,v,5) * mat_tr(5,k) &
4747 + vec_in_z(i,j,v,6) * mat_tr(6,k) &
4748 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
4749 + vec_in_z(i,j,v,8) * mat_tr(8,k)
4750 tmp3 = vec_in_z(i,j,v,9) * mat_tr(9,k) &
4751 + vec_in_z(i,j,v,10) * mat_tr(10,k) &
4752 + vec_in_z(i,j,v,11) * mat_tr(11,k)
4753! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
4754 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
4755 end do
4756 end do
4757 end do
4758 end do
4759 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p10()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p10 | ( | real(rp), dimension(11,11), intent(in) | mat, |
| real(rp), dimension(11,11), intent(in) | mat_tr, | ||
| real(rp), dimension(11,11,11,6), intent(in) | lift, | ||
| real(rp), dimension(11,11,5,11,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(11,11,5,11,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(11,11,5,11,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(11,11,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | e11, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | e22, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | e33, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(11,11,5,11,ne), intent(inout) | div3d ) |
Definition at line 4762 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4766 implicit none
4767 real(RP), intent(in) :: Mat(11,11)
4768 real(RP), intent(in) :: Mat_tr(11,11)
4769 real(RP), intent(in) :: Lift(11,11,11,6)
4770 integer, intent(in) :: Ne
4771 real(RP), intent(in) :: vec_in_x(11,11,5,11,Ne)
4772 real(RP), intent(in) :: vec_in_y(11,11,5,11,Ne)
4773 real(RP), intent(in) :: vec_in_z(11,11,5,11,Ne)
4774 real(RP), intent(in) :: ebnd_flux(11,11,6,5,Ne)
4775 real(RP), intent(in) :: E11(11,11,11,Ne)
4776 real(RP), intent(in) :: E22(11,11,11,Ne)
4777 real(RP), intent(in) :: E33(11,11,11,Ne)
4778 real(RP), intent(in) :: Gsqrt(11,11,11,Ne)
4779 real(RP), intent(inout) :: div3D(11,11,5,11,Ne)
4780
4781 integer :: ke
4782 integer :: i, j, k, v
4783 real(RP) :: tmp1
4784 real(RP) :: tmp_lift
4785 real(RP) :: tmp2, tmp3
4786 real(RP) :: invG, e33_
4787 real(RP) :: div_x, div_xy
4788 !----------------------------------------------------------
4789
4790 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
4791 do ke=1, ne
4792 do k=1, 11
4793 do v=1, 5
4794 !$acc loop vector collapse(2)
4795 do j=1, 11
4796 do i=1, 11
4797 ! X-dir
4798 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
4799 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
4800 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
4801 + mat(i,4) * vec_in_x(4,j,v,k,ke)
4802 tmp2 = mat(i,5) * vec_in_x(5,j,v,k,ke) &
4803 + mat(i,6) * vec_in_x(6,j,v,k,ke) &
4804 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
4805 + mat(i,8) * vec_in_x(8,j,v,k,ke)
4806 tmp3 = mat(i,9) * vec_in_x(9,j,v,k,ke) &
4807 + mat(i,10) * vec_in_x(10,j,v,k,ke) &
4808 + mat(i,11) * vec_in_x(11,j,v,k,ke)
4809 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
4810
4811 ! Y-dir
4812 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
4813 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
4814 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
4815 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j)
4816 tmp2 = vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
4817 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
4818 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
4819 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j)
4820 tmp3 = vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
4821 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j) &
4822 + vec_in_y(i,11,v,k,ke) * mat_tr(11,j)
4823 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
4824
4825
4826 ! Z-dir
4827
4828 invg = 1.0_rp / gsqrt(i,j,k,ke)
4829 e33_ = e33(i,j,k,ke)
4830
4831
4832 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
4833 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
4834 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
4835 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
4836 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
4837 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
4838 tmp_lift = tmp1 + tmp2 + tmp3
4839
4840 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
4841 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
4842 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
4843 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
4844 tmp2 = vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
4845 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
4846 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
4847 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
4848 tmp3 = vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
4849 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k) &
4850 + vec_in_z(i,j,v,11,ke) * mat_tr(11,k)
4851
4852 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
4853
4854 end do
4855 end do
4856 end do
4857 end do
4858 end do
4859 return
◆ element_operation_kernel_matvec_divlike_var5_p10_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p10_v2 | ( | real(rp), dimension(11,11), intent(in) | mat, |
| real(rp), dimension(11,11), intent(in) | mat_tr, | ||
| real(rp), dimension(11,11,11,6), intent(in) | lift, | ||
| real(rp), dimension(11,11,5,11,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(11,11,5,11,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(11,11,5,11,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(11,11,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | e11, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | e22, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | e33, | ||
| real(rp), dimension(11,11,11,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(11,11,5,11,ne), intent(inout) | div3d ) |
Definition at line 4862 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
4866 implicit none
4867 real(RP), intent(in) :: Mat(11,11)
4868 real(RP), intent(in) :: Mat_tr(11,11)
4869 real(RP), intent(in) :: Lift(11,11,11,6)
4870 integer, intent(in) :: Ne
4871 real(RP), intent(in) :: vec_in_x(11,11,5,11,Ne)
4872 real(RP), intent(in) :: vec_in_y(11,11,5,11,Ne)
4873 real(RP), intent(in) :: vec_in_z(11,11,5,11,Ne)
4874 real(RP), intent(in) :: ebnd_flux(11,11,6,5,Ne)
4875 real(RP), intent(in) :: E11(11,11,11,Ne)
4876 real(RP), intent(in) :: E22(11,11,11,Ne)
4877 real(RP), intent(in) :: E33(11,11,11,Ne)
4878 real(RP), intent(in) :: Gsqrt(11,11,11,Ne)
4879 real(RP), intent(inout) :: div3D(11,11,5,11,Ne)
4880
4881 integer :: ke
4882 integer :: p, i, j, k, v, n
4883 real(RP) :: tmp1
4884 real(RP) :: tmp_lift
4885 real(RP) :: tmp2, tmp3
4886
4887 real(RP) :: invG, e33_
4888 real(RP) :: div_x, div_xy
4889
4890 real(RP) :: tmp_vec_in_y(11)
4891
4892 real(RP) :: s1, s2, s3, s4
4893 real(RP) :: e11_
4894 !----------------------------------------------------------
4895
4896 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
4897 do ke=1, ne
4898 do k=1, 11
4899 !$acc loop vector collapse(2)
4900 do j=1, 11
4901 do i=1, 11
4902 e11_ = e11(i,j,k,ke)
4903 ! X-dir
4904 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
4905
4906 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
4907 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
4908 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
4909 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
4910 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
4911 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
4912 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
4913 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
4914 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) &
4915 + mat_tr(11,i) * vec_in_x(11,j,1,k,ke) )
4916 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
4917
4918 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
4919 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
4920 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
4921 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
4922 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
4923 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
4924 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
4925 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
4926 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) &
4927 + mat_tr(11,i) * vec_in_x(11,j,2,k,ke) )
4928 div3d(i,j,1,k,ke) = s1 * e11_
4929 div3d(i,j,2,k,ke) = s2 * e11_
4930
4931 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
4932
4933 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
4934 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
4935 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
4936 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
4937 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
4938 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
4939 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
4940 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
4941 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) &
4942 + mat_tr(11,i) * vec_in_x(11,j,3,k,ke) )
4943 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
4944
4945 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
4946 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
4947 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
4948 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
4949 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
4950 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
4951 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
4952 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
4953 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) &
4954 + mat_tr(11,i) * vec_in_x(11,j,4,k,ke) )
4955 div3d(i,j,3,k,ke) = s1 * e11_
4956 div3d(i,j,4,k,ke) = s2 * e11_
4957
4958 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
4959
4960 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
4961 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
4962 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
4963 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
4964 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
4965 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
4966 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
4967 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
4968 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) &
4969 + mat_tr(11,i) * vec_in_x(11,j,5,k,ke) )
4970 div3d(i,j,5,k,ke) = s1 * e11_
4971 end do
4972 end do
4973 end do
4974 end do
4975
4976 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
4977 do ke=1, ne
4978 do k=1, 11
4979 do v=1, 5
4980 !$acc loop vector collapse(2)
4981 do j=1, 11
4982 do i=1, 11
4983
4984 ! Y-dir
4985 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
4986
4987 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
4988 + tmp_vec_in_y(2) * mat_tr(2,j) &
4989 + tmp_vec_in_y(3) * mat_tr(3,j) &
4990 + tmp_vec_in_y(8) * mat_tr(8,j)
4991 tmp3 = tmp_vec_in_y(9) * mat_tr(9,j) &
4992 + tmp_vec_in_y(10) * mat_tr(10,j) &
4993 + tmp_vec_in_y(11) * mat_tr(11,j)
4994 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
4995 end do
4996 end do
4997 end do
4998 end do
4999 end do
5000
5001 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
5002 do ke=1, ne
5003 do k=1, 11
5004 do v=1, 5
5005 !$acc loop vector collapse(2)
5006 do j=1, 11
5007 do i=1, 11
5008
5009 invg = 1.0_rp / gsqrt(i,j,k,ke)
5010 e33_ = e33(i,j,k,ke)
5011
5012
5013 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
5014 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
5015 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
5016 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
5017 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
5018 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
5019 tmp_lift = tmp1 + tmp2 + tmp3
5020
5021 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
5022 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
5023 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
5024 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
5025 tmp2 = vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
5026 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
5027 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
5028 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
5029 tmp3 = vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
5030 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k) &
5031 + vec_in_z(i,j,v,11,ke) * mat_tr(11,k)
5032! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
5033 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
5034
5035 end do
5036 end do
5037 end do
5038 end do
5039 end do
5040
5041 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p10()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(11,11,11,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(11,11,11,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=10.
Definition at line 5048 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5051 implicit none
5052 integer, intent(in) :: Ne
5053 real(RP), intent(in) :: Mat_h1D(11,11)
5054 real(RP), intent(in) :: Mat_h1D_tr(11,11)
5055 real(RP), intent(in) :: Mat_v1D_tr(11,11)
5056 real(RP), intent(in) :: vec_in(11,11,11,Ne)
5057 real(RP), intent(out) :: vec_work(11,11,11,Ne)
5058 real(RP), intent(out) :: vec_out(11,11,11,Ne)
5059
5060 integer :: ke
5061 integer :: i, j, k
5062 real(RP) :: tmp1, tmp2, tmp3
5063 !----------------------------------------------------------
5064
5065 ! X-dir
5066 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
5067 do ke=1, ne
5068 do k=1, 11
5069 !$acc loop vector collapse(2)
5070 do j=1, 11
5071 do i=1, 11
5072 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
5073 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
5074 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
5075 + mat_h1d(i,4) * vec_in(4,j,k,ke)
5076 tmp2 = mat_h1d(i,5) * vec_in(5,j,k,ke) &
5077 + mat_h1d(i,6) * vec_in(6,j,k,ke) &
5078 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
5079 + mat_h1d(i,8) * vec_in(8,j,k,ke)
5080 tmp3 = mat_h1d(i,9) * vec_in(9,j,k,ke) &
5081 + mat_h1d(i,10) * vec_in(10,j,k,ke) &
5082 + mat_h1d(i,11) * vec_in(11,j,k,ke)
5083 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
5084 end do
5085 end do
5086 end do
5087 end do
5088
5089 ! Y-dir
5090 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
5091 do ke=1, ne
5092 do k=1, 11
5093 !$acc loop vector collapse(2)
5094 do j=1, 11
5095 do i=1, 11
5096 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
5097 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
5098 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
5099 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j)
5100 tmp2 = vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
5101 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
5102 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
5103 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j)
5104 tmp3 = vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
5105 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j) &
5106 + vec_out(i,11,k,ke) * mat_h1d_tr(11,j)
5107 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
5108 end do
5109 end do
5110 end do
5111 end do
5112
5113 ! Z-dir
5114 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
5115 do ke=1, ne
5116 do k=1, 11
5117 !$acc loop vector collapse(2)
5118 do j=1, 11
5119 do i=1, 11
5120 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
5121 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
5122 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
5123 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k)
5124 tmp2 = vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
5125 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
5126 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
5127 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k)
5128 tmp3 = vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
5129 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k) &
5130 + vec_work(i,j,11,ke) * mat_v1d_tr(11,k)
5131 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
5132 end do
5133 end do
5134 end do
5135 end do
5136 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p11()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p11 | ( | real(rp), dimension(12,12), intent(in) | mat_z_tr, |
| real(rp), dimension(12**2,12,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(12**2,12,ne_out), 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 5145 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5146 implicit none
5147 integer, intent(in) :: Ne_in
5148 integer, intent(in) :: Ne_out
5149 real(RP), intent(in) :: Mat_z_tr(12,12)
5150 real(RP), intent(in) :: vec_in(12**2,12,Ne_in)
5151 real(RP), intent(out) :: vec_out(12**2,12,Ne_out)
5152
5153 integer :: ij, k, ke
5154 !----------------------------------------------------------
5155
5156 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
5157 do ke=1, ne_out
5158 do k=1, 12
5159 do ij=1, 12**2
5160 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
5161 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
5162 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
5163 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
5164 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
5165 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
5166 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
5167 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
5168 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
5169 + vec_in(ij,10,ke) * mat_z_tr(10,k) &
5170 + vec_in(ij,11,ke) * mat_z_tr(11,k) &
5171 + vec_in(ij,12,ke) * mat_z_tr(12,k)
5172 end do
5173 end do
5174 end do
5175
5176 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p11()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p11 | ( | real(rp), dimension(12,12), intent(in) | mat, |
| real(rp), dimension(12,12), intent(in) | mat_tr, | ||
| real(rp), dimension(12,12), intent(in) | vec_in_x, | ||
| real(rp), dimension(12,12), intent(in) | vec_in_y, | ||
| real(rp), dimension(12,12), intent(in) | e11, | ||
| real(rp), dimension(12,12), intent(in) | e22, | ||
| real(rp), dimension(12,12), intent(out) | div_out_xy ) |
Definition at line 5179 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5183 implicit none
5184 real(RP), intent(in) :: Mat(12,12)
5185 real(RP), intent(in) :: Mat_tr(12,12)
5186 real(RP), intent(in) :: vec_in_x(12,12)
5187 real(RP), intent(in) :: vec_in_y(12,12)
5188 real(RP), intent(in) :: E11(12,12)
5189 real(RP), intent(in) :: E22(12,12)
5190 real(RP), intent(out) :: div_out_xy(12,12)
5191
5192 integer :: i, j, jv, jk
5193 real(RP) :: tmp1, div_x
5194 real(RP) :: tmp2, tmp3
5195 !----------------------------------------------------------
5196 !$acc routine vector
5197
5198 !$acc loop vector collapse(2)
5199 do j=1, 12
5200 do i=1, 12
5201 ! X-dir
5202 tmp1 = mat(i,1) * vec_in_x(1,j) &
5203 + mat(i,2) * vec_in_x(2,j) &
5204 + mat(i,3) * vec_in_x(3,j) &
5205 + mat(i,4) * vec_in_x(4,j)
5206 tmp2 = mat(i,5) * vec_in_x(5,j) &
5207 + mat(i,6) * vec_in_x(6,j) &
5208 + mat(i,7) * vec_in_x(7,j) &
5209 + mat(i,8) * vec_in_x(8,j)
5210 tmp3 = mat(i,9) * vec_in_x(9,j) &
5211 + mat(i,10) * vec_in_x(10,j) &
5212 + mat(i,11) * vec_in_x(11,j) &
5213 + mat(i,12) * vec_in_x(12,j)
5214 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
5215
5216 ! Y-dir
5217 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
5218 + vec_in_y(i,2) * mat_tr(2,j) &
5219 + vec_in_y(i,3) * mat_tr(3,j) &
5220 + vec_in_y(i,4) * mat_tr(4,j)
5221 tmp2 = vec_in_y(i,5) * mat_tr(5,j) &
5222 + vec_in_y(i,6) * mat_tr(6,j) &
5223 + vec_in_y(i,7) * mat_tr(7,j) &
5224 + vec_in_y(i,8) * mat_tr(8,j)
5225 tmp3 = vec_in_y(i,9) * mat_tr(9,j) &
5226 + vec_in_y(i,10) * mat_tr(10,j) &
5227 + vec_in_y(i,11) * mat_tr(11,j) &
5228 + vec_in_y(i,12) * mat_tr(12,j)
5229 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
5230 end do
5231 end do
5232 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p11()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p11 | ( | real(rp), dimension(12,12), intent(in) | mat, |
| real(rp), dimension(12,12), intent(in) | mat_tr, | ||
| real(rp), dimension(12,12,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(12,12,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(12,12), intent(in) | e11, | ||
| real(rp), dimension(12,12), intent(in) | e22, | ||
| real(rp), dimension(12,12,5), intent(out) | div_out_xy ) |
Definition at line 5235 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5239 implicit none
5240 real(RP), intent(in) :: Mat(12,12)
5241 real(RP), intent(in) :: Mat_tr(12,12)
5242 real(RP), intent(in) :: vec_in_x(12,12,5)
5243 real(RP), intent(in) :: vec_in_y(12,12,5)
5244 real(RP), intent(in) :: E11(12,12)
5245 real(RP), intent(in) :: E22(12,12)
5246 real(RP), intent(out) :: div_out_xy(12,12,5)
5247
5248 integer :: i, j, jv, jk, v, kv
5249 real(RP) :: tmp1, div_x
5250 real(RP) :: tmp2, tmp3
5251 !----------------------------------------------------------
5252 !$acc routine vector
5253
5254 do v=1, 5
5255 !$acc loop vector collapse(2)
5256 do j=1, 12
5257 do i=1, 12
5258 ! X-dir
5259 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
5260 + mat(i,2) * vec_in_x(2,j,v) &
5261 + mat(i,3) * vec_in_x(3,j,v) &
5262 + mat(i,4) * vec_in_x(4,j,v)
5263 tmp2 = mat(i,5) * vec_in_x(5,j,v) &
5264 + mat(i,6) * vec_in_x(6,j,v) &
5265 + mat(i,7) * vec_in_x(7,j,v) &
5266 + mat(i,8) * vec_in_x(8,j,v)
5267 tmp3 = mat(i,9) * vec_in_x(9,j,v) &
5268 + mat(i,10) * vec_in_x(10,j,v) &
5269 + mat(i,11) * vec_in_x(11,j,v) &
5270 + mat(i,12) * vec_in_x(12,j,v)
5271 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
5272
5273 ! Y-dir
5274 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
5275 + vec_in_y(i,2,v) * mat_tr(2,j) &
5276 + vec_in_y(i,3,v) * mat_tr(3,j) &
5277 + vec_in_y(i,4,v) * mat_tr(4,j)
5278 tmp2 = vec_in_y(i,5,v) * mat_tr(5,j) &
5279 + vec_in_y(i,6,v) * mat_tr(6,j) &
5280 + vec_in_y(i,7,v) * mat_tr(7,j) &
5281 + vec_in_y(i,8,v) * mat_tr(8,j)
5282 tmp3 = vec_in_y(i,9,v) * mat_tr(9,j) &
5283 + vec_in_y(i,10,v) * mat_tr(10,j) &
5284 + vec_in_y(i,11,v) * mat_tr(11,j) &
5285 + vec_in_y(i,12,v) * mat_tr(12,j)
5286 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
5287 end do
5288 end do
5289 end do
5290 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p11()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p11 | ( | real(rp), dimension(12,12), intent(in) | mat_tr, |
| real(rp), dimension(12,12,12,6), intent(in) | lift, | ||
| real(rp), dimension(12,12,5,12), intent(in) | vec_in_z, | ||
| real(rp), dimension(12,12,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(12,12,12), intent(in) | e33, | ||
| real(rp), dimension(12,12,12), intent(in) | gsqrt, | ||
| real(rp), dimension(12,12,5,12), intent(inout) | div3d ) |
Definition at line 5293 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5296 implicit none
5297 real(RP), intent(in) :: Mat_tr(12,12)
5298 real(RP), intent(in) :: Lift(12,12,12,6)
5299 real(RP), intent(in) :: vec_in_z(12,12,5,12)
5300 real(RP), intent(in) :: ebnd_flux(12,12,6,5)
5301 real(RP), intent(in) :: E33(12,12,12)
5302 real(RP), intent(in) :: Gsqrt(12,12,12)
5303 real(RP), intent(inout) :: div3D(12,12,5,12)
5304
5305 integer :: i, j, k, v
5306 real(RP) :: tmp1
5307 real(RP) :: tmp_lift
5308 real(RP) :: tmp2, tmp3
5309 real(RP) :: invG, e33_
5310 !----------------------------------------------------------
5311
5312 !$acc routine vector
5313
5314 ! Z-dir
5315 do v=1, 5
5316 do k=1, 12
5317 !$acc loop vector collapse(2)
5318 do j=1, 12
5319 do i=1, 12
5320 invg = 1.0_rp / gsqrt(i,j,k)
5321 e33_ = e33(i,j,k)
5322
5323
5324 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
5325 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
5326 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
5327 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
5328 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
5329 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
5330 tmp_lift = tmp1 + tmp2 + tmp3
5331
5332 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
5333 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
5334 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
5335 + vec_in_z(i,j,v,4) * mat_tr(4,k)
5336 tmp2 = vec_in_z(i,j,v,5) * mat_tr(5,k) &
5337 + vec_in_z(i,j,v,6) * mat_tr(6,k) &
5338 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
5339 + vec_in_z(i,j,v,8) * mat_tr(8,k)
5340 tmp3 = vec_in_z(i,j,v,9) * mat_tr(9,k) &
5341 + vec_in_z(i,j,v,10) * mat_tr(10,k) &
5342 + vec_in_z(i,j,v,11) * mat_tr(11,k) &
5343 + vec_in_z(i,j,v,12) * mat_tr(12,k)
5344! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
5345 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
5346 end do
5347 end do
5348 end do
5349 end do
5350 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p11()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p11 | ( | real(rp), dimension(12,12), intent(in) | mat, |
| real(rp), dimension(12,12), intent(in) | mat_tr, | ||
| real(rp), dimension(12,12,12,6), intent(in) | lift, | ||
| real(rp), dimension(12,12,5,12,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(12,12,5,12,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(12,12,5,12,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(12,12,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | e11, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | e22, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | e33, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(12,12,5,12,ne), intent(inout) | div3d ) |
Definition at line 5353 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5357 implicit none
5358 real(RP), intent(in) :: Mat(12,12)
5359 real(RP), intent(in) :: Mat_tr(12,12)
5360 real(RP), intent(in) :: Lift(12,12,12,6)
5361 integer, intent(in) :: Ne
5362 real(RP), intent(in) :: vec_in_x(12,12,5,12,Ne)
5363 real(RP), intent(in) :: vec_in_y(12,12,5,12,Ne)
5364 real(RP), intent(in) :: vec_in_z(12,12,5,12,Ne)
5365 real(RP), intent(in) :: ebnd_flux(12,12,6,5,Ne)
5366 real(RP), intent(in) :: E11(12,12,12,Ne)
5367 real(RP), intent(in) :: E22(12,12,12,Ne)
5368 real(RP), intent(in) :: E33(12,12,12,Ne)
5369 real(RP), intent(in) :: Gsqrt(12,12,12,Ne)
5370 real(RP), intent(inout) :: div3D(12,12,5,12,Ne)
5371
5372 integer :: ke
5373 integer :: i, j, k, v
5374 real(RP) :: tmp1
5375 real(RP) :: tmp_lift
5376 real(RP) :: tmp2, tmp3
5377 real(RP) :: invG, e33_
5378 real(RP) :: div_x, div_xy
5379 !----------------------------------------------------------
5380
5381 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
5382 do ke=1, ne
5383 do k=1, 12
5384 do v=1, 5
5385 !$acc loop vector collapse(2)
5386 do j=1, 12
5387 do i=1, 12
5388 ! X-dir
5389 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
5390 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
5391 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
5392 + mat(i,4) * vec_in_x(4,j,v,k,ke)
5393 tmp2 = mat(i,5) * vec_in_x(5,j,v,k,ke) &
5394 + mat(i,6) * vec_in_x(6,j,v,k,ke) &
5395 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
5396 + mat(i,8) * vec_in_x(8,j,v,k,ke)
5397 tmp3 = mat(i,9) * vec_in_x(9,j,v,k,ke) &
5398 + mat(i,10) * vec_in_x(10,j,v,k,ke) &
5399 + mat(i,11) * vec_in_x(11,j,v,k,ke) &
5400 + mat(i,12) * vec_in_x(12,j,v,k,ke)
5401 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
5402
5403 ! Y-dir
5404 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
5405 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
5406 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
5407 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j)
5408 tmp2 = vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
5409 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
5410 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
5411 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j)
5412 tmp3 = vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
5413 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j) &
5414 + vec_in_y(i,11,v,k,ke) * mat_tr(11,j) &
5415 + vec_in_y(i,12,v,k,ke) * mat_tr(12,j)
5416 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
5417
5418
5419 ! Z-dir
5420
5421 invg = 1.0_rp / gsqrt(i,j,k,ke)
5422 e33_ = e33(i,j,k,ke)
5423
5424
5425 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
5426 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
5427 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
5428 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
5429 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
5430 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
5431 tmp_lift = tmp1 + tmp2 + tmp3
5432
5433 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
5434 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
5435 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
5436 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
5437 tmp2 = vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
5438 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
5439 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
5440 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
5441 tmp3 = vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
5442 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k) &
5443 + vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
5444 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k)
5445
5446 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
5447
5448 end do
5449 end do
5450 end do
5451 end do
5452 end do
5453 return
◆ element_operation_kernel_matvec_divlike_var5_p11_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p11_v2 | ( | real(rp), dimension(12,12), intent(in) | mat, |
| real(rp), dimension(12,12), intent(in) | mat_tr, | ||
| real(rp), dimension(12,12,12,6), intent(in) | lift, | ||
| real(rp), dimension(12,12,5,12,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(12,12,5,12,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(12,12,5,12,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(12,12,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | e11, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | e22, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | e33, | ||
| real(rp), dimension(12,12,12,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(12,12,5,12,ne), intent(inout) | div3d ) |
Definition at line 5456 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5460 implicit none
5461 real(RP), intent(in) :: Mat(12,12)
5462 real(RP), intent(in) :: Mat_tr(12,12)
5463 real(RP), intent(in) :: Lift(12,12,12,6)
5464 integer, intent(in) :: Ne
5465 real(RP), intent(in) :: vec_in_x(12,12,5,12,Ne)
5466 real(RP), intent(in) :: vec_in_y(12,12,5,12,Ne)
5467 real(RP), intent(in) :: vec_in_z(12,12,5,12,Ne)
5468 real(RP), intent(in) :: ebnd_flux(12,12,6,5,Ne)
5469 real(RP), intent(in) :: E11(12,12,12,Ne)
5470 real(RP), intent(in) :: E22(12,12,12,Ne)
5471 real(RP), intent(in) :: E33(12,12,12,Ne)
5472 real(RP), intent(in) :: Gsqrt(12,12,12,Ne)
5473 real(RP), intent(inout) :: div3D(12,12,5,12,Ne)
5474
5475 integer :: ke
5476 integer :: p, i, j, k, v, n
5477 real(RP) :: tmp1
5478 real(RP) :: tmp_lift
5479 real(RP) :: tmp2, tmp3
5480
5481 real(RP) :: invG, e33_
5482 real(RP) :: div_x, div_xy
5483
5484 real(RP) :: tmp_vec_in_y(12)
5485
5486 real(RP) :: s1, s2, s3, s4
5487 real(RP) :: e11_
5488 !----------------------------------------------------------
5489
5490 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
5491 do ke=1, ne
5492 do k=1, 12
5493 !$acc loop vector collapse(2)
5494 do j=1, 12
5495 do i=1, 12
5496 e11_ = e11(i,j,k,ke)
5497 ! X-dir
5498 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
5499
5500 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
5501 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
5502 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
5503 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
5504 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
5505 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
5506 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
5507 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
5508 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) &
5509 + mat_tr(11,i) * vec_in_x(11,j,1,k,ke) &
5510 + mat_tr(12,i) * vec_in_x(12,j,1,k,ke) )
5511 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
5512
5513 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
5514 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
5515 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
5516 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
5517 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
5518 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
5519 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
5520 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
5521 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) &
5522 + mat_tr(11,i) * vec_in_x(11,j,2,k,ke) &
5523 + mat_tr(12,i) * vec_in_x(12,j,2,k,ke) )
5524 div3d(i,j,1,k,ke) = s1 * e11_
5525 div3d(i,j,2,k,ke) = s2 * e11_
5526
5527 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
5528
5529 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
5530 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
5531 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
5532 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
5533 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
5534 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
5535 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
5536 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
5537 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) &
5538 + mat_tr(11,i) * vec_in_x(11,j,3,k,ke) &
5539 + mat_tr(12,i) * vec_in_x(12,j,3,k,ke) )
5540 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
5541
5542 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
5543 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
5544 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
5545 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
5546 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
5547 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
5548 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
5549 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
5550 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) &
5551 + mat_tr(11,i) * vec_in_x(11,j,4,k,ke) &
5552 + mat_tr(12,i) * vec_in_x(12,j,4,k,ke) )
5553 div3d(i,j,3,k,ke) = s1 * e11_
5554 div3d(i,j,4,k,ke) = s2 * e11_
5555
5556 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
5557
5558 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
5559 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
5560 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
5561 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
5562 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
5563 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
5564 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
5565 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
5566 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) &
5567 + mat_tr(11,i) * vec_in_x(11,j,5,k,ke) &
5568 + mat_tr(12,i) * vec_in_x(12,j,5,k,ke) )
5569 div3d(i,j,5,k,ke) = s1 * e11_
5570 end do
5571 end do
5572 end do
5573 end do
5574
5575 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
5576 do ke=1, ne
5577 do k=1, 12
5578 do v=1, 5
5579 !$acc loop vector collapse(2)
5580 do j=1, 12
5581 do i=1, 12
5582
5583 ! Y-dir
5584 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
5585
5586 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
5587 + tmp_vec_in_y(2) * mat_tr(2,j) &
5588 + tmp_vec_in_y(3) * mat_tr(3,j) &
5589 + tmp_vec_in_y(8) * mat_tr(8,j)
5590 tmp3 = tmp_vec_in_y(9) * mat_tr(9,j) &
5591 + tmp_vec_in_y(10) * mat_tr(10,j) &
5592 + tmp_vec_in_y(11) * mat_tr(11,j) &
5593 + tmp_vec_in_y(12) * mat_tr(12,j)
5594 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
5595 end do
5596 end do
5597 end do
5598 end do
5599 end do
5600
5601 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
5602 do ke=1, ne
5603 do k=1, 12
5604 do v=1, 5
5605 !$acc loop vector collapse(2)
5606 do j=1, 12
5607 do i=1, 12
5608
5609 invg = 1.0_rp / gsqrt(i,j,k,ke)
5610 e33_ = e33(i,j,k,ke)
5611
5612
5613 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
5614 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
5615 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
5616 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
5617 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
5618 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
5619 tmp_lift = tmp1 + tmp2 + tmp3
5620
5621 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
5622 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
5623 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
5624 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
5625 tmp2 = vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
5626 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
5627 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
5628 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
5629 tmp3 = vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
5630 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k) &
5631 + vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
5632 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k)
5633! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
5634 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
5635
5636 end do
5637 end do
5638 end do
5639 end do
5640 end do
5641
5642 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p11()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(12,12,12,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(12,12,12,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=11.
Definition at line 5649 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5652 implicit none
5653 integer, intent(in) :: Ne
5654 real(RP), intent(in) :: Mat_h1D(12,12)
5655 real(RP), intent(in) :: Mat_h1D_tr(12,12)
5656 real(RP), intent(in) :: Mat_v1D_tr(12,12)
5657 real(RP), intent(in) :: vec_in(12,12,12,Ne)
5658 real(RP), intent(out) :: vec_work(12,12,12,Ne)
5659 real(RP), intent(out) :: vec_out(12,12,12,Ne)
5660
5661 integer :: ke
5662 integer :: i, j, k
5663 real(RP) :: tmp1, tmp2, tmp3
5664 !----------------------------------------------------------
5665
5666 ! X-dir
5667 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
5668 do ke=1, ne
5669 do k=1, 12
5670 !$acc loop vector collapse(2)
5671 do j=1, 12
5672 do i=1, 12
5673 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
5674 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
5675 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
5676 + mat_h1d(i,4) * vec_in(4,j,k,ke)
5677 tmp2 = mat_h1d(i,5) * vec_in(5,j,k,ke) &
5678 + mat_h1d(i,6) * vec_in(6,j,k,ke) &
5679 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
5680 + mat_h1d(i,8) * vec_in(8,j,k,ke)
5681 tmp3 = mat_h1d(i,9) * vec_in(9,j,k,ke) &
5682 + mat_h1d(i,10) * vec_in(10,j,k,ke) &
5683 + mat_h1d(i,11) * vec_in(11,j,k,ke) &
5684 + mat_h1d(i,12) * vec_in(12,j,k,ke)
5685 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
5686 end do
5687 end do
5688 end do
5689 end do
5690
5691 ! Y-dir
5692 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
5693 do ke=1, ne
5694 do k=1, 12
5695 !$acc loop vector collapse(2)
5696 do j=1, 12
5697 do i=1, 12
5698 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
5699 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
5700 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
5701 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j)
5702 tmp2 = vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
5703 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
5704 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
5705 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j)
5706 tmp3 = vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
5707 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j) &
5708 + vec_out(i,11,k,ke) * mat_h1d_tr(11,j) &
5709 + vec_out(i,12,k,ke) * mat_h1d_tr(12,j)
5710 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
5711 end do
5712 end do
5713 end do
5714 end do
5715
5716 ! Z-dir
5717 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
5718 do ke=1, ne
5719 do k=1, 12
5720 !$acc loop vector collapse(2)
5721 do j=1, 12
5722 do i=1, 12
5723 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
5724 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
5725 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
5726 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k)
5727 tmp2 = vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
5728 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
5729 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
5730 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k)
5731 tmp3 = vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
5732 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k) &
5733 + vec_work(i,j,11,ke) * mat_v1d_tr(11,k) &
5734 + vec_work(i,j,12,ke) * mat_v1d_tr(12,k)
5735 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
5736 end do
5737 end do
5738 end do
5739 end do
5740 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p12()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p12 | ( | real(rp), dimension(13,13), intent(in) | mat_z_tr, |
| real(rp), dimension(13**2,13,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(13**2,13,ne_out), 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 5749 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5750 implicit none
5751 integer, intent(in) :: Ne_in
5752 integer, intent(in) :: Ne_out
5753 real(RP), intent(in) :: Mat_z_tr(13,13)
5754 real(RP), intent(in) :: vec_in(13**2,13,Ne_in)
5755 real(RP), intent(out) :: vec_out(13**2,13,Ne_out)
5756
5757 integer :: ij, k, ke
5758 !----------------------------------------------------------
5759
5760 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
5761 do ke=1, ne_out
5762 do k=1, 13
5763 do ij=1, 13**2
5764 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
5765 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
5766 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
5767 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
5768 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
5769 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
5770 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
5771 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
5772 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
5773 + vec_in(ij,10,ke) * mat_z_tr(10,k) &
5774 + vec_in(ij,11,ke) * mat_z_tr(11,k) &
5775 + vec_in(ij,12,ke) * mat_z_tr(12,k) &
5776 + vec_in(ij,13,ke) * mat_z_tr(13,k)
5777 end do
5778 end do
5779 end do
5780
5781 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p12()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p12 | ( | real(rp), dimension(13,13), intent(in) | mat, |
| real(rp), dimension(13,13), intent(in) | mat_tr, | ||
| real(rp), dimension(13,13), intent(in) | vec_in_x, | ||
| real(rp), dimension(13,13), intent(in) | vec_in_y, | ||
| real(rp), dimension(13,13), intent(in) | e11, | ||
| real(rp), dimension(13,13), intent(in) | e22, | ||
| real(rp), dimension(13,13), intent(out) | div_out_xy ) |
Definition at line 5784 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5788 implicit none
5789 real(RP), intent(in) :: Mat(13,13)
5790 real(RP), intent(in) :: Mat_tr(13,13)
5791 real(RP), intent(in) :: vec_in_x(13,13)
5792 real(RP), intent(in) :: vec_in_y(13,13)
5793 real(RP), intent(in) :: E11(13,13)
5794 real(RP), intent(in) :: E22(13,13)
5795 real(RP), intent(out) :: div_out_xy(13,13)
5796
5797 integer :: i, j, jv, jk
5798 real(RP) :: tmp1, div_x
5799 real(RP) :: tmp2, tmp3
5800 !----------------------------------------------------------
5801 !$acc routine vector
5802
5803 !$acc loop vector collapse(2)
5804 do j=1, 13
5805 do i=1, 13
5806 ! X-dir
5807 tmp1 = mat(i,1) * vec_in_x(1,j) &
5808 + mat(i,2) * vec_in_x(2,j) &
5809 + mat(i,3) * vec_in_x(3,j) &
5810 + mat(i,4) * vec_in_x(4,j)
5811 tmp2 = mat(i,5) * vec_in_x(5,j) &
5812 + mat(i,6) * vec_in_x(6,j) &
5813 + mat(i,7) * vec_in_x(7,j) &
5814 + mat(i,8) * vec_in_x(8,j)
5815 tmp3 = mat(i,9) * vec_in_x(9,j) &
5816 + mat(i,10) * vec_in_x(10,j) &
5817 + mat(i,11) * vec_in_x(11,j) &
5818 + mat(i,12) * vec_in_x(12,j) &
5819 + mat(i,13) * vec_in_x(13,j)
5820 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
5821
5822 ! Y-dir
5823 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
5824 + vec_in_y(i,2) * mat_tr(2,j) &
5825 + vec_in_y(i,3) * mat_tr(3,j) &
5826 + vec_in_y(i,4) * mat_tr(4,j)
5827 tmp2 = vec_in_y(i,5) * mat_tr(5,j) &
5828 + vec_in_y(i,6) * mat_tr(6,j) &
5829 + vec_in_y(i,7) * mat_tr(7,j) &
5830 + vec_in_y(i,8) * mat_tr(8,j)
5831 tmp3 = vec_in_y(i,9) * mat_tr(9,j) &
5832 + vec_in_y(i,10) * mat_tr(10,j) &
5833 + vec_in_y(i,11) * mat_tr(11,j) &
5834 + vec_in_y(i,12) * mat_tr(12,j) &
5835 + vec_in_y(i,13) * mat_tr(13,j)
5836 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
5837 end do
5838 end do
5839 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p12()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p12 | ( | real(rp), dimension(13,13), intent(in) | mat, |
| real(rp), dimension(13,13), intent(in) | mat_tr, | ||
| real(rp), dimension(13,13,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(13,13,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(13,13), intent(in) | e11, | ||
| real(rp), dimension(13,13), intent(in) | e22, | ||
| real(rp), dimension(13,13,5), intent(out) | div_out_xy ) |
Definition at line 5842 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5846 implicit none
5847 real(RP), intent(in) :: Mat(13,13)
5848 real(RP), intent(in) :: Mat_tr(13,13)
5849 real(RP), intent(in) :: vec_in_x(13,13,5)
5850 real(RP), intent(in) :: vec_in_y(13,13,5)
5851 real(RP), intent(in) :: E11(13,13)
5852 real(RP), intent(in) :: E22(13,13)
5853 real(RP), intent(out) :: div_out_xy(13,13,5)
5854
5855 integer :: i, j, jv, jk, v, kv
5856 real(RP) :: tmp1, div_x
5857 real(RP) :: tmp2, tmp3
5858 !----------------------------------------------------------
5859 !$acc routine vector
5860
5861 do v=1, 5
5862 !$acc loop vector collapse(2)
5863 do j=1, 13
5864 do i=1, 13
5865 ! X-dir
5866 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
5867 + mat(i,2) * vec_in_x(2,j,v) &
5868 + mat(i,3) * vec_in_x(3,j,v) &
5869 + mat(i,4) * vec_in_x(4,j,v)
5870 tmp2 = mat(i,5) * vec_in_x(5,j,v) &
5871 + mat(i,6) * vec_in_x(6,j,v) &
5872 + mat(i,7) * vec_in_x(7,j,v) &
5873 + mat(i,8) * vec_in_x(8,j,v)
5874 tmp3 = mat(i,9) * vec_in_x(9,j,v) &
5875 + mat(i,10) * vec_in_x(10,j,v) &
5876 + mat(i,11) * vec_in_x(11,j,v) &
5877 + mat(i,12) * vec_in_x(12,j,v) &
5878 + mat(i,13) * vec_in_x(13,j,v)
5879 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
5880
5881 ! Y-dir
5882 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
5883 + vec_in_y(i,2,v) * mat_tr(2,j) &
5884 + vec_in_y(i,3,v) * mat_tr(3,j) &
5885 + vec_in_y(i,4,v) * mat_tr(4,j)
5886 tmp2 = vec_in_y(i,5,v) * mat_tr(5,j) &
5887 + vec_in_y(i,6,v) * mat_tr(6,j) &
5888 + vec_in_y(i,7,v) * mat_tr(7,j) &
5889 + vec_in_y(i,8,v) * mat_tr(8,j)
5890 tmp3 = vec_in_y(i,9,v) * mat_tr(9,j) &
5891 + vec_in_y(i,10,v) * mat_tr(10,j) &
5892 + vec_in_y(i,11,v) * mat_tr(11,j) &
5893 + vec_in_y(i,12,v) * mat_tr(12,j) &
5894 + vec_in_y(i,13,v) * mat_tr(13,j)
5895 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
5896 end do
5897 end do
5898 end do
5899 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p12()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p12 | ( | real(rp), dimension(13,13), intent(in) | mat_tr, |
| real(rp), dimension(13,13,13,6), intent(in) | lift, | ||
| real(rp), dimension(13,13,5,13), intent(in) | vec_in_z, | ||
| real(rp), dimension(13,13,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(13,13,13), intent(in) | e33, | ||
| real(rp), dimension(13,13,13), intent(in) | gsqrt, | ||
| real(rp), dimension(13,13,5,13), intent(inout) | div3d ) |
Definition at line 5902 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5905 implicit none
5906 real(RP), intent(in) :: Mat_tr(13,13)
5907 real(RP), intent(in) :: Lift(13,13,13,6)
5908 real(RP), intent(in) :: vec_in_z(13,13,5,13)
5909 real(RP), intent(in) :: ebnd_flux(13,13,6,5)
5910 real(RP), intent(in) :: E33(13,13,13)
5911 real(RP), intent(in) :: Gsqrt(13,13,13)
5912 real(RP), intent(inout) :: div3D(13,13,5,13)
5913
5914 integer :: i, j, k, v
5915 real(RP) :: tmp1
5916 real(RP) :: tmp_lift
5917 real(RP) :: tmp2, tmp3
5918 real(RP) :: invG, e33_
5919 !----------------------------------------------------------
5920
5921 !$acc routine vector
5922
5923 ! Z-dir
5924 do v=1, 5
5925 do k=1, 13
5926 !$acc loop vector collapse(2)
5927 do j=1, 13
5928 do i=1, 13
5929 invg = 1.0_rp / gsqrt(i,j,k)
5930 e33_ = e33(i,j,k)
5931
5932
5933 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
5934 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
5935 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
5936 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
5937 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
5938 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
5939 tmp_lift = tmp1 + tmp2 + tmp3
5940
5941 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
5942 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
5943 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
5944 + vec_in_z(i,j,v,4) * mat_tr(4,k)
5945 tmp2 = vec_in_z(i,j,v,5) * mat_tr(5,k) &
5946 + vec_in_z(i,j,v,6) * mat_tr(6,k) &
5947 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
5948 + vec_in_z(i,j,v,8) * mat_tr(8,k)
5949 tmp3 = vec_in_z(i,j,v,9) * mat_tr(9,k) &
5950 + vec_in_z(i,j,v,10) * mat_tr(10,k) &
5951 + vec_in_z(i,j,v,11) * mat_tr(11,k) &
5952 + vec_in_z(i,j,v,12) * mat_tr(12,k) &
5953 + vec_in_z(i,j,v,13) * mat_tr(13,k)
5954! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
5955 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
5956 end do
5957 end do
5958 end do
5959 end do
5960 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p12()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p12 | ( | real(rp), dimension(13,13), intent(in) | mat, |
| real(rp), dimension(13,13), intent(in) | mat_tr, | ||
| real(rp), dimension(13,13,13,6), intent(in) | lift, | ||
| real(rp), dimension(13,13,5,13,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(13,13,5,13,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(13,13,5,13,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(13,13,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | e11, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | e22, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | e33, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(13,13,5,13,ne), intent(inout) | div3d ) |
Definition at line 5963 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
5967 implicit none
5968 real(RP), intent(in) :: Mat(13,13)
5969 real(RP), intent(in) :: Mat_tr(13,13)
5970 real(RP), intent(in) :: Lift(13,13,13,6)
5971 integer, intent(in) :: Ne
5972 real(RP), intent(in) :: vec_in_x(13,13,5,13,Ne)
5973 real(RP), intent(in) :: vec_in_y(13,13,5,13,Ne)
5974 real(RP), intent(in) :: vec_in_z(13,13,5,13,Ne)
5975 real(RP), intent(in) :: ebnd_flux(13,13,6,5,Ne)
5976 real(RP), intent(in) :: E11(13,13,13,Ne)
5977 real(RP), intent(in) :: E22(13,13,13,Ne)
5978 real(RP), intent(in) :: E33(13,13,13,Ne)
5979 real(RP), intent(in) :: Gsqrt(13,13,13,Ne)
5980 real(RP), intent(inout) :: div3D(13,13,5,13,Ne)
5981
5982 integer :: ke
5983 integer :: i, j, k, v
5984 real(RP) :: tmp1
5985 real(RP) :: tmp_lift
5986 real(RP) :: tmp2, tmp3
5987 real(RP) :: invG, e33_
5988 real(RP) :: div_x, div_xy
5989 !----------------------------------------------------------
5990
5991 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
5992 do ke=1, ne
5993 do k=1, 13
5994 do v=1, 5
5995 !$acc loop vector collapse(2)
5996 do j=1, 13
5997 do i=1, 13
5998 ! X-dir
5999 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
6000 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
6001 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
6002 + mat(i,4) * vec_in_x(4,j,v,k,ke)
6003 tmp2 = mat(i,5) * vec_in_x(5,j,v,k,ke) &
6004 + mat(i,6) * vec_in_x(6,j,v,k,ke) &
6005 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
6006 + mat(i,8) * vec_in_x(8,j,v,k,ke)
6007 tmp3 = mat(i,9) * vec_in_x(9,j,v,k,ke) &
6008 + mat(i,10) * vec_in_x(10,j,v,k,ke) &
6009 + mat(i,11) * vec_in_x(11,j,v,k,ke) &
6010 + mat(i,12) * vec_in_x(12,j,v,k,ke) &
6011 + mat(i,13) * vec_in_x(13,j,v,k,ke)
6012 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
6013
6014 ! Y-dir
6015 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
6016 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
6017 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
6018 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j)
6019 tmp2 = vec_in_y(i,5,v,k,ke) * mat_tr(5,j) &
6020 + vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
6021 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
6022 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j)
6023 tmp3 = vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
6024 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j) &
6025 + vec_in_y(i,11,v,k,ke) * mat_tr(11,j) &
6026 + vec_in_y(i,12,v,k,ke) * mat_tr(12,j) &
6027 + vec_in_y(i,13,v,k,ke) * mat_tr(13,j)
6028 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
6029
6030
6031 ! Z-dir
6032
6033 invg = 1.0_rp / gsqrt(i,j,k,ke)
6034 e33_ = e33(i,j,k,ke)
6035
6036
6037 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
6038 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
6039 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
6040 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
6041 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
6042 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
6043 tmp_lift = tmp1 + tmp2 + tmp3
6044
6045 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
6046 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
6047 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
6048 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
6049 tmp2 = vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
6050 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
6051 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
6052 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
6053 tmp3 = vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
6054 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k) &
6055 + vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
6056 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
6057 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k)
6058
6059 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
6060
6061 end do
6062 end do
6063 end do
6064 end do
6065 end do
6066 return
◆ element_operation_kernel_matvec_divlike_var5_p12_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p12_v2 | ( | real(rp), dimension(13,13), intent(in) | mat, |
| real(rp), dimension(13,13), intent(in) | mat_tr, | ||
| real(rp), dimension(13,13,13,6), intent(in) | lift, | ||
| real(rp), dimension(13,13,5,13,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(13,13,5,13,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(13,13,5,13,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(13,13,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | e11, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | e22, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | e33, | ||
| real(rp), dimension(13,13,13,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(13,13,5,13,ne), intent(inout) | div3d ) |
Definition at line 6069 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6073 implicit none
6074 real(RP), intent(in) :: Mat(13,13)
6075 real(RP), intent(in) :: Mat_tr(13,13)
6076 real(RP), intent(in) :: Lift(13,13,13,6)
6077 integer, intent(in) :: Ne
6078 real(RP), intent(in) :: vec_in_x(13,13,5,13,Ne)
6079 real(RP), intent(in) :: vec_in_y(13,13,5,13,Ne)
6080 real(RP), intent(in) :: vec_in_z(13,13,5,13,Ne)
6081 real(RP), intent(in) :: ebnd_flux(13,13,6,5,Ne)
6082 real(RP), intent(in) :: E11(13,13,13,Ne)
6083 real(RP), intent(in) :: E22(13,13,13,Ne)
6084 real(RP), intent(in) :: E33(13,13,13,Ne)
6085 real(RP), intent(in) :: Gsqrt(13,13,13,Ne)
6086 real(RP), intent(inout) :: div3D(13,13,5,13,Ne)
6087
6088 integer :: ke
6089 integer :: p, i, j, k, v, n
6090 real(RP) :: tmp1
6091 real(RP) :: tmp_lift
6092 real(RP) :: tmp2, tmp3
6093
6094 real(RP) :: invG, e33_
6095 real(RP) :: div_x, div_xy
6096
6097 real(RP) :: tmp_vec_in_y(13)
6098
6099 real(RP) :: s1, s2, s3, s4
6100 real(RP) :: e11_
6101 !----------------------------------------------------------
6102
6103 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
6104 do ke=1, ne
6105 do k=1, 13
6106 !$acc loop vector collapse(2)
6107 do j=1, 13
6108 do i=1, 13
6109 e11_ = e11(i,j,k,ke)
6110 ! X-dir
6111 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
6112
6113 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
6114 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
6115 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
6116 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
6117 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
6118 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
6119 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
6120 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
6121 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) &
6122 + mat_tr(11,i) * vec_in_x(11,j,1,k,ke) &
6123 + mat_tr(12,i) * vec_in_x(12,j,1,k,ke) &
6124 + mat_tr(13,i) * vec_in_x(13,j,1,k,ke) )
6125 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
6126
6127 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
6128 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
6129 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
6130 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
6131 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
6132 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
6133 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
6134 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
6135 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) &
6136 + mat_tr(11,i) * vec_in_x(11,j,2,k,ke) &
6137 + mat_tr(12,i) * vec_in_x(12,j,2,k,ke) &
6138 + mat_tr(13,i) * vec_in_x(13,j,2,k,ke) )
6139 div3d(i,j,1,k,ke) = s1 * e11_
6140 div3d(i,j,2,k,ke) = s2 * e11_
6141
6142 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
6143
6144 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
6145 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
6146 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
6147 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
6148 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
6149 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
6150 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
6151 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
6152 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) &
6153 + mat_tr(11,i) * vec_in_x(11,j,3,k,ke) &
6154 + mat_tr(12,i) * vec_in_x(12,j,3,k,ke) &
6155 + mat_tr(13,i) * vec_in_x(13,j,3,k,ke) )
6156 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
6157
6158 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
6159 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
6160 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
6161 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
6162 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
6163 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
6164 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
6165 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
6166 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) &
6167 + mat_tr(11,i) * vec_in_x(11,j,4,k,ke) &
6168 + mat_tr(12,i) * vec_in_x(12,j,4,k,ke) &
6169 + mat_tr(13,i) * vec_in_x(13,j,4,k,ke) )
6170 div3d(i,j,3,k,ke) = s1 * e11_
6171 div3d(i,j,4,k,ke) = s2 * e11_
6172
6173 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
6174
6175 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
6176 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
6177 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
6178 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
6179 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
6180 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
6181 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
6182 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
6183 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) &
6184 + mat_tr(11,i) * vec_in_x(11,j,5,k,ke) &
6185 + mat_tr(12,i) * vec_in_x(12,j,5,k,ke) &
6186 + mat_tr(13,i) * vec_in_x(13,j,5,k,ke) )
6187 div3d(i,j,5,k,ke) = s1 * e11_
6188 end do
6189 end do
6190 end do
6191 end do
6192
6193 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
6194 do ke=1, ne
6195 do k=1, 13
6196 do v=1, 5
6197 !$acc loop vector collapse(2)
6198 do j=1, 13
6199 do i=1, 13
6200
6201 ! Y-dir
6202 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
6203
6204 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
6205 + tmp_vec_in_y(2) * mat_tr(2,j) &
6206 + tmp_vec_in_y(3) * mat_tr(3,j) &
6207 + tmp_vec_in_y(8) * mat_tr(8,j)
6208 tmp3 = tmp_vec_in_y(9) * mat_tr(9,j) &
6209 + tmp_vec_in_y(10) * mat_tr(10,j) &
6210 + tmp_vec_in_y(11) * mat_tr(11,j) &
6211 + tmp_vec_in_y(12) * mat_tr(12,j) &
6212 + tmp_vec_in_y(13) * mat_tr(13,j)
6213 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
6214 end do
6215 end do
6216 end do
6217 end do
6218 end do
6219
6220 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
6221 do ke=1, ne
6222 do k=1, 13
6223 do v=1, 5
6224 !$acc loop vector collapse(2)
6225 do j=1, 13
6226 do i=1, 13
6227
6228 invg = 1.0_rp / gsqrt(i,j,k,ke)
6229 e33_ = e33(i,j,k,ke)
6230
6231
6232 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
6233 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
6234 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
6235 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
6236 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
6237 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
6238 tmp_lift = tmp1 + tmp2 + tmp3
6239
6240 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
6241 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
6242 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
6243 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k)
6244 tmp2 = vec_in_z(i,j,v,5,ke) * mat_tr(5,k) &
6245 + vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
6246 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
6247 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k)
6248 tmp3 = vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
6249 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k) &
6250 + vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
6251 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
6252 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k)
6253! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
6254 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
6255
6256 end do
6257 end do
6258 end do
6259 end do
6260 end do
6261
6262 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p12()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(13,13,13,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(13,13,13,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=12.
Definition at line 6269 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6272 implicit none
6273 integer, intent(in) :: Ne
6274 real(RP), intent(in) :: Mat_h1D(13,13)
6275 real(RP), intent(in) :: Mat_h1D_tr(13,13)
6276 real(RP), intent(in) :: Mat_v1D_tr(13,13)
6277 real(RP), intent(in) :: vec_in(13,13,13,Ne)
6278 real(RP), intent(out) :: vec_work(13,13,13,Ne)
6279 real(RP), intent(out) :: vec_out(13,13,13,Ne)
6280
6281 integer :: ke
6282 integer :: i, j, k
6283 real(RP) :: tmp1, tmp2, tmp3
6284 !----------------------------------------------------------
6285
6286 ! X-dir
6287 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
6288 do ke=1, ne
6289 do k=1, 13
6290 !$acc loop vector collapse(2)
6291 do j=1, 13
6292 do i=1, 13
6293 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
6294 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
6295 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
6296 + mat_h1d(i,4) * vec_in(4,j,k,ke)
6297 tmp2 = mat_h1d(i,5) * vec_in(5,j,k,ke) &
6298 + mat_h1d(i,6) * vec_in(6,j,k,ke) &
6299 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
6300 + mat_h1d(i,8) * vec_in(8,j,k,ke)
6301 tmp3 = mat_h1d(i,9) * vec_in(9,j,k,ke) &
6302 + mat_h1d(i,10) * vec_in(10,j,k,ke) &
6303 + mat_h1d(i,11) * vec_in(11,j,k,ke) &
6304 + mat_h1d(i,12) * vec_in(12,j,k,ke) &
6305 + mat_h1d(i,13) * vec_in(13,j,k,ke)
6306 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
6307 end do
6308 end do
6309 end do
6310 end do
6311
6312 ! Y-dir
6313 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
6314 do ke=1, ne
6315 do k=1, 13
6316 !$acc loop vector collapse(2)
6317 do j=1, 13
6318 do i=1, 13
6319 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
6320 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
6321 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
6322 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j)
6323 tmp2 = vec_out(i,5,k,ke) * mat_h1d_tr(5,j) &
6324 + vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
6325 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
6326 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j)
6327 tmp3 = vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
6328 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j) &
6329 + vec_out(i,11,k,ke) * mat_h1d_tr(11,j) &
6330 + vec_out(i,12,k,ke) * mat_h1d_tr(12,j) &
6331 + vec_out(i,13,k,ke) * mat_h1d_tr(13,j)
6332 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
6333 end do
6334 end do
6335 end do
6336 end do
6337
6338 ! Z-dir
6339 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
6340 do ke=1, ne
6341 do k=1, 13
6342 !$acc loop vector collapse(2)
6343 do j=1, 13
6344 do i=1, 13
6345 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
6346 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
6347 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
6348 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k)
6349 tmp2 = vec_work(i,j,5,ke) * mat_v1d_tr(5,k) &
6350 + vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
6351 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
6352 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k)
6353 tmp3 = vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
6354 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k) &
6355 + vec_work(i,j,11,ke) * mat_v1d_tr(11,k) &
6356 + vec_work(i,j,12,ke) * mat_v1d_tr(12,k) &
6357 + vec_work(i,j,13,ke) * mat_v1d_tr(13,k)
6358 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
6359 end do
6360 end do
6361 end do
6362 end do
6363 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p13()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p13 | ( | real(rp), dimension(14,14), intent(in) | mat_z_tr, |
| real(rp), dimension(14**2,14,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(14**2,14,ne_out), 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 6372 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6373 implicit none
6374 integer, intent(in) :: Ne_in
6375 integer, intent(in) :: Ne_out
6376 real(RP), intent(in) :: Mat_z_tr(14,14)
6377 real(RP), intent(in) :: vec_in(14**2,14,Ne_in)
6378 real(RP), intent(out) :: vec_out(14**2,14,Ne_out)
6379
6380 integer :: ij, k, ke
6381 !----------------------------------------------------------
6382
6383 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
6384 do ke=1, ne_out
6385 do k=1, 14
6386 do ij=1, 14**2
6387 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
6388 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
6389 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
6390 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
6391 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
6392 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
6393 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
6394 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
6395 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
6396 + vec_in(ij,10,ke) * mat_z_tr(10,k) &
6397 + vec_in(ij,11,ke) * mat_z_tr(11,k) &
6398 + vec_in(ij,12,ke) * mat_z_tr(12,k) &
6399 + vec_in(ij,13,ke) * mat_z_tr(13,k) &
6400 + vec_in(ij,14,ke) * mat_z_tr(14,k)
6401 end do
6402 end do
6403 end do
6404
6405 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p13()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p13 | ( | real(rp), dimension(14,14), intent(in) | mat, |
| real(rp), dimension(14,14), intent(in) | mat_tr, | ||
| real(rp), dimension(14,14), intent(in) | vec_in_x, | ||
| real(rp), dimension(14,14), intent(in) | vec_in_y, | ||
| real(rp), dimension(14,14), intent(in) | e11, | ||
| real(rp), dimension(14,14), intent(in) | e22, | ||
| real(rp), dimension(14,14), intent(out) | div_out_xy ) |
Definition at line 6408 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6412 implicit none
6413 real(RP), intent(in) :: Mat(14,14)
6414 real(RP), intent(in) :: Mat_tr(14,14)
6415 real(RP), intent(in) :: vec_in_x(14,14)
6416 real(RP), intent(in) :: vec_in_y(14,14)
6417 real(RP), intent(in) :: E11(14,14)
6418 real(RP), intent(in) :: E22(14,14)
6419 real(RP), intent(out) :: div_out_xy(14,14)
6420
6421 integer :: i, j, jv, jk
6422 real(RP) :: tmp1, div_x
6423 real(RP) :: tmp2, tmp3
6424 !----------------------------------------------------------
6425 !$acc routine vector
6426
6427 !$acc loop vector collapse(2)
6428 do j=1, 14
6429 do i=1, 14
6430 ! X-dir
6431 tmp1 = mat(i,1) * vec_in_x(1,j) &
6432 + mat(i,2) * vec_in_x(2,j) &
6433 + mat(i,3) * vec_in_x(3,j) &
6434 + mat(i,4) * vec_in_x(4,j) &
6435 + mat(i,5) * vec_in_x(5,j)
6436 tmp2 = mat(i,6) * vec_in_x(6,j) &
6437 + mat(i,7) * vec_in_x(7,j) &
6438 + mat(i,8) * vec_in_x(8,j) &
6439 + mat(i,9) * vec_in_x(9,j) &
6440 + mat(i,10) * vec_in_x(10,j)
6441 tmp3 = mat(i,11) * vec_in_x(11,j) &
6442 + mat(i,12) * vec_in_x(12,j) &
6443 + mat(i,13) * vec_in_x(13,j) &
6444 + mat(i,14) * vec_in_x(14,j)
6445 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
6446
6447 ! Y-dir
6448 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
6449 + vec_in_y(i,2) * mat_tr(2,j) &
6450 + vec_in_y(i,3) * mat_tr(3,j) &
6451 + vec_in_y(i,4) * mat_tr(4,j) &
6452 + vec_in_y(i,5) * mat_tr(5,j)
6453 tmp2 = vec_in_y(i,6) * mat_tr(6,j) &
6454 + vec_in_y(i,7) * mat_tr(7,j) &
6455 + vec_in_y(i,8) * mat_tr(8,j) &
6456 + vec_in_y(i,9) * mat_tr(9,j) &
6457 + vec_in_y(i,10) * mat_tr(10,j)
6458 tmp3 = vec_in_y(i,11) * mat_tr(11,j) &
6459 + vec_in_y(i,12) * mat_tr(12,j) &
6460 + vec_in_y(i,13) * mat_tr(13,j) &
6461 + vec_in_y(i,14) * mat_tr(14,j)
6462 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
6463 end do
6464 end do
6465 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p13()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p13 | ( | real(rp), dimension(14,14), intent(in) | mat, |
| real(rp), dimension(14,14), intent(in) | mat_tr, | ||
| real(rp), dimension(14,14,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(14,14,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(14,14), intent(in) | e11, | ||
| real(rp), dimension(14,14), intent(in) | e22, | ||
| real(rp), dimension(14,14,5), intent(out) | div_out_xy ) |
Definition at line 6468 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6472 implicit none
6473 real(RP), intent(in) :: Mat(14,14)
6474 real(RP), intent(in) :: Mat_tr(14,14)
6475 real(RP), intent(in) :: vec_in_x(14,14,5)
6476 real(RP), intent(in) :: vec_in_y(14,14,5)
6477 real(RP), intent(in) :: E11(14,14)
6478 real(RP), intent(in) :: E22(14,14)
6479 real(RP), intent(out) :: div_out_xy(14,14,5)
6480
6481 integer :: i, j, jv, jk, v, kv
6482 real(RP) :: tmp1, div_x
6483 real(RP) :: tmp2, tmp3
6484 !----------------------------------------------------------
6485 !$acc routine vector
6486
6487 do v=1, 5
6488 !$acc loop vector collapse(2)
6489 do j=1, 14
6490 do i=1, 14
6491 ! X-dir
6492 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
6493 + mat(i,2) * vec_in_x(2,j,v) &
6494 + mat(i,3) * vec_in_x(3,j,v) &
6495 + mat(i,4) * vec_in_x(4,j,v) &
6496 + mat(i,5) * vec_in_x(5,j,v)
6497 tmp2 = mat(i,6) * vec_in_x(6,j,v) &
6498 + mat(i,7) * vec_in_x(7,j,v) &
6499 + mat(i,8) * vec_in_x(8,j,v) &
6500 + mat(i,9) * vec_in_x(9,j,v) &
6501 + mat(i,10) * vec_in_x(10,j,v)
6502 tmp3 = mat(i,11) * vec_in_x(11,j,v) &
6503 + mat(i,12) * vec_in_x(12,j,v) &
6504 + mat(i,13) * vec_in_x(13,j,v) &
6505 + mat(i,14) * vec_in_x(14,j,v)
6506 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
6507
6508 ! Y-dir
6509 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
6510 + vec_in_y(i,2,v) * mat_tr(2,j) &
6511 + vec_in_y(i,3,v) * mat_tr(3,j) &
6512 + vec_in_y(i,4,v) * mat_tr(4,j) &
6513 + vec_in_y(i,5,v) * mat_tr(5,j)
6514 tmp2 = vec_in_y(i,6,v) * mat_tr(6,j) &
6515 + vec_in_y(i,7,v) * mat_tr(7,j) &
6516 + vec_in_y(i,8,v) * mat_tr(8,j) &
6517 + vec_in_y(i,9,v) * mat_tr(9,j) &
6518 + vec_in_y(i,10,v) * mat_tr(10,j)
6519 tmp3 = vec_in_y(i,11,v) * mat_tr(11,j) &
6520 + vec_in_y(i,12,v) * mat_tr(12,j) &
6521 + vec_in_y(i,13,v) * mat_tr(13,j) &
6522 + vec_in_y(i,14,v) * mat_tr(14,j)
6523 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
6524 end do
6525 end do
6526 end do
6527 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p13()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p13 | ( | real(rp), dimension(14,14), intent(in) | mat_tr, |
| real(rp), dimension(14,14,14,6), intent(in) | lift, | ||
| real(rp), dimension(14,14,5,14), intent(in) | vec_in_z, | ||
| real(rp), dimension(14,14,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(14,14,14), intent(in) | e33, | ||
| real(rp), dimension(14,14,14), intent(in) | gsqrt, | ||
| real(rp), dimension(14,14,5,14), intent(inout) | div3d ) |
Definition at line 6530 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6533 implicit none
6534 real(RP), intent(in) :: Mat_tr(14,14)
6535 real(RP), intent(in) :: Lift(14,14,14,6)
6536 real(RP), intent(in) :: vec_in_z(14,14,5,14)
6537 real(RP), intent(in) :: ebnd_flux(14,14,6,5)
6538 real(RP), intent(in) :: E33(14,14,14)
6539 real(RP), intent(in) :: Gsqrt(14,14,14)
6540 real(RP), intent(inout) :: div3D(14,14,5,14)
6541
6542 integer :: i, j, k, v
6543 real(RP) :: tmp1
6544 real(RP) :: tmp_lift
6545 real(RP) :: tmp2, tmp3
6546 real(RP) :: invG, e33_
6547 !----------------------------------------------------------
6548
6549 !$acc routine vector
6550
6551 ! Z-dir
6552 do v=1, 5
6553 do k=1, 14
6554 !$acc loop vector collapse(2)
6555 do j=1, 14
6556 do i=1, 14
6557 invg = 1.0_rp / gsqrt(i,j,k)
6558 e33_ = e33(i,j,k)
6559
6560
6561 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
6562 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
6563 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
6564 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
6565 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
6566 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
6567 tmp_lift = tmp1 + tmp2 + tmp3
6568
6569 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
6570 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
6571 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
6572 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
6573 + vec_in_z(i,j,v,5) * mat_tr(5,k)
6574 tmp2 = vec_in_z(i,j,v,6) * mat_tr(6,k) &
6575 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
6576 + vec_in_z(i,j,v,8) * mat_tr(8,k) &
6577 + vec_in_z(i,j,v,9) * mat_tr(9,k) &
6578 + vec_in_z(i,j,v,10) * mat_tr(10,k)
6579 tmp3 = vec_in_z(i,j,v,11) * mat_tr(11,k) &
6580 + vec_in_z(i,j,v,12) * mat_tr(12,k) &
6581 + vec_in_z(i,j,v,13) * mat_tr(13,k) &
6582 + vec_in_z(i,j,v,14) * mat_tr(14,k)
6583! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
6584 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
6585 end do
6586 end do
6587 end do
6588 end do
6589 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p13()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p13 | ( | real(rp), dimension(14,14), intent(in) | mat, |
| real(rp), dimension(14,14), intent(in) | mat_tr, | ||
| real(rp), dimension(14,14,14,6), intent(in) | lift, | ||
| real(rp), dimension(14,14,5,14,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(14,14,5,14,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(14,14,5,14,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(14,14,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | e11, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | e22, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | e33, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(14,14,5,14,ne), intent(inout) | div3d ) |
Definition at line 6592 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6596 implicit none
6597 real(RP), intent(in) :: Mat(14,14)
6598 real(RP), intent(in) :: Mat_tr(14,14)
6599 real(RP), intent(in) :: Lift(14,14,14,6)
6600 integer, intent(in) :: Ne
6601 real(RP), intent(in) :: vec_in_x(14,14,5,14,Ne)
6602 real(RP), intent(in) :: vec_in_y(14,14,5,14,Ne)
6603 real(RP), intent(in) :: vec_in_z(14,14,5,14,Ne)
6604 real(RP), intent(in) :: ebnd_flux(14,14,6,5,Ne)
6605 real(RP), intent(in) :: E11(14,14,14,Ne)
6606 real(RP), intent(in) :: E22(14,14,14,Ne)
6607 real(RP), intent(in) :: E33(14,14,14,Ne)
6608 real(RP), intent(in) :: Gsqrt(14,14,14,Ne)
6609 real(RP), intent(inout) :: div3D(14,14,5,14,Ne)
6610
6611 integer :: ke
6612 integer :: i, j, k, v
6613 real(RP) :: tmp1
6614 real(RP) :: tmp_lift
6615 real(RP) :: tmp2, tmp3
6616 real(RP) :: invG, e33_
6617 real(RP) :: div_x, div_xy
6618 !----------------------------------------------------------
6619
6620 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
6621 do ke=1, ne
6622 do k=1, 14
6623 do v=1, 5
6624 !$acc loop vector collapse(2)
6625 do j=1, 14
6626 do i=1, 14
6627 ! X-dir
6628 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
6629 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
6630 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
6631 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
6632 + mat(i,5) * vec_in_x(5,j,v,k,ke)
6633 tmp2 = mat(i,6) * vec_in_x(6,j,v,k,ke) &
6634 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
6635 + mat(i,8) * vec_in_x(8,j,v,k,ke) &
6636 + mat(i,9) * vec_in_x(9,j,v,k,ke) &
6637 + mat(i,10) * vec_in_x(10,j,v,k,ke)
6638 tmp3 = mat(i,11) * vec_in_x(11,j,v,k,ke) &
6639 + mat(i,12) * vec_in_x(12,j,v,k,ke) &
6640 + mat(i,13) * vec_in_x(13,j,v,k,ke) &
6641 + mat(i,14) * vec_in_x(14,j,v,k,ke)
6642 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
6643
6644 ! Y-dir
6645 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
6646 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
6647 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
6648 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
6649 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j)
6650 tmp2 = vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
6651 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
6652 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j) &
6653 + vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
6654 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j)
6655 tmp3 = vec_in_y(i,11,v,k,ke) * mat_tr(11,j) &
6656 + vec_in_y(i,12,v,k,ke) * mat_tr(12,j) &
6657 + vec_in_y(i,13,v,k,ke) * mat_tr(13,j) &
6658 + vec_in_y(i,14,v,k,ke) * mat_tr(14,j)
6659 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
6660
6661
6662 ! Z-dir
6663
6664 invg = 1.0_rp / gsqrt(i,j,k,ke)
6665 e33_ = e33(i,j,k,ke)
6666
6667
6668 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
6669 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
6670 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
6671 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
6672 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
6673 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
6674 tmp_lift = tmp1 + tmp2 + tmp3
6675
6676 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
6677 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
6678 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
6679 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
6680 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
6681 tmp2 = vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
6682 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
6683 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
6684 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
6685 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
6686 tmp3 = vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
6687 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
6688 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k) &
6689 + vec_in_z(i,j,v,14,ke) * mat_tr(14,k)
6690
6691 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
6692
6693 end do
6694 end do
6695 end do
6696 end do
6697 end do
6698 return
◆ element_operation_kernel_matvec_divlike_var5_p13_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p13_v2 | ( | real(rp), dimension(14,14), intent(in) | mat, |
| real(rp), dimension(14,14), intent(in) | mat_tr, | ||
| real(rp), dimension(14,14,14,6), intent(in) | lift, | ||
| real(rp), dimension(14,14,5,14,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(14,14,5,14,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(14,14,5,14,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(14,14,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | e11, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | e22, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | e33, | ||
| real(rp), dimension(14,14,14,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(14,14,5,14,ne), intent(inout) | div3d ) |
Definition at line 6701 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6705 implicit none
6706 real(RP), intent(in) :: Mat(14,14)
6707 real(RP), intent(in) :: Mat_tr(14,14)
6708 real(RP), intent(in) :: Lift(14,14,14,6)
6709 integer, intent(in) :: Ne
6710 real(RP), intent(in) :: vec_in_x(14,14,5,14,Ne)
6711 real(RP), intent(in) :: vec_in_y(14,14,5,14,Ne)
6712 real(RP), intent(in) :: vec_in_z(14,14,5,14,Ne)
6713 real(RP), intent(in) :: ebnd_flux(14,14,6,5,Ne)
6714 real(RP), intent(in) :: E11(14,14,14,Ne)
6715 real(RP), intent(in) :: E22(14,14,14,Ne)
6716 real(RP), intent(in) :: E33(14,14,14,Ne)
6717 real(RP), intent(in) :: Gsqrt(14,14,14,Ne)
6718 real(RP), intent(inout) :: div3D(14,14,5,14,Ne)
6719
6720 integer :: ke
6721 integer :: p, i, j, k, v, n
6722 real(RP) :: tmp1
6723 real(RP) :: tmp_lift
6724 real(RP) :: tmp2, tmp3
6725
6726 real(RP) :: invG, e33_
6727 real(RP) :: div_x, div_xy
6728
6729 real(RP) :: tmp_vec_in_y(14)
6730
6731 real(RP) :: s1, s2, s3, s4
6732 real(RP) :: e11_
6733 !----------------------------------------------------------
6734
6735 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
6736 do ke=1, ne
6737 do k=1, 14
6738 !$acc loop vector collapse(2)
6739 do j=1, 14
6740 do i=1, 14
6741 e11_ = e11(i,j,k,ke)
6742 ! X-dir
6743 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
6744
6745 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
6746 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
6747 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
6748 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
6749 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
6750 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
6751 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
6752 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
6753 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) &
6754 + mat_tr(11,i) * vec_in_x(11,j,1,k,ke) &
6755 + mat_tr(12,i) * vec_in_x(12,j,1,k,ke) &
6756 + mat_tr(13,i) * vec_in_x(13,j,1,k,ke) &
6757 + mat_tr(14,i) * vec_in_x(14,j,1,k,ke) )
6758 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
6759
6760 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
6761 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
6762 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
6763 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
6764 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
6765 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
6766 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
6767 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
6768 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) &
6769 + mat_tr(11,i) * vec_in_x(11,j,2,k,ke) &
6770 + mat_tr(12,i) * vec_in_x(12,j,2,k,ke) &
6771 + mat_tr(13,i) * vec_in_x(13,j,2,k,ke) &
6772 + mat_tr(14,i) * vec_in_x(14,j,2,k,ke) )
6773 div3d(i,j,1,k,ke) = s1 * e11_
6774 div3d(i,j,2,k,ke) = s2 * e11_
6775
6776 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
6777
6778 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
6779 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
6780 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
6781 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
6782 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
6783 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
6784 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
6785 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
6786 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) &
6787 + mat_tr(11,i) * vec_in_x(11,j,3,k,ke) &
6788 + mat_tr(12,i) * vec_in_x(12,j,3,k,ke) &
6789 + mat_tr(13,i) * vec_in_x(13,j,3,k,ke) &
6790 + mat_tr(14,i) * vec_in_x(14,j,3,k,ke) )
6791 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
6792
6793 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
6794 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
6795 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
6796 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
6797 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
6798 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
6799 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
6800 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
6801 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) &
6802 + mat_tr(11,i) * vec_in_x(11,j,4,k,ke) &
6803 + mat_tr(12,i) * vec_in_x(12,j,4,k,ke) &
6804 + mat_tr(13,i) * vec_in_x(13,j,4,k,ke) &
6805 + mat_tr(14,i) * vec_in_x(14,j,4,k,ke) )
6806 div3d(i,j,3,k,ke) = s1 * e11_
6807 div3d(i,j,4,k,ke) = s2 * e11_
6808
6809 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
6810
6811 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
6812 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
6813 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
6814 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
6815 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
6816 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
6817 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
6818 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
6819 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) &
6820 + mat_tr(11,i) * vec_in_x(11,j,5,k,ke) &
6821 + mat_tr(12,i) * vec_in_x(12,j,5,k,ke) &
6822 + mat_tr(13,i) * vec_in_x(13,j,5,k,ke) &
6823 + mat_tr(14,i) * vec_in_x(14,j,5,k,ke) )
6824 div3d(i,j,5,k,ke) = s1 * e11_
6825 end do
6826 end do
6827 end do
6828 end do
6829
6830 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
6831 do ke=1, ne
6832 do k=1, 14
6833 do v=1, 5
6834 !$acc loop vector collapse(2)
6835 do j=1, 14
6836 do i=1, 14
6837
6838 ! Y-dir
6839 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
6840
6841 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
6842 + tmp_vec_in_y(2) * mat_tr(2,j) &
6843 + tmp_vec_in_y(3) * mat_tr(3,j) &
6844 + tmp_vec_in_y(4) * mat_tr(4,j) &
6845 + tmp_vec_in_y(10) * mat_tr(10,j)
6846 tmp3 = tmp_vec_in_y(11) * mat_tr(11,j) &
6847 + tmp_vec_in_y(12) * mat_tr(12,j) &
6848 + tmp_vec_in_y(13) * mat_tr(13,j) &
6849 + tmp_vec_in_y(14) * mat_tr(14,j)
6850 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
6851 end do
6852 end do
6853 end do
6854 end do
6855 end do
6856
6857 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
6858 do ke=1, ne
6859 do k=1, 14
6860 do v=1, 5
6861 !$acc loop vector collapse(2)
6862 do j=1, 14
6863 do i=1, 14
6864
6865 invg = 1.0_rp / gsqrt(i,j,k,ke)
6866 e33_ = e33(i,j,k,ke)
6867
6868
6869 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
6870 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
6871 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
6872 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
6873 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
6874 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
6875 tmp_lift = tmp1 + tmp2 + tmp3
6876
6877 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
6878 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
6879 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
6880 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
6881 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
6882 tmp2 = vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
6883 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
6884 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
6885 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
6886 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
6887 tmp3 = vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
6888 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
6889 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k) &
6890 + vec_in_z(i,j,v,14,ke) * mat_tr(14,k)
6891! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
6892 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
6893
6894 end do
6895 end do
6896 end do
6897 end do
6898 end do
6899
6900 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p13()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(14,14,14,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(14,14,14,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=13.
Definition at line 6907 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
6910 implicit none
6911 integer, intent(in) :: Ne
6912 real(RP), intent(in) :: Mat_h1D(14,14)
6913 real(RP), intent(in) :: Mat_h1D_tr(14,14)
6914 real(RP), intent(in) :: Mat_v1D_tr(14,14)
6915 real(RP), intent(in) :: vec_in(14,14,14,Ne)
6916 real(RP), intent(out) :: vec_work(14,14,14,Ne)
6917 real(RP), intent(out) :: vec_out(14,14,14,Ne)
6918
6919 integer :: ke
6920 integer :: i, j, k
6921 real(RP) :: tmp1, tmp2, tmp3
6922 !----------------------------------------------------------
6923
6924 ! X-dir
6925 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
6926 do ke=1, ne
6927 do k=1, 14
6928 !$acc loop vector collapse(2)
6929 do j=1, 14
6930 do i=1, 14
6931 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
6932 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
6933 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
6934 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
6935 + mat_h1d(i,5) * vec_in(5,j,k,ke)
6936 tmp2 = mat_h1d(i,6) * vec_in(6,j,k,ke) &
6937 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
6938 + mat_h1d(i,8) * vec_in(8,j,k,ke) &
6939 + mat_h1d(i,9) * vec_in(9,j,k,ke) &
6940 + mat_h1d(i,10) * vec_in(10,j,k,ke)
6941 tmp3 = mat_h1d(i,11) * vec_in(11,j,k,ke) &
6942 + mat_h1d(i,12) * vec_in(12,j,k,ke) &
6943 + mat_h1d(i,13) * vec_in(13,j,k,ke) &
6944 + mat_h1d(i,14) * vec_in(14,j,k,ke)
6945 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
6946 end do
6947 end do
6948 end do
6949 end do
6950
6951 ! Y-dir
6952 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
6953 do ke=1, ne
6954 do k=1, 14
6955 !$acc loop vector collapse(2)
6956 do j=1, 14
6957 do i=1, 14
6958 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
6959 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
6960 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
6961 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
6962 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j)
6963 tmp2 = vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
6964 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
6965 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j) &
6966 + vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
6967 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j)
6968 tmp3 = vec_out(i,11,k,ke) * mat_h1d_tr(11,j) &
6969 + vec_out(i,12,k,ke) * mat_h1d_tr(12,j) &
6970 + vec_out(i,13,k,ke) * mat_h1d_tr(13,j) &
6971 + vec_out(i,14,k,ke) * mat_h1d_tr(14,j)
6972 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
6973 end do
6974 end do
6975 end do
6976 end do
6977
6978 ! Z-dir
6979 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
6980 do ke=1, ne
6981 do k=1, 14
6982 !$acc loop vector collapse(2)
6983 do j=1, 14
6984 do i=1, 14
6985 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
6986 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
6987 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
6988 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
6989 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k)
6990 tmp2 = vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
6991 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
6992 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k) &
6993 + vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
6994 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k)
6995 tmp3 = vec_work(i,j,11,ke) * mat_v1d_tr(11,k) &
6996 + vec_work(i,j,12,ke) * mat_v1d_tr(12,k) &
6997 + vec_work(i,j,13,ke) * mat_v1d_tr(13,k) &
6998 + vec_work(i,j,14,ke) * mat_v1d_tr(14,k)
6999 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
7000 end do
7001 end do
7002 end do
7003 end do
7004 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p14()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p14 | ( | real(rp), dimension(15,15), intent(in) | mat_z_tr, |
| real(rp), dimension(15**2,15,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(15**2,15,ne_out), 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 7013 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7014 implicit none
7015 integer, intent(in) :: Ne_in
7016 integer, intent(in) :: Ne_out
7017 real(RP), intent(in) :: Mat_z_tr(15,15)
7018 real(RP), intent(in) :: vec_in(15**2,15,Ne_in)
7019 real(RP), intent(out) :: vec_out(15**2,15,Ne_out)
7020
7021 integer :: ij, k, ke
7022 !----------------------------------------------------------
7023
7024 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
7025 do ke=1, ne_out
7026 do k=1, 15
7027 do ij=1, 15**2
7028 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
7029 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
7030 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
7031 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
7032 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
7033 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
7034 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
7035 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
7036 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
7037 + vec_in(ij,10,ke) * mat_z_tr(10,k) &
7038 + vec_in(ij,11,ke) * mat_z_tr(11,k) &
7039 + vec_in(ij,12,ke) * mat_z_tr(12,k) &
7040 + vec_in(ij,13,ke) * mat_z_tr(13,k) &
7041 + vec_in(ij,14,ke) * mat_z_tr(14,k) &
7042 + vec_in(ij,15,ke) * mat_z_tr(15,k)
7043 end do
7044 end do
7045 end do
7046
7047 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p14()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p14 | ( | real(rp), dimension(15,15), intent(in) | mat, |
| real(rp), dimension(15,15), intent(in) | mat_tr, | ||
| real(rp), dimension(15,15), intent(in) | vec_in_x, | ||
| real(rp), dimension(15,15), intent(in) | vec_in_y, | ||
| real(rp), dimension(15,15), intent(in) | e11, | ||
| real(rp), dimension(15,15), intent(in) | e22, | ||
| real(rp), dimension(15,15), intent(out) | div_out_xy ) |
Definition at line 7050 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7054 implicit none
7055 real(RP), intent(in) :: Mat(15,15)
7056 real(RP), intent(in) :: Mat_tr(15,15)
7057 real(RP), intent(in) :: vec_in_x(15,15)
7058 real(RP), intent(in) :: vec_in_y(15,15)
7059 real(RP), intent(in) :: E11(15,15)
7060 real(RP), intent(in) :: E22(15,15)
7061 real(RP), intent(out) :: div_out_xy(15,15)
7062
7063 integer :: i, j, jv, jk
7064 real(RP) :: tmp1, div_x
7065 real(RP) :: tmp2, tmp3
7066 !----------------------------------------------------------
7067 !$acc routine vector
7068
7069 !$acc loop vector collapse(2)
7070 do j=1, 15
7071 do i=1, 15
7072 ! X-dir
7073 tmp1 = mat(i,1) * vec_in_x(1,j) &
7074 + mat(i,2) * vec_in_x(2,j) &
7075 + mat(i,3) * vec_in_x(3,j) &
7076 + mat(i,4) * vec_in_x(4,j) &
7077 + mat(i,5) * vec_in_x(5,j)
7078 tmp2 = mat(i,6) * vec_in_x(6,j) &
7079 + mat(i,7) * vec_in_x(7,j) &
7080 + mat(i,8) * vec_in_x(8,j) &
7081 + mat(i,9) * vec_in_x(9,j) &
7082 + mat(i,10) * vec_in_x(10,j)
7083 tmp3 = mat(i,11) * vec_in_x(11,j) &
7084 + mat(i,12) * vec_in_x(12,j) &
7085 + mat(i,13) * vec_in_x(13,j) &
7086 + mat(i,14) * vec_in_x(14,j) &
7087 + mat(i,15) * vec_in_x(15,j)
7088 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
7089
7090 ! Y-dir
7091 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
7092 + vec_in_y(i,2) * mat_tr(2,j) &
7093 + vec_in_y(i,3) * mat_tr(3,j) &
7094 + vec_in_y(i,4) * mat_tr(4,j) &
7095 + vec_in_y(i,5) * mat_tr(5,j)
7096 tmp2 = vec_in_y(i,6) * mat_tr(6,j) &
7097 + vec_in_y(i,7) * mat_tr(7,j) &
7098 + vec_in_y(i,8) * mat_tr(8,j) &
7099 + vec_in_y(i,9) * mat_tr(9,j) &
7100 + vec_in_y(i,10) * mat_tr(10,j)
7101 tmp3 = vec_in_y(i,11) * mat_tr(11,j) &
7102 + vec_in_y(i,12) * mat_tr(12,j) &
7103 + vec_in_y(i,13) * mat_tr(13,j) &
7104 + vec_in_y(i,14) * mat_tr(14,j) &
7105 + vec_in_y(i,15) * mat_tr(15,j)
7106 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
7107 end do
7108 end do
7109 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p14()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p14 | ( | real(rp), dimension(15,15), intent(in) | mat, |
| real(rp), dimension(15,15), intent(in) | mat_tr, | ||
| real(rp), dimension(15,15,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(15,15,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(15,15), intent(in) | e11, | ||
| real(rp), dimension(15,15), intent(in) | e22, | ||
| real(rp), dimension(15,15,5), intent(out) | div_out_xy ) |
Definition at line 7112 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7116 implicit none
7117 real(RP), intent(in) :: Mat(15,15)
7118 real(RP), intent(in) :: Mat_tr(15,15)
7119 real(RP), intent(in) :: vec_in_x(15,15,5)
7120 real(RP), intent(in) :: vec_in_y(15,15,5)
7121 real(RP), intent(in) :: E11(15,15)
7122 real(RP), intent(in) :: E22(15,15)
7123 real(RP), intent(out) :: div_out_xy(15,15,5)
7124
7125 integer :: i, j, jv, jk, v, kv
7126 real(RP) :: tmp1, div_x
7127 real(RP) :: tmp2, tmp3
7128 !----------------------------------------------------------
7129 !$acc routine vector
7130
7131 do v=1, 5
7132 !$acc loop vector collapse(2)
7133 do j=1, 15
7134 do i=1, 15
7135 ! X-dir
7136 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
7137 + mat(i,2) * vec_in_x(2,j,v) &
7138 + mat(i,3) * vec_in_x(3,j,v) &
7139 + mat(i,4) * vec_in_x(4,j,v) &
7140 + mat(i,5) * vec_in_x(5,j,v)
7141 tmp2 = mat(i,6) * vec_in_x(6,j,v) &
7142 + mat(i,7) * vec_in_x(7,j,v) &
7143 + mat(i,8) * vec_in_x(8,j,v) &
7144 + mat(i,9) * vec_in_x(9,j,v) &
7145 + mat(i,10) * vec_in_x(10,j,v)
7146 tmp3 = mat(i,11) * vec_in_x(11,j,v) &
7147 + mat(i,12) * vec_in_x(12,j,v) &
7148 + mat(i,13) * vec_in_x(13,j,v) &
7149 + mat(i,14) * vec_in_x(14,j,v) &
7150 + mat(i,15) * vec_in_x(15,j,v)
7151 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
7152
7153 ! Y-dir
7154 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
7155 + vec_in_y(i,2,v) * mat_tr(2,j) &
7156 + vec_in_y(i,3,v) * mat_tr(3,j) &
7157 + vec_in_y(i,4,v) * mat_tr(4,j) &
7158 + vec_in_y(i,5,v) * mat_tr(5,j)
7159 tmp2 = vec_in_y(i,6,v) * mat_tr(6,j) &
7160 + vec_in_y(i,7,v) * mat_tr(7,j) &
7161 + vec_in_y(i,8,v) * mat_tr(8,j) &
7162 + vec_in_y(i,9,v) * mat_tr(9,j) &
7163 + vec_in_y(i,10,v) * mat_tr(10,j)
7164 tmp3 = vec_in_y(i,11,v) * mat_tr(11,j) &
7165 + vec_in_y(i,12,v) * mat_tr(12,j) &
7166 + vec_in_y(i,13,v) * mat_tr(13,j) &
7167 + vec_in_y(i,14,v) * mat_tr(14,j) &
7168 + vec_in_y(i,15,v) * mat_tr(15,j)
7169 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
7170 end do
7171 end do
7172 end do
7173 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p14()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p14 | ( | real(rp), dimension(15,15), intent(in) | mat_tr, |
| real(rp), dimension(15,15,15,6), intent(in) | lift, | ||
| real(rp), dimension(15,15,5,15), intent(in) | vec_in_z, | ||
| real(rp), dimension(15,15,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(15,15,15), intent(in) | e33, | ||
| real(rp), dimension(15,15,15), intent(in) | gsqrt, | ||
| real(rp), dimension(15,15,5,15), intent(inout) | div3d ) |
Definition at line 7176 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7179 implicit none
7180 real(RP), intent(in) :: Mat_tr(15,15)
7181 real(RP), intent(in) :: Lift(15,15,15,6)
7182 real(RP), intent(in) :: vec_in_z(15,15,5,15)
7183 real(RP), intent(in) :: ebnd_flux(15,15,6,5)
7184 real(RP), intent(in) :: E33(15,15,15)
7185 real(RP), intent(in) :: Gsqrt(15,15,15)
7186 real(RP), intent(inout) :: div3D(15,15,5,15)
7187
7188 integer :: i, j, k, v
7189 real(RP) :: tmp1
7190 real(RP) :: tmp_lift
7191 real(RP) :: tmp2, tmp3
7192 real(RP) :: invG, e33_
7193 !----------------------------------------------------------
7194
7195 !$acc routine vector
7196
7197 ! Z-dir
7198 do v=1, 5
7199 do k=1, 15
7200 !$acc loop vector collapse(2)
7201 do j=1, 15
7202 do i=1, 15
7203 invg = 1.0_rp / gsqrt(i,j,k)
7204 e33_ = e33(i,j,k)
7205
7206
7207 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
7208 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
7209 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
7210 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
7211 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
7212 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
7213 tmp_lift = tmp1 + tmp2 + tmp3
7214
7215 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
7216 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
7217 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
7218 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
7219 + vec_in_z(i,j,v,5) * mat_tr(5,k)
7220 tmp2 = vec_in_z(i,j,v,6) * mat_tr(6,k) &
7221 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
7222 + vec_in_z(i,j,v,8) * mat_tr(8,k) &
7223 + vec_in_z(i,j,v,9) * mat_tr(9,k) &
7224 + vec_in_z(i,j,v,10) * mat_tr(10,k)
7225 tmp3 = vec_in_z(i,j,v,11) * mat_tr(11,k) &
7226 + vec_in_z(i,j,v,12) * mat_tr(12,k) &
7227 + vec_in_z(i,j,v,13) * mat_tr(13,k) &
7228 + vec_in_z(i,j,v,14) * mat_tr(14,k) &
7229 + vec_in_z(i,j,v,15) * mat_tr(15,k)
7230! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
7231 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
7232 end do
7233 end do
7234 end do
7235 end do
7236 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p14()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p14 | ( | real(rp), dimension(15,15), intent(in) | mat, |
| real(rp), dimension(15,15), intent(in) | mat_tr, | ||
| real(rp), dimension(15,15,15,6), intent(in) | lift, | ||
| real(rp), dimension(15,15,5,15,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(15,15,5,15,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(15,15,5,15,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(15,15,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | e11, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | e22, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | e33, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(15,15,5,15,ne), intent(inout) | div3d ) |
Definition at line 7239 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7243 implicit none
7244 real(RP), intent(in) :: Mat(15,15)
7245 real(RP), intent(in) :: Mat_tr(15,15)
7246 real(RP), intent(in) :: Lift(15,15,15,6)
7247 integer, intent(in) :: Ne
7248 real(RP), intent(in) :: vec_in_x(15,15,5,15,Ne)
7249 real(RP), intent(in) :: vec_in_y(15,15,5,15,Ne)
7250 real(RP), intent(in) :: vec_in_z(15,15,5,15,Ne)
7251 real(RP), intent(in) :: ebnd_flux(15,15,6,5,Ne)
7252 real(RP), intent(in) :: E11(15,15,15,Ne)
7253 real(RP), intent(in) :: E22(15,15,15,Ne)
7254 real(RP), intent(in) :: E33(15,15,15,Ne)
7255 real(RP), intent(in) :: Gsqrt(15,15,15,Ne)
7256 real(RP), intent(inout) :: div3D(15,15,5,15,Ne)
7257
7258 integer :: ke
7259 integer :: i, j, k, v
7260 real(RP) :: tmp1
7261 real(RP) :: tmp_lift
7262 real(RP) :: tmp2, tmp3
7263 real(RP) :: invG, e33_
7264 real(RP) :: div_x, div_xy
7265 !----------------------------------------------------------
7266
7267 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
7268 do ke=1, ne
7269 do k=1, 15
7270 do v=1, 5
7271 !$acc loop vector collapse(2)
7272 do j=1, 15
7273 do i=1, 15
7274 ! X-dir
7275 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
7276 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
7277 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
7278 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
7279 + mat(i,5) * vec_in_x(5,j,v,k,ke)
7280 tmp2 = mat(i,6) * vec_in_x(6,j,v,k,ke) &
7281 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
7282 + mat(i,8) * vec_in_x(8,j,v,k,ke) &
7283 + mat(i,9) * vec_in_x(9,j,v,k,ke) &
7284 + mat(i,10) * vec_in_x(10,j,v,k,ke)
7285 tmp3 = mat(i,11) * vec_in_x(11,j,v,k,ke) &
7286 + mat(i,12) * vec_in_x(12,j,v,k,ke) &
7287 + mat(i,13) * vec_in_x(13,j,v,k,ke) &
7288 + mat(i,14) * vec_in_x(14,j,v,k,ke) &
7289 + mat(i,15) * vec_in_x(15,j,v,k,ke)
7290 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
7291
7292 ! Y-dir
7293 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
7294 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
7295 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
7296 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
7297 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j)
7298 tmp2 = vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
7299 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
7300 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j) &
7301 + vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
7302 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j)
7303 tmp3 = vec_in_y(i,11,v,k,ke) * mat_tr(11,j) &
7304 + vec_in_y(i,12,v,k,ke) * mat_tr(12,j) &
7305 + vec_in_y(i,13,v,k,ke) * mat_tr(13,j) &
7306 + vec_in_y(i,14,v,k,ke) * mat_tr(14,j) &
7307 + vec_in_y(i,15,v,k,ke) * mat_tr(15,j)
7308 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
7309
7310
7311 ! Z-dir
7312
7313 invg = 1.0_rp / gsqrt(i,j,k,ke)
7314 e33_ = e33(i,j,k,ke)
7315
7316
7317 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
7318 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
7319 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
7320 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
7321 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
7322 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
7323 tmp_lift = tmp1 + tmp2 + tmp3
7324
7325 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
7326 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
7327 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
7328 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
7329 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
7330 tmp2 = vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
7331 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
7332 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
7333 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
7334 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
7335 tmp3 = vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
7336 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
7337 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k) &
7338 + vec_in_z(i,j,v,14,ke) * mat_tr(14,k) &
7339 + vec_in_z(i,j,v,15,ke) * mat_tr(15,k)
7340
7341 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
7342
7343 end do
7344 end do
7345 end do
7346 end do
7347 end do
7348 return
◆ element_operation_kernel_matvec_divlike_var5_p14_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p14_v2 | ( | real(rp), dimension(15,15), intent(in) | mat, |
| real(rp), dimension(15,15), intent(in) | mat_tr, | ||
| real(rp), dimension(15,15,15,6), intent(in) | lift, | ||
| real(rp), dimension(15,15,5,15,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(15,15,5,15,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(15,15,5,15,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(15,15,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | e11, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | e22, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | e33, | ||
| real(rp), dimension(15,15,15,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(15,15,5,15,ne), intent(inout) | div3d ) |
Definition at line 7351 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7355 implicit none
7356 real(RP), intent(in) :: Mat(15,15)
7357 real(RP), intent(in) :: Mat_tr(15,15)
7358 real(RP), intent(in) :: Lift(15,15,15,6)
7359 integer, intent(in) :: Ne
7360 real(RP), intent(in) :: vec_in_x(15,15,5,15,Ne)
7361 real(RP), intent(in) :: vec_in_y(15,15,5,15,Ne)
7362 real(RP), intent(in) :: vec_in_z(15,15,5,15,Ne)
7363 real(RP), intent(in) :: ebnd_flux(15,15,6,5,Ne)
7364 real(RP), intent(in) :: E11(15,15,15,Ne)
7365 real(RP), intent(in) :: E22(15,15,15,Ne)
7366 real(RP), intent(in) :: E33(15,15,15,Ne)
7367 real(RP), intent(in) :: Gsqrt(15,15,15,Ne)
7368 real(RP), intent(inout) :: div3D(15,15,5,15,Ne)
7369
7370 integer :: ke
7371 integer :: p, i, j, k, v, n
7372 real(RP) :: tmp1
7373 real(RP) :: tmp_lift
7374 real(RP) :: tmp2, tmp3
7375
7376 real(RP) :: invG, e33_
7377 real(RP) :: div_x, div_xy
7378
7379 real(RP) :: tmp_vec_in_y(15)
7380
7381 real(RP) :: s1, s2, s3, s4
7382 real(RP) :: e11_
7383 !----------------------------------------------------------
7384
7385 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
7386 do ke=1, ne
7387 do k=1, 15
7388 !$acc loop vector collapse(2)
7389 do j=1, 15
7390 do i=1, 15
7391 e11_ = e11(i,j,k,ke)
7392 ! X-dir
7393 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
7394
7395 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
7396 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
7397 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
7398 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
7399 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
7400 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
7401 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
7402 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
7403 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) &
7404 + mat_tr(11,i) * vec_in_x(11,j,1,k,ke) &
7405 + mat_tr(12,i) * vec_in_x(12,j,1,k,ke) &
7406 + mat_tr(13,i) * vec_in_x(13,j,1,k,ke) &
7407 + mat_tr(14,i) * vec_in_x(14,j,1,k,ke) &
7408 + mat_tr(15,i) * vec_in_x(15,j,1,k,ke) )
7409 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
7410
7411 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
7412 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
7413 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
7414 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
7415 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
7416 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
7417 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
7418 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
7419 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) &
7420 + mat_tr(11,i) * vec_in_x(11,j,2,k,ke) &
7421 + mat_tr(12,i) * vec_in_x(12,j,2,k,ke) &
7422 + mat_tr(13,i) * vec_in_x(13,j,2,k,ke) &
7423 + mat_tr(14,i) * vec_in_x(14,j,2,k,ke) &
7424 + mat_tr(15,i) * vec_in_x(15,j,2,k,ke) )
7425 div3d(i,j,1,k,ke) = s1 * e11_
7426 div3d(i,j,2,k,ke) = s2 * e11_
7427
7428 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
7429
7430 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
7431 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
7432 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
7433 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
7434 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
7435 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
7436 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
7437 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
7438 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) &
7439 + mat_tr(11,i) * vec_in_x(11,j,3,k,ke) &
7440 + mat_tr(12,i) * vec_in_x(12,j,3,k,ke) &
7441 + mat_tr(13,i) * vec_in_x(13,j,3,k,ke) &
7442 + mat_tr(14,i) * vec_in_x(14,j,3,k,ke) &
7443 + mat_tr(15,i) * vec_in_x(15,j,3,k,ke) )
7444 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
7445
7446 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
7447 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
7448 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
7449 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
7450 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
7451 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
7452 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
7453 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
7454 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) &
7455 + mat_tr(11,i) * vec_in_x(11,j,4,k,ke) &
7456 + mat_tr(12,i) * vec_in_x(12,j,4,k,ke) &
7457 + mat_tr(13,i) * vec_in_x(13,j,4,k,ke) &
7458 + mat_tr(14,i) * vec_in_x(14,j,4,k,ke) &
7459 + mat_tr(15,i) * vec_in_x(15,j,4,k,ke) )
7460 div3d(i,j,3,k,ke) = s1 * e11_
7461 div3d(i,j,4,k,ke) = s2 * e11_
7462
7463 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
7464
7465 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
7466 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
7467 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
7468 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
7469 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
7470 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
7471 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
7472 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
7473 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) &
7474 + mat_tr(11,i) * vec_in_x(11,j,5,k,ke) &
7475 + mat_tr(12,i) * vec_in_x(12,j,5,k,ke) &
7476 + mat_tr(13,i) * vec_in_x(13,j,5,k,ke) &
7477 + mat_tr(14,i) * vec_in_x(14,j,5,k,ke) &
7478 + mat_tr(15,i) * vec_in_x(15,j,5,k,ke) )
7479 div3d(i,j,5,k,ke) = s1 * e11_
7480 end do
7481 end do
7482 end do
7483 end do
7484
7485 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
7486 do ke=1, ne
7487 do k=1, 15
7488 do v=1, 5
7489 !$acc loop vector collapse(2)
7490 do j=1, 15
7491 do i=1, 15
7492
7493 ! Y-dir
7494 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
7495
7496 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
7497 + tmp_vec_in_y(2) * mat_tr(2,j) &
7498 + tmp_vec_in_y(3) * mat_tr(3,j) &
7499 + tmp_vec_in_y(4) * mat_tr(4,j) &
7500 + tmp_vec_in_y(10) * mat_tr(10,j)
7501 tmp3 = tmp_vec_in_y(11) * mat_tr(11,j) &
7502 + tmp_vec_in_y(12) * mat_tr(12,j) &
7503 + tmp_vec_in_y(13) * mat_tr(13,j) &
7504 + tmp_vec_in_y(14) * mat_tr(14,j) &
7505 + tmp_vec_in_y(15) * mat_tr(15,j)
7506 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
7507 end do
7508 end do
7509 end do
7510 end do
7511 end do
7512
7513 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
7514 do ke=1, ne
7515 do k=1, 15
7516 do v=1, 5
7517 !$acc loop vector collapse(2)
7518 do j=1, 15
7519 do i=1, 15
7520
7521 invg = 1.0_rp / gsqrt(i,j,k,ke)
7522 e33_ = e33(i,j,k,ke)
7523
7524
7525 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
7526 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
7527 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
7528 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
7529 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
7530 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
7531 tmp_lift = tmp1 + tmp2 + tmp3
7532
7533 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
7534 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
7535 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
7536 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
7537 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
7538 tmp2 = vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
7539 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
7540 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
7541 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
7542 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
7543 tmp3 = vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
7544 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
7545 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k) &
7546 + vec_in_z(i,j,v,14,ke) * mat_tr(14,k) &
7547 + vec_in_z(i,j,v,15,ke) * mat_tr(15,k)
7548! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
7549 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
7550
7551 end do
7552 end do
7553 end do
7554 end do
7555 end do
7556
7557 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p14()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(15,15,15,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(15,15,15,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=14.
Definition at line 7564 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7567 implicit none
7568 integer, intent(in) :: Ne
7569 real(RP), intent(in) :: Mat_h1D(15,15)
7570 real(RP), intent(in) :: Mat_h1D_tr(15,15)
7571 real(RP), intent(in) :: Mat_v1D_tr(15,15)
7572 real(RP), intent(in) :: vec_in(15,15,15,Ne)
7573 real(RP), intent(out) :: vec_work(15,15,15,Ne)
7574 real(RP), intent(out) :: vec_out(15,15,15,Ne)
7575
7576 integer :: ke
7577 integer :: i, j, k
7578 real(RP) :: tmp1, tmp2, tmp3
7579 !----------------------------------------------------------
7580
7581 ! X-dir
7582 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
7583 do ke=1, ne
7584 do k=1, 15
7585 !$acc loop vector collapse(2)
7586 do j=1, 15
7587 do i=1, 15
7588 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
7589 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
7590 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
7591 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
7592 + mat_h1d(i,5) * vec_in(5,j,k,ke)
7593 tmp2 = mat_h1d(i,6) * vec_in(6,j,k,ke) &
7594 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
7595 + mat_h1d(i,8) * vec_in(8,j,k,ke) &
7596 + mat_h1d(i,9) * vec_in(9,j,k,ke) &
7597 + mat_h1d(i,10) * vec_in(10,j,k,ke)
7598 tmp3 = mat_h1d(i,11) * vec_in(11,j,k,ke) &
7599 + mat_h1d(i,12) * vec_in(12,j,k,ke) &
7600 + mat_h1d(i,13) * vec_in(13,j,k,ke) &
7601 + mat_h1d(i,14) * vec_in(14,j,k,ke) &
7602 + mat_h1d(i,15) * vec_in(15,j,k,ke)
7603 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
7604 end do
7605 end do
7606 end do
7607 end do
7608
7609 ! Y-dir
7610 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
7611 do ke=1, ne
7612 do k=1, 15
7613 !$acc loop vector collapse(2)
7614 do j=1, 15
7615 do i=1, 15
7616 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
7617 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
7618 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
7619 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
7620 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j)
7621 tmp2 = vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
7622 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
7623 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j) &
7624 + vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
7625 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j)
7626 tmp3 = vec_out(i,11,k,ke) * mat_h1d_tr(11,j) &
7627 + vec_out(i,12,k,ke) * mat_h1d_tr(12,j) &
7628 + vec_out(i,13,k,ke) * mat_h1d_tr(13,j) &
7629 + vec_out(i,14,k,ke) * mat_h1d_tr(14,j) &
7630 + vec_out(i,15,k,ke) * mat_h1d_tr(15,j)
7631 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
7632 end do
7633 end do
7634 end do
7635 end do
7636
7637 ! Z-dir
7638 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
7639 do ke=1, ne
7640 do k=1, 15
7641 !$acc loop vector collapse(2)
7642 do j=1, 15
7643 do i=1, 15
7644 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
7645 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
7646 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
7647 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
7648 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k)
7649 tmp2 = vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
7650 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
7651 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k) &
7652 + vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
7653 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k)
7654 tmp3 = vec_work(i,j,11,ke) * mat_v1d_tr(11,k) &
7655 + vec_work(i,j,12,ke) * mat_v1d_tr(12,k) &
7656 + vec_work(i,j,13,ke) * mat_v1d_tr(13,k) &
7657 + vec_work(i,j,14,ke) * mat_v1d_tr(14,k) &
7658 + vec_work(i,j,15,ke) * mat_v1d_tr(15,k)
7659 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
7660 end do
7661 end do
7662 end do
7663 end do
7664 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
◆ element_operation_kernel_matvec_dirz_p15()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_dirz_p15 | ( | real(rp), dimension(16,16), intent(in) | mat_z_tr, |
| real(rp), dimension(16**2,16,ne_in), intent(in) | vec_in, | ||
| integer, intent(in) | ne_in, | ||
| integer, intent(in) | ne_out, | ||
| real(rp), dimension(16**2,16,ne_out), 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 7673 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7674 implicit none
7675 integer, intent(in) :: Ne_in
7676 integer, intent(in) :: Ne_out
7677 real(RP), intent(in) :: Mat_z_tr(16,16)
7678 real(RP), intent(in) :: vec_in(16**2,16,Ne_in)
7679 real(RP), intent(out) :: vec_out(16**2,16,Ne_out)
7680
7681 integer :: ij, k, ke
7682 !----------------------------------------------------------
7683
7684 !$acc parallel loop gang collapse(2) present(Mat_z_tr,vec_in,vec_out) async(1)
7685 do ke=1, ne_out
7686 do k=1, 16
7687 do ij=1, 16**2
7688 vec_out(ij,k,ke) = vec_in(ij,1,ke) * mat_z_tr(1,k) &
7689 + vec_in(ij,2,ke) * mat_z_tr(2,k) &
7690 + vec_in(ij,3,ke) * mat_z_tr(3,k) &
7691 + vec_in(ij,4,ke) * mat_z_tr(4,k) &
7692 + vec_in(ij,5,ke) * mat_z_tr(5,k) &
7693 + vec_in(ij,6,ke) * mat_z_tr(6,k) &
7694 + vec_in(ij,7,ke) * mat_z_tr(7,k) &
7695 + vec_in(ij,8,ke) * mat_z_tr(8,k) &
7696 + vec_in(ij,9,ke) * mat_z_tr(9,k) &
7697 + vec_in(ij,10,ke) * mat_z_tr(10,k) &
7698 + vec_in(ij,11,ke) * mat_z_tr(11,k) &
7699 + vec_in(ij,12,ke) * mat_z_tr(12,k) &
7700 + vec_in(ij,13,ke) * mat_z_tr(13,k) &
7701 + vec_in(ij,14,ke) * mat_z_tr(14,k) &
7702 + vec_in(ij,15,ke) * mat_z_tr(15,k) &
7703 + vec_in(ij,16,ke) * mat_z_tr(16,k)
7704 end do
7705 end do
7706 end do
7707
7708 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_vfilterpm1().
◆ element_operation_kernel_matvec_divlike_dirxy_p15()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_p15 | ( | real(rp), dimension(16,16), intent(in) | mat, |
| real(rp), dimension(16,16), intent(in) | mat_tr, | ||
| real(rp), dimension(16,16), intent(in) | vec_in_x, | ||
| real(rp), dimension(16,16), intent(in) | vec_in_y, | ||
| real(rp), dimension(16,16), intent(in) | e11, | ||
| real(rp), dimension(16,16), intent(in) | e22, | ||
| real(rp), dimension(16,16), intent(out) | div_out_xy ) |
Definition at line 7711 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7715 implicit none
7716 real(RP), intent(in) :: Mat(16,16)
7717 real(RP), intent(in) :: Mat_tr(16,16)
7718 real(RP), intent(in) :: vec_in_x(16,16)
7719 real(RP), intent(in) :: vec_in_y(16,16)
7720 real(RP), intent(in) :: E11(16,16)
7721 real(RP), intent(in) :: E22(16,16)
7722 real(RP), intent(out) :: div_out_xy(16,16)
7723
7724 integer :: i, j, jv, jk
7725 real(RP) :: tmp1, div_x
7726 real(RP) :: tmp2, tmp3
7727 !----------------------------------------------------------
7728 !$acc routine vector
7729
7730 !$acc loop vector collapse(2)
7731 do j=1, 16
7732 do i=1, 16
7733 ! X-dir
7734 tmp1 = mat(i,1) * vec_in_x(1,j) &
7735 + mat(i,2) * vec_in_x(2,j) &
7736 + mat(i,3) * vec_in_x(3,j) &
7737 + mat(i,4) * vec_in_x(4,j) &
7738 + mat(i,5) * vec_in_x(5,j)
7739 tmp2 = mat(i,6) * vec_in_x(6,j) &
7740 + mat(i,7) * vec_in_x(7,j) &
7741 + mat(i,8) * vec_in_x(8,j) &
7742 + mat(i,9) * vec_in_x(9,j) &
7743 + mat(i,10) * vec_in_x(10,j)
7744 tmp3 = mat(i,11) * vec_in_x(11,j) &
7745 + mat(i,12) * vec_in_x(12,j) &
7746 + mat(i,13) * vec_in_x(13,j) &
7747 + mat(i,14) * vec_in_x(14,j) &
7748 + mat(i,15) * vec_in_x(15,j) &
7749 + mat(i,16) * vec_in_x(16,j)
7750 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
7751
7752 ! Y-dir
7753 tmp1 = vec_in_y(i,1) * mat_tr(1,j) &
7754 + vec_in_y(i,2) * mat_tr(2,j) &
7755 + vec_in_y(i,3) * mat_tr(3,j) &
7756 + vec_in_y(i,4) * mat_tr(4,j) &
7757 + vec_in_y(i,5) * mat_tr(5,j)
7758 tmp2 = vec_in_y(i,6) * mat_tr(6,j) &
7759 + vec_in_y(i,7) * mat_tr(7,j) &
7760 + vec_in_y(i,8) * mat_tr(8,j) &
7761 + vec_in_y(i,9) * mat_tr(9,j) &
7762 + vec_in_y(i,10) * mat_tr(10,j)
7763 tmp3 = vec_in_y(i,11) * mat_tr(11,j) &
7764 + vec_in_y(i,12) * mat_tr(12,j) &
7765 + vec_in_y(i,13) * mat_tr(13,j) &
7766 + vec_in_y(i,14) * mat_tr(14,j) &
7767 + vec_in_y(i,15) * mat_tr(15,j) &
7768 + vec_in_y(i,16) * mat_tr(16,j)
7769 div_out_xy(i,j) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
7770 end do
7771 end do
7772 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_div_kplane().
◆ element_operation_kernel_matvec_divlike_dirxy_var5_p15()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirxy_var5_p15 | ( | real(rp), dimension(16,16), intent(in) | mat, |
| real(rp), dimension(16,16), intent(in) | mat_tr, | ||
| real(rp), dimension(16,16,5), intent(in) | vec_in_x, | ||
| real(rp), dimension(16,16,5), intent(in) | vec_in_y, | ||
| real(rp), dimension(16,16), intent(in) | e11, | ||
| real(rp), dimension(16,16), intent(in) | e22, | ||
| real(rp), dimension(16,16,5), intent(out) | div_out_xy ) |
Definition at line 7775 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7779 implicit none
7780 real(RP), intent(in) :: Mat(16,16)
7781 real(RP), intent(in) :: Mat_tr(16,16)
7782 real(RP), intent(in) :: vec_in_x(16,16,5)
7783 real(RP), intent(in) :: vec_in_y(16,16,5)
7784 real(RP), intent(in) :: E11(16,16)
7785 real(RP), intent(in) :: E22(16,16)
7786 real(RP), intent(out) :: div_out_xy(16,16,5)
7787
7788 integer :: i, j, jv, jk, v, kv
7789 real(RP) :: tmp1, div_x
7790 real(RP) :: tmp2, tmp3
7791 !----------------------------------------------------------
7792 !$acc routine vector
7793
7794 do v=1, 5
7795 !$acc loop vector collapse(2)
7796 do j=1, 16
7797 do i=1, 16
7798 ! X-dir
7799 tmp1 = mat(i,1) * vec_in_x(1,j,v) &
7800 + mat(i,2) * vec_in_x(2,j,v) &
7801 + mat(i,3) * vec_in_x(3,j,v) &
7802 + mat(i,4) * vec_in_x(4,j,v) &
7803 + mat(i,5) * vec_in_x(5,j,v)
7804 tmp2 = mat(i,6) * vec_in_x(6,j,v) &
7805 + mat(i,7) * vec_in_x(7,j,v) &
7806 + mat(i,8) * vec_in_x(8,j,v) &
7807 + mat(i,9) * vec_in_x(9,j,v) &
7808 + mat(i,10) * vec_in_x(10,j,v)
7809 tmp3 = mat(i,11) * vec_in_x(11,j,v) &
7810 + mat(i,12) * vec_in_x(12,j,v) &
7811 + mat(i,13) * vec_in_x(13,j,v) &
7812 + mat(i,14) * vec_in_x(14,j,v) &
7813 + mat(i,15) * vec_in_x(15,j,v) &
7814 + mat(i,16) * vec_in_x(16,j,v)
7815 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j)
7816
7817 ! Y-dir
7818 tmp1 = vec_in_y(i,1,v) * mat_tr(1,j) &
7819 + vec_in_y(i,2,v) * mat_tr(2,j) &
7820 + vec_in_y(i,3,v) * mat_tr(3,j) &
7821 + vec_in_y(i,4,v) * mat_tr(4,j) &
7822 + vec_in_y(i,5,v) * mat_tr(5,j)
7823 tmp2 = vec_in_y(i,6,v) * mat_tr(6,j) &
7824 + vec_in_y(i,7,v) * mat_tr(7,j) &
7825 + vec_in_y(i,8,v) * mat_tr(8,j) &
7826 + vec_in_y(i,9,v) * mat_tr(9,j) &
7827 + vec_in_y(i,10,v) * mat_tr(10,j)
7828 tmp3 = vec_in_y(i,11,v) * mat_tr(11,j) &
7829 + vec_in_y(i,12,v) * mat_tr(12,j) &
7830 + vec_in_y(i,13,v) * mat_tr(13,j) &
7831 + vec_in_y(i,14,v) * mat_tr(14,j) &
7832 + vec_in_y(i,15,v) * mat_tr(15,j) &
7833 + vec_in_y(i,16,v) * mat_tr(16,j)
7834 div_out_xy(i,j,v) = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j)
7835 end do
7836 end do
7837 end do
7838 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane(), and scale_element_operation_gpu_driver::elementoperationgpu_divvar5_kplane2().
◆ element_operation_kernel_matvec_divlike_dirz_lift_var5_p15()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_dirz_lift_var5_p15 | ( | real(rp), dimension(16,16), intent(in) | mat_tr, |
| real(rp), dimension(16,16,16,6), intent(in) | lift, | ||
| real(rp), dimension(16,16,5,16), intent(in) | vec_in_z, | ||
| real(rp), dimension(16,16,6,5), intent(in) | ebnd_flux, | ||
| real(rp), dimension(16,16,16), intent(in) | e33, | ||
| real(rp), dimension(16,16,16), intent(in) | gsqrt, | ||
| real(rp), dimension(16,16,5,16), intent(inout) | div3d ) |
Definition at line 7841 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7844 implicit none
7845 real(RP), intent(in) :: Mat_tr(16,16)
7846 real(RP), intent(in) :: Lift(16,16,16,6)
7847 real(RP), intent(in) :: vec_in_z(16,16,5,16)
7848 real(RP), intent(in) :: ebnd_flux(16,16,6,5)
7849 real(RP), intent(in) :: E33(16,16,16)
7850 real(RP), intent(in) :: Gsqrt(16,16,16)
7851 real(RP), intent(inout) :: div3D(16,16,5,16)
7852
7853 integer :: i, j, k, v
7854 real(RP) :: tmp1
7855 real(RP) :: tmp_lift
7856 real(RP) :: tmp2, tmp3
7857 real(RP) :: invG, e33_
7858 !----------------------------------------------------------
7859
7860 !$acc routine vector
7861
7862 ! Z-dir
7863 do v=1, 5
7864 do k=1, 16
7865 !$acc loop vector collapse(2)
7866 do j=1, 16
7867 do i=1, 16
7868 invg = 1.0_rp / gsqrt(i,j,k)
7869 e33_ = e33(i,j,k)
7870
7871
7872 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v) &
7873 + lift(i,j,k,3) * ebnd_flux(i,k,3,v)
7874 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v) &
7875 + lift(i,j,k,4) * ebnd_flux(j,k,4,v)
7876 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v) &
7877 + lift(i,j,k,6) * ebnd_flux(i,j,6,v)
7878 tmp_lift = tmp1 + tmp2 + tmp3
7879
7880 tmp1 = vec_in_z(i,j,v,1) * mat_tr(1,k) &
7881 + vec_in_z(i,j,v,2) * mat_tr(2,k) &
7882 + vec_in_z(i,j,v,3) * mat_tr(3,k) &
7883 + vec_in_z(i,j,v,4) * mat_tr(4,k) &
7884 + vec_in_z(i,j,v,5) * mat_tr(5,k)
7885 tmp2 = vec_in_z(i,j,v,6) * mat_tr(6,k) &
7886 + vec_in_z(i,j,v,7) * mat_tr(7,k) &
7887 + vec_in_z(i,j,v,8) * mat_tr(8,k) &
7888 + vec_in_z(i,j,v,9) * mat_tr(9,k) &
7889 + vec_in_z(i,j,v,10) * mat_tr(10,k)
7890 tmp3 = vec_in_z(i,j,v,11) * mat_tr(11,k) &
7891 + vec_in_z(i,j,v,12) * mat_tr(12,k) &
7892 + vec_in_z(i,j,v,13) * mat_tr(13,k) &
7893 + vec_in_z(i,j,v,14) * mat_tr(14,k) &
7894 + vec_in_z(i,j,v,15) * mat_tr(15,k) &
7895 + vec_in_z(i,j,v,16) * mat_tr(16,k)
7896! div3D(i,j,v,k) = ( div3D(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * E33(i,j,k) ) / Gsqrt(i,j,k)
7897 div3d(i,j,v,k) = ( div3d(i,j,v,k) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
7898 end do
7899 end do
7900 end do
7901 end do
7902 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5_z_lift().
◆ element_operation_kernel_matvec_divlike_var5_p15()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p15 | ( | real(rp), dimension(16,16), intent(in) | mat, |
| real(rp), dimension(16,16), intent(in) | mat_tr, | ||
| real(rp), dimension(16,16,16,6), intent(in) | lift, | ||
| real(rp), dimension(16,16,5,16,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(16,16,5,16,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(16,16,5,16,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(16,16,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | e11, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | e22, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | e33, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(16,16,5,16,ne), intent(inout) | div3d ) |
Definition at line 7905 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
7909 implicit none
7910 real(RP), intent(in) :: Mat(16,16)
7911 real(RP), intent(in) :: Mat_tr(16,16)
7912 real(RP), intent(in) :: Lift(16,16,16,6)
7913 integer, intent(in) :: Ne
7914 real(RP), intent(in) :: vec_in_x(16,16,5,16,Ne)
7915 real(RP), intent(in) :: vec_in_y(16,16,5,16,Ne)
7916 real(RP), intent(in) :: vec_in_z(16,16,5,16,Ne)
7917 real(RP), intent(in) :: ebnd_flux(16,16,6,5,Ne)
7918 real(RP), intent(in) :: E11(16,16,16,Ne)
7919 real(RP), intent(in) :: E22(16,16,16,Ne)
7920 real(RP), intent(in) :: E33(16,16,16,Ne)
7921 real(RP), intent(in) :: Gsqrt(16,16,16,Ne)
7922 real(RP), intent(inout) :: div3D(16,16,5,16,Ne)
7923
7924 integer :: ke
7925 integer :: i, j, k, v
7926 real(RP) :: tmp1
7927 real(RP) :: tmp_lift
7928 real(RP) :: tmp2, tmp3
7929 real(RP) :: invG, e33_
7930 real(RP) :: div_x, div_xy
7931 !----------------------------------------------------------
7932
7933 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
7934 do ke=1, ne
7935 do k=1, 16
7936 do v=1, 5
7937 !$acc loop vector collapse(2)
7938 do j=1, 16
7939 do i=1, 16
7940 ! X-dir
7941 tmp1 = mat(i,1) * vec_in_x(1,j,v,k,ke) &
7942 + mat(i,2) * vec_in_x(2,j,v,k,ke) &
7943 + mat(i,3) * vec_in_x(3,j,v,k,ke) &
7944 + mat(i,4) * vec_in_x(4,j,v,k,ke) &
7945 + mat(i,5) * vec_in_x(5,j,v,k,ke)
7946 tmp2 = mat(i,6) * vec_in_x(6,j,v,k,ke) &
7947 + mat(i,7) * vec_in_x(7,j,v,k,ke) &
7948 + mat(i,8) * vec_in_x(8,j,v,k,ke) &
7949 + mat(i,9) * vec_in_x(9,j,v,k,ke) &
7950 + mat(i,10) * vec_in_x(10,j,v,k,ke)
7951 tmp3 = mat(i,11) * vec_in_x(11,j,v,k,ke) &
7952 + mat(i,12) * vec_in_x(12,j,v,k,ke) &
7953 + mat(i,13) * vec_in_x(13,j,v,k,ke) &
7954 + mat(i,14) * vec_in_x(14,j,v,k,ke) &
7955 + mat(i,15) * vec_in_x(15,j,v,k,ke) &
7956 + mat(i,16) * vec_in_x(16,j,v,k,ke)
7957 div_x = ( tmp1 + tmp2 + tmp3 ) * e11(i,j,k,ke)
7958
7959 ! Y-dir
7960 tmp1 = vec_in_y(i,1,v,k,ke) * mat_tr(1,j) &
7961 + vec_in_y(i,2,v,k,ke) * mat_tr(2,j) &
7962 + vec_in_y(i,3,v,k,ke) * mat_tr(3,j) &
7963 + vec_in_y(i,4,v,k,ke) * mat_tr(4,j) &
7964 + vec_in_y(i,5,v,k,ke) * mat_tr(5,j)
7965 tmp2 = vec_in_y(i,6,v,k,ke) * mat_tr(6,j) &
7966 + vec_in_y(i,7,v,k,ke) * mat_tr(7,j) &
7967 + vec_in_y(i,8,v,k,ke) * mat_tr(8,j) &
7968 + vec_in_y(i,9,v,k,ke) * mat_tr(9,j) &
7969 + vec_in_y(i,10,v,k,ke) * mat_tr(10,j)
7970 tmp3 = vec_in_y(i,11,v,k,ke) * mat_tr(11,j) &
7971 + vec_in_y(i,12,v,k,ke) * mat_tr(12,j) &
7972 + vec_in_y(i,13,v,k,ke) * mat_tr(13,j) &
7973 + vec_in_y(i,14,v,k,ke) * mat_tr(14,j) &
7974 + vec_in_y(i,15,v,k,ke) * mat_tr(15,j) &
7975 + vec_in_y(i,16,v,k,ke) * mat_tr(16,j)
7976 div_xy = div_x + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
7977
7978
7979 ! Z-dir
7980
7981 invg = 1.0_rp / gsqrt(i,j,k,ke)
7982 e33_ = e33(i,j,k,ke)
7983
7984
7985 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
7986 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
7987 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
7988 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
7989 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
7990 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
7991 tmp_lift = tmp1 + tmp2 + tmp3
7992
7993 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
7994 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
7995 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
7996 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
7997 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
7998 tmp2 = vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
7999 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
8000 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
8001 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
8002 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
8003 tmp3 = vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
8004 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
8005 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k) &
8006 + vec_in_z(i,j,v,14,ke) * mat_tr(14,k) &
8007 + vec_in_z(i,j,v,15,ke) * mat_tr(15,k) &
8008 + vec_in_z(i,j,v,16,ke) * mat_tr(16,k)
8009
8010 div3d(i,j,v,k,ke) = ( div_xy + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
8011
8012 end do
8013 end do
8014 end do
8015 end do
8016 end do
8017 return
◆ element_operation_kernel_matvec_divlike_var5_p15_v2()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::element_operation_kernel_matvec_divlike_var5_p15_v2 | ( | real(rp), dimension(16,16), intent(in) | mat, |
| real(rp), dimension(16,16), intent(in) | mat_tr, | ||
| real(rp), dimension(16,16,16,6), intent(in) | lift, | ||
| real(rp), dimension(16,16,5,16,ne), intent(in) | vec_in_x, | ||
| real(rp), dimension(16,16,5,16,ne), intent(in) | vec_in_y, | ||
| real(rp), dimension(16,16,5,16,ne), intent(in) | vec_in_z, | ||
| real(rp), dimension(16,16,6,5,ne), intent(in) | ebnd_flux, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | e11, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | e22, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | e33, | ||
| real(rp), dimension(16,16,16,ne), intent(in) | gsqrt, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(16,16,5,16,ne), intent(inout) | div3d ) |
Definition at line 8020 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
8024 implicit none
8025 real(RP), intent(in) :: Mat(16,16)
8026 real(RP), intent(in) :: Mat_tr(16,16)
8027 real(RP), intent(in) :: Lift(16,16,16,6)
8028 integer, intent(in) :: Ne
8029 real(RP), intent(in) :: vec_in_x(16,16,5,16,Ne)
8030 real(RP), intent(in) :: vec_in_y(16,16,5,16,Ne)
8031 real(RP), intent(in) :: vec_in_z(16,16,5,16,Ne)
8032 real(RP), intent(in) :: ebnd_flux(16,16,6,5,Ne)
8033 real(RP), intent(in) :: E11(16,16,16,Ne)
8034 real(RP), intent(in) :: E22(16,16,16,Ne)
8035 real(RP), intent(in) :: E33(16,16,16,Ne)
8036 real(RP), intent(in) :: Gsqrt(16,16,16,Ne)
8037 real(RP), intent(inout) :: div3D(16,16,5,16,Ne)
8038
8039 integer :: ke
8040 integer :: p, i, j, k, v, n
8041 real(RP) :: tmp1
8042 real(RP) :: tmp_lift
8043 real(RP) :: tmp2, tmp3
8044
8045 real(RP) :: invG, e33_
8046 real(RP) :: div_x, div_xy
8047
8048 real(RP) :: tmp_vec_in_y(16)
8049
8050 real(RP) :: s1, s2, s3, s4
8051 real(RP) :: e11_
8052 !----------------------------------------------------------
8053
8054 !$acc parallel loop gang collapse(2) present(Mat,vec_in_x,E11,div3D) async(1)
8055 do ke=1, ne
8056 do k=1, 16
8057 !$acc loop vector collapse(2)
8058 do j=1, 16
8059 do i=1, 16
8060 e11_ = e11(i,j,k,ke)
8061 ! X-dir
8062 s1 = ( mat_tr(1,i) * vec_in_x(1,j,1,k,ke) &
8063
8064 + mat_tr(2,i) * vec_in_x(2,j,1,k,ke) &
8065 + mat_tr(3,i) * vec_in_x(3,j,1,k,ke) &
8066 + mat_tr(4,i) * vec_in_x(4,j,1,k,ke) &
8067 + mat_tr(5,i) * vec_in_x(5,j,1,k,ke) &
8068 + mat_tr(6,i) * vec_in_x(6,j,1,k,ke) &
8069 + mat_tr(7,i) * vec_in_x(7,j,1,k,ke) &
8070 + mat_tr(8,i) * vec_in_x(8,j,1,k,ke) &
8071 + mat_tr(9,i) * vec_in_x(9,j,1,k,ke) &
8072 + mat_tr(10,i) * vec_in_x(10,j,1,k,ke) &
8073 + mat_tr(11,i) * vec_in_x(11,j,1,k,ke) &
8074 + mat_tr(12,i) * vec_in_x(12,j,1,k,ke) &
8075 + mat_tr(13,i) * vec_in_x(13,j,1,k,ke) &
8076 + mat_tr(14,i) * vec_in_x(14,j,1,k,ke) &
8077 + mat_tr(15,i) * vec_in_x(15,j,1,k,ke) &
8078 + mat_tr(16,i) * vec_in_x(16,j,1,k,ke) )
8079 s2 = ( mat_tr(1,i) * vec_in_x(1,j,2,k,ke) &
8080
8081 + mat_tr(2,i) * vec_in_x(2,j,2,k,ke) &
8082 + mat_tr(3,i) * vec_in_x(3,j,2,k,ke) &
8083 + mat_tr(4,i) * vec_in_x(4,j,2,k,ke) &
8084 + mat_tr(5,i) * vec_in_x(5,j,2,k,ke) &
8085 + mat_tr(6,i) * vec_in_x(6,j,2,k,ke) &
8086 + mat_tr(7,i) * vec_in_x(7,j,2,k,ke) &
8087 + mat_tr(8,i) * vec_in_x(8,j,2,k,ke) &
8088 + mat_tr(9,i) * vec_in_x(9,j,2,k,ke) &
8089 + mat_tr(10,i) * vec_in_x(10,j,2,k,ke) &
8090 + mat_tr(11,i) * vec_in_x(11,j,2,k,ke) &
8091 + mat_tr(12,i) * vec_in_x(12,j,2,k,ke) &
8092 + mat_tr(13,i) * vec_in_x(13,j,2,k,ke) &
8093 + mat_tr(14,i) * vec_in_x(14,j,2,k,ke) &
8094 + mat_tr(15,i) * vec_in_x(15,j,2,k,ke) &
8095 + mat_tr(16,i) * vec_in_x(16,j,2,k,ke) )
8096 div3d(i,j,1,k,ke) = s1 * e11_
8097 div3d(i,j,2,k,ke) = s2 * e11_
8098
8099 s1 = ( mat_tr(1,i) * vec_in_x(1,j,3,k,ke) &
8100
8101 + mat_tr(2,i) * vec_in_x(2,j,3,k,ke) &
8102 + mat_tr(3,i) * vec_in_x(3,j,3,k,ke) &
8103 + mat_tr(4,i) * vec_in_x(4,j,3,k,ke) &
8104 + mat_tr(5,i) * vec_in_x(5,j,3,k,ke) &
8105 + mat_tr(6,i) * vec_in_x(6,j,3,k,ke) &
8106 + mat_tr(7,i) * vec_in_x(7,j,3,k,ke) &
8107 + mat_tr(8,i) * vec_in_x(8,j,3,k,ke) &
8108 + mat_tr(9,i) * vec_in_x(9,j,3,k,ke) &
8109 + mat_tr(10,i) * vec_in_x(10,j,3,k,ke) &
8110 + mat_tr(11,i) * vec_in_x(11,j,3,k,ke) &
8111 + mat_tr(12,i) * vec_in_x(12,j,3,k,ke) &
8112 + mat_tr(13,i) * vec_in_x(13,j,3,k,ke) &
8113 + mat_tr(14,i) * vec_in_x(14,j,3,k,ke) &
8114 + mat_tr(15,i) * vec_in_x(15,j,3,k,ke) &
8115 + mat_tr(16,i) * vec_in_x(16,j,3,k,ke) )
8116 s2 = ( mat_tr(1,i) * vec_in_x(1,j,4,k,ke) &
8117
8118 + mat_tr(2,i) * vec_in_x(2,j,4,k,ke) &
8119 + mat_tr(3,i) * vec_in_x(3,j,4,k,ke) &
8120 + mat_tr(4,i) * vec_in_x(4,j,4,k,ke) &
8121 + mat_tr(5,i) * vec_in_x(5,j,4,k,ke) &
8122 + mat_tr(6,i) * vec_in_x(6,j,4,k,ke) &
8123 + mat_tr(7,i) * vec_in_x(7,j,4,k,ke) &
8124 + mat_tr(8,i) * vec_in_x(8,j,4,k,ke) &
8125 + mat_tr(9,i) * vec_in_x(9,j,4,k,ke) &
8126 + mat_tr(10,i) * vec_in_x(10,j,4,k,ke) &
8127 + mat_tr(11,i) * vec_in_x(11,j,4,k,ke) &
8128 + mat_tr(12,i) * vec_in_x(12,j,4,k,ke) &
8129 + mat_tr(13,i) * vec_in_x(13,j,4,k,ke) &
8130 + mat_tr(14,i) * vec_in_x(14,j,4,k,ke) &
8131 + mat_tr(15,i) * vec_in_x(15,j,4,k,ke) &
8132 + mat_tr(16,i) * vec_in_x(16,j,4,k,ke) )
8133 div3d(i,j,3,k,ke) = s1 * e11_
8134 div3d(i,j,4,k,ke) = s2 * e11_
8135
8136 s1 = ( mat_tr(1,i) * vec_in_x(1,j,5,k,ke) &
8137
8138 + mat_tr(2,i) * vec_in_x(2,j,5,k,ke) &
8139 + mat_tr(3,i) * vec_in_x(3,j,5,k,ke) &
8140 + mat_tr(4,i) * vec_in_x(4,j,5,k,ke) &
8141 + mat_tr(5,i) * vec_in_x(5,j,5,k,ke) &
8142 + mat_tr(6,i) * vec_in_x(6,j,5,k,ke) &
8143 + mat_tr(7,i) * vec_in_x(7,j,5,k,ke) &
8144 + mat_tr(8,i) * vec_in_x(8,j,5,k,ke) &
8145 + mat_tr(9,i) * vec_in_x(9,j,5,k,ke) &
8146 + mat_tr(10,i) * vec_in_x(10,j,5,k,ke) &
8147 + mat_tr(11,i) * vec_in_x(11,j,5,k,ke) &
8148 + mat_tr(12,i) * vec_in_x(12,j,5,k,ke) &
8149 + mat_tr(13,i) * vec_in_x(13,j,5,k,ke) &
8150 + mat_tr(14,i) * vec_in_x(14,j,5,k,ke) &
8151 + mat_tr(15,i) * vec_in_x(15,j,5,k,ke) &
8152 + mat_tr(16,i) * vec_in_x(16,j,5,k,ke) )
8153 div3d(i,j,5,k,ke) = s1 * e11_
8154 end do
8155 end do
8156 end do
8157 end do
8158
8159 !$acc parallel loop gang collapse(2) private(tmp_vec_in_y)present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
8160 do ke=1, ne
8161 do k=1, 16
8162 do v=1, 5
8163 !$acc loop vector collapse(2)
8164 do j=1, 16
8165 do i=1, 16
8166
8167 ! Y-dir
8168 tmp_vec_in_y(:) = vec_in_y(i,:,v,k,ke)
8169
8170 tmp1 = tmp_vec_in_y(1) * mat_tr(1,j) &
8171 + tmp_vec_in_y(2) * mat_tr(2,j) &
8172 + tmp_vec_in_y(3) * mat_tr(3,j) &
8173 + tmp_vec_in_y(4) * mat_tr(4,j) &
8174 + tmp_vec_in_y(10) * mat_tr(10,j)
8175 tmp3 = tmp_vec_in_y(11) * mat_tr(11,j) &
8176 + tmp_vec_in_y(12) * mat_tr(12,j) &
8177 + tmp_vec_in_y(13) * mat_tr(13,j) &
8178 + tmp_vec_in_y(14) * mat_tr(14,j) &
8179 + tmp_vec_in_y(15) * mat_tr(15,j) &
8180 + tmp_vec_in_y(16) * mat_tr(16,j)
8181 div3d(i,j,v,k,ke) = div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e22(i,j,k,ke)
8182 end do
8183 end do
8184 end do
8185 end do
8186 end do
8187
8188 !$acc parallel loop gang collapse(2) present(Mat,Mat_tr,vec_in_x,vec_in_y,vec_in_z,Lift,ebnd_flux,E11,E22,E33,Gsqrt,div3D) async(1)
8189 do ke=1, ne
8190 do k=1, 16
8191 do v=1, 5
8192 !$acc loop vector collapse(2)
8193 do j=1, 16
8194 do i=1, 16
8195
8196 invg = 1.0_rp / gsqrt(i,j,k,ke)
8197 e33_ = e33(i,j,k,ke)
8198
8199
8200 tmp1 = lift(i,j,k,1) * ebnd_flux(i,k,1,v,ke) &
8201 + lift(i,j,k,3) * ebnd_flux(i,k,3,v,ke)
8202 tmp2 = lift(i,j,k,2) * ebnd_flux(j,k,2,v,ke) &
8203 + lift(i,j,k,4) * ebnd_flux(j,k,4,v,ke)
8204 tmp3 = lift(i,j,k,5) * ebnd_flux(i,j,5,v,ke) &
8205 + lift(i,j,k,6) * ebnd_flux(i,j,6,v,ke)
8206 tmp_lift = tmp1 + tmp2 + tmp3
8207
8208 tmp1 = vec_in_z(i,j,v,1,ke) * mat_tr(1,k) &
8209 + vec_in_z(i,j,v,2,ke) * mat_tr(2,k) &
8210 + vec_in_z(i,j,v,3,ke) * mat_tr(3,k) &
8211 + vec_in_z(i,j,v,4,ke) * mat_tr(4,k) &
8212 + vec_in_z(i,j,v,5,ke) * mat_tr(5,k)
8213 tmp2 = vec_in_z(i,j,v,6,ke) * mat_tr(6,k) &
8214 + vec_in_z(i,j,v,7,ke) * mat_tr(7,k) &
8215 + vec_in_z(i,j,v,8,ke) * mat_tr(8,k) &
8216 + vec_in_z(i,j,v,9,ke) * mat_tr(9,k) &
8217 + vec_in_z(i,j,v,10,ke) * mat_tr(10,k)
8218 tmp3 = vec_in_z(i,j,v,11,ke) * mat_tr(11,k) &
8219 + vec_in_z(i,j,v,12,ke) * mat_tr(12,k) &
8220 + vec_in_z(i,j,v,13,ke) * mat_tr(13,k) &
8221 + vec_in_z(i,j,v,14,ke) * mat_tr(14,k) &
8222 + vec_in_z(i,j,v,15,ke) * mat_tr(15,k) &
8223 + vec_in_z(i,j,v,16,ke) * mat_tr(16,k)
8224! div3D(i,j,v,k,ke) = ( div3D(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invG
8225 div3d(i,j,v,k,ke) = ( div3d(i,j,v,k,ke) + ( tmp1 + tmp2 + tmp3 ) * e33_ + tmp_lift ) * invg
8226
8227 end do
8228 end do
8229 end do
8230 end do
8231 end do
8232
8233 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_divvar5().
◆ element_operation_kernel_matvec_modalfilter_p15()
| subroutine, public scale_element_operation_tensorprod3d_kernel_gpu::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,ne), intent(in) | vec_in, | ||
| real(rp), dimension(16,16,16,ne), intent(out) | vec_work, | ||
| integer, intent(in) | ne, | ||
| real(rp), dimension(16,16,16,ne), intent(out) | vec_out ) |
Calculate a matrix-vector multiplication associated with 3D modal filtering with p=15.
Definition at line 8240 of file scale_element_operation_tensorprod3D_kernel_gpu.F90.
8243 implicit none
8244 integer, intent(in) :: Ne
8245 real(RP), intent(in) :: Mat_h1D(16,16)
8246 real(RP), intent(in) :: Mat_h1D_tr(16,16)
8247 real(RP), intent(in) :: Mat_v1D_tr(16,16)
8248 real(RP), intent(in) :: vec_in(16,16,16,Ne)
8249 real(RP), intent(out) :: vec_work(16,16,16,Ne)
8250 real(RP), intent(out) :: vec_out(16,16,16,Ne)
8251
8252 integer :: ke
8253 integer :: i, j, k
8254 real(RP) :: tmp1, tmp2, tmp3
8255 !----------------------------------------------------------
8256
8257 ! X-dir
8258 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
8259 do ke=1, ne
8260 do k=1, 16
8261 !$acc loop vector collapse(2)
8262 do j=1, 16
8263 do i=1, 16
8264 tmp1 = mat_h1d(i,1) * vec_in(1,j,k,ke) &
8265 + mat_h1d(i,2) * vec_in(2,j,k,ke) &
8266 + mat_h1d(i,3) * vec_in(3,j,k,ke) &
8267 + mat_h1d(i,4) * vec_in(4,j,k,ke) &
8268 + mat_h1d(i,5) * vec_in(5,j,k,ke)
8269 tmp2 = mat_h1d(i,6) * vec_in(6,j,k,ke) &
8270 + mat_h1d(i,7) * vec_in(7,j,k,ke) &
8271 + mat_h1d(i,8) * vec_in(8,j,k,ke) &
8272 + mat_h1d(i,9) * vec_in(9,j,k,ke) &
8273 + mat_h1d(i,10) * vec_in(10,j,k,ke)
8274 tmp3 = mat_h1d(i,11) * vec_in(11,j,k,ke) &
8275 + mat_h1d(i,12) * vec_in(12,j,k,ke) &
8276 + mat_h1d(i,13) * vec_in(13,j,k,ke) &
8277 + mat_h1d(i,14) * vec_in(14,j,k,ke) &
8278 + mat_h1d(i,15) * vec_in(15,j,k,ke) &
8279 + mat_h1d(i,16) * vec_in(16,j,k,ke)
8280 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
8281 end do
8282 end do
8283 end do
8284 end do
8285
8286 ! Y-dir
8287 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
8288 do ke=1, ne
8289 do k=1, 16
8290 !$acc loop vector collapse(2)
8291 do j=1, 16
8292 do i=1, 16
8293 tmp1 = vec_out(i,1,k,ke) * mat_h1d_tr(1,j) &
8294 + vec_out(i,2,k,ke) * mat_h1d_tr(2,j) &
8295 + vec_out(i,3,k,ke) * mat_h1d_tr(3,j) &
8296 + vec_out(i,4,k,ke) * mat_h1d_tr(4,j) &
8297 + vec_out(i,5,k,ke) * mat_h1d_tr(5,j)
8298 tmp2 = vec_out(i,6,k,ke) * mat_h1d_tr(6,j) &
8299 + vec_out(i,7,k,ke) * mat_h1d_tr(7,j) &
8300 + vec_out(i,8,k,ke) * mat_h1d_tr(8,j) &
8301 + vec_out(i,9,k,ke) * mat_h1d_tr(9,j) &
8302 + vec_out(i,10,k,ke) * mat_h1d_tr(10,j)
8303 tmp3 = vec_out(i,11,k,ke) * mat_h1d_tr(11,j) &
8304 + vec_out(i,12,k,ke) * mat_h1d_tr(12,j) &
8305 + vec_out(i,13,k,ke) * mat_h1d_tr(13,j) &
8306 + vec_out(i,14,k,ke) * mat_h1d_tr(14,j) &
8307 + vec_out(i,15,k,ke) * mat_h1d_tr(15,j) &
8308 + vec_out(i,16,k,ke) * mat_h1d_tr(16,j)
8309 vec_work(i,j,k,ke) = tmp1 + tmp2 + tmp3
8310 end do
8311 end do
8312 end do
8313 end do
8314
8315 ! Z-dir
8316 !$acc parallel loop gang collapse(2) present(Mat_h1D,Mat_h1D_tr,Mat_v1D_tr,vec_in,vec_work,vec_out) async(1)
8317 do ke=1, ne
8318 do k=1, 16
8319 !$acc loop vector collapse(2)
8320 do j=1, 16
8321 do i=1, 16
8322 tmp1 = vec_work(i,j,1,ke) * mat_v1d_tr(1,k) &
8323 + vec_work(i,j,2,ke) * mat_v1d_tr(2,k) &
8324 + vec_work(i,j,3,ke) * mat_v1d_tr(3,k) &
8325 + vec_work(i,j,4,ke) * mat_v1d_tr(4,k) &
8326 + vec_work(i,j,5,ke) * mat_v1d_tr(5,k)
8327 tmp2 = vec_work(i,j,6,ke) * mat_v1d_tr(6,k) &
8328 + vec_work(i,j,7,ke) * mat_v1d_tr(7,k) &
8329 + vec_work(i,j,8,ke) * mat_v1d_tr(8,k) &
8330 + vec_work(i,j,9,ke) * mat_v1d_tr(9,k) &
8331 + vec_work(i,j,10,ke) * mat_v1d_tr(10,k)
8332 tmp3 = vec_work(i,j,11,ke) * mat_v1d_tr(11,k) &
8333 + vec_work(i,j,12,ke) * mat_v1d_tr(12,k) &
8334 + vec_work(i,j,13,ke) * mat_v1d_tr(13,k) &
8335 + vec_work(i,j,14,ke) * mat_v1d_tr(14,k) &
8336 + vec_work(i,j,15,ke) * mat_v1d_tr(15,k) &
8337 + vec_work(i,j,16,ke) * mat_v1d_tr(16,k)
8338 vec_out(i,j,k,ke) = tmp1 + tmp2 + tmp3
8339 end do
8340 end do
8341 end do
8342 end do
8343 return
Referenced by scale_element_operation_gpu_driver::elementoperationgpu_modalfilter_var5().
Generated by
1.14.0