1 #ifndef __CS_CONVECTION_DIFFUSION_H__ 2 #define __CS_CONVECTION_DIFFUSION_H__ 114 cs_get_v_slope_test(
int f_id,
117 const int iconvp = var_cal_opt.
iconv;
118 const int isstpp = var_cal_opt.
isstpc;
119 const double blencp = var_cal_opt.
blencv;
123 if (f_id > -1 && iconvp > 0 && blencp > 0. && isstpp == 0) {
125 static int _k_slope_test_f_id = -1;
129 int f_track_slope_test_id = -1;
131 if (_k_slope_test_f_id < 0)
133 if (_k_slope_test_f_id > -1 && isstpp == 0)
136 if (f_track_slope_test_id > -1)
139 if (v_slope_test != NULL) {
141 # pragma omp parallel for 142 for (
cs_lnum_t cell_id = 0; cell_id < n_cells_ext; cell_id++)
143 v_slope_test[cell_id] = 0.;
162 cs_cell_courant_number(
const int f_id,
197 # pragma omp parallel for 198 for (
cs_lnum_t ii = 0; ii < n_cells_ext; ii++) {
206 for (
int g_id = 0; g_id < n_i_groups; g_id++) {
207 # pragma omp parallel for 208 for (
int t_id = 0; t_id < n_i_threads; t_id++) {
209 for (
cs_lnum_t face_id = i_group_index[(t_id*n_i_groups + g_id)*2];
210 face_id < i_group_index[(t_id*n_i_groups + g_id)*2 + 1];
215 cnt =
CS_ABS(i_massflux[face_id])*dt[ii]/vol[ii];
216 courant[ii] =
CS_MAX(courant[ii], cnt);
218 cnt =
CS_ABS(i_massflux[face_id])*dt[jj]/vol[jj];
219 courant[jj] =
CS_MAX(courant[jj], cnt);
226 for (
int g_id = 0; g_id < n_b_groups; g_id++) {
227 # pragma omp parallel for 228 for (
int t_id = 0; t_id < n_b_threads; t_id++) {
229 for (
cs_lnum_t face_id = b_group_index[(t_id*n_b_groups + g_id)*2];
230 face_id < b_group_index[(t_id*n_b_groups + g_id)*2 + 1];
234 cnt =
CS_ABS(b_massflux[face_id])*dt[ii]/vol[ii];
235 courant[ii] =
CS_MAX(courant[ii], cnt);
267 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
269 if (nvf_p_c < beta_m) {
270 nvf_p_f = nvf_p_c*(1.+rfc*(1.-nvf_p_c)/beta_m);
272 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
274 nvf_p_f = r1f*nvf_p_c+rfc;
280 if (nvf_p_c < (nvf_r_c/3.)) {
281 r1 = nvf_r_f*(1.-3.*nvf_r_c+2.*nvf_r_f);
282 r2 = nvf_r_c*(1.-nvf_r_c);
284 nvf_p_f = nvf_p_c*r1/r2;
285 }
else if (nvf_p_c <= (nvf_r_c*(1.+nvf_r_f-nvf_r_c)/nvf_r_f)) {
286 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
287 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
289 nvf_p_f = nvf_r_f*(r1f*nvf_p_c/nvf_r_c + rfc);
297 if (nvf_p_c < (3.*nvf_r_c/4.)) {
298 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
300 nvf_p_f = nvf_r_f*(1.+rfc/3.)*nvf_p_c/nvf_r_c;
301 }
else if (nvf_p_c <= (nvf_r_c*(1.+2.*(nvf_r_f-nvf_r_c))/(2.*nvf_r_f-nvf_r_c))) {
302 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
303 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
305 nvf_p_f = nvf_r_f*(r1f*nvf_p_c/nvf_r_c+rfc);
307 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
309 nvf_p_f = 1.-.5*r1f*(1.-nvf_p_c);
315 if (nvf_p_c < (nvf_r_c/(2.-nvf_r_c))) {
316 nvf_p_f = (2.*nvf_r_f-nvf_r_c)*nvf_p_c/nvf_r_c;
317 }
else if (nvf_p_c < nvf_r_c) {
318 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
319 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
321 nvf_p_f = r1f*nvf_p_c+rfc;
322 }
else if (nvf_p_c < (nvf_r_c/nvf_r_f)) {
323 nvf_p_f = nvf_r_f*nvf_p_c/nvf_r_c;
331 if (nvf_p_c < (.5*nvf_r_c)) {
332 nvf_p_f = (2.*nvf_r_f-nvf_r_c)*nvf_p_c/nvf_r_c;
333 }
else if (nvf_p_c < (1.+nvf_r_c-nvf_r_f)) {
334 nvf_p_f = nvf_p_c+nvf_r_f-nvf_r_c;
342 if (nvf_p_c < nvf_r_c) {
343 nvf_p_f = nvf_r_f*nvf_p_c/nvf_r_c;
345 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
346 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
348 nvf_p_f = r1f*nvf_p_c+rfc;
354 r1 = nvf_r_c*nvf_r_c-nvf_r_f;
355 r2 = nvf_r_c*(nvf_r_c-1.);
356 r3 = nvf_r_f-nvf_r_c;
358 nvf_p_f = nvf_p_c*(r1+r3*nvf_p_c)/r2;
363 b1 = (nvf_r_c-nvf_r_f)*nvf_r_c;
364 b2 = nvf_r_c+nvf_r_f+2.*nvf_r_f*nvf_r_f-4.*nvf_r_f*nvf_r_c;
366 if (nvf_p_c < (b1/b2)) {
367 r1 = -nvf_r_f*(1.-3.*nvf_r_c+2.*nvf_r_f);
368 r2 = nvf_r_c*(nvf_r_c-1.);
370 nvf_p_f = nvf_p_c*r1/r2;
371 }
else if (nvf_p_c < nvf_r_c) {
372 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
373 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
375 nvf_p_f = r1f*nvf_p_c+rfc;
376 }
else if (nvf_p_c < (nvf_r_c*(1.+nvf_r_f-nvf_r_c)/nvf_r_f)) {
377 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
378 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
380 nvf_p_f = nvf_r_f*(nvf_p_c*r1f/nvf_r_c+rfc);
388 if (nvf_p_c < (nvf_r_c/nvf_r_f)) {
389 nvf_p_f = nvf_r_f*nvf_p_c/nvf_r_c;
397 r1 = nvf_r_c*nvf_r_f*(nvf_r_f-nvf_r_c);
398 r2 = 2.*nvf_r_c*(1.-nvf_r_c)-nvf_r_f*(1.-nvf_r_f);
400 if (nvf_p_c < (r1/r2)) {
401 nvf_p_f = 2.*nvf_p_c;
402 }
else if (nvf_p_c <= (nvf_r_c*(1.+nvf_r_f-nvf_r_c)/nvf_r_f)) {
403 rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
404 r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
406 nvf_p_f = nvf_r_f*(nvf_p_c*r1f/nvf_r_c+rfc);
451 cs_real_t blend, high_order, low_order, ratio;
454 cs_real_t dotp =
CS_ABS(cs_math_3_dot_product(gradv_c, i_face_normal));
455 cs_real_t sgrad = cs_math_3_norm(gradv_c);
456 cs_real_t snorm = cs_math_3_norm(i_face_normal);
462 high_order = 2.*nvf_p_c;
478 blend =
CS_MIN(1., pow(ratio, .5));
482 nvf_p_f = blend*high_order + (1.-blend)*low_order;
485 if (c_courant < .7 && c_courant > .3) {
486 nvf_p_f = nvf_p_f + (nvf_p_f - low_order)*(.7 - c_courant )/.4;
487 }
else if (c_courant >= .7) {
492 if (c_courant <= .3) {
494 }
else if (c_courant <= .6) {
495 high_order =
CS_MIN(1., nvf_p_c/.3);
496 }
else if (c_courant <= .7) {
501 high_order = 10.*( (.7-c_courant)*
CS_MIN(1., nvf_p_c/.3)
502 + (c_courant-.6)*superbee);
522 blend =
CS_MIN(1., pow(ratio, 2.));
526 nvf_p_f = blend*high_order + (1.-blend)*low_order;
545 blend =
CS_MIN(1., pow(ratio, 4.));
549 nvf_p_f = blend*high_order + (1.-blend)*low_order;
593 testi = grdpai[0]*i_face_normal[0]
594 + grdpai[1]*i_face_normal[1]
595 + grdpai[2]*i_face_normal[2];
596 testj = grdpaj[0]*i_face_normal[0]
597 + grdpaj[1]*i_face_normal[1]
598 + grdpaj[2]*i_face_normal[2];
600 *testij = grdpai[0]*grdpaj[0]
601 + grdpai[1]*grdpaj[1]
602 + grdpai[2]*grdpaj[2];
605 dcc = gradi[0]*i_face_normal[0]
606 + gradi[1]*i_face_normal[1]
607 + gradi[2]*i_face_normal[2];
609 ddj = (pj-
pi)/distf *srfan;
611 dcc = gradj[0]*i_face_normal[0]
612 + gradj[1]*i_face_normal[1]
613 + gradj[2]*i_face_normal[2];
614 ddi = (pj-
pi)/distf *srfan;
618 *tesqck = cs_math_sq(dcc) - cs_math_sq(ddi-ddj);
661 for (
int i = 0; i < 3; i++) {
662 *testij += gradsti[i][0]*gradstj[i][0]
663 + gradsti[i][1]*gradstj[i][1]
664 + gradsti[i][2]*gradstj[i][2];
666 testi[i] = gradsti[i][0]*i_face_normal[0]
667 + gradsti[i][1]*i_face_normal[1]
668 + gradsti[i][2]*i_face_normal[2];
669 testj[i] = gradstj[i][0]*i_face_normal[0]
670 + gradstj[i][1]*i_face_normal[1]
671 + gradstj[i][2]*i_face_normal[2];
673 if (i_massflux > 0.) {
674 dcc[i] = gradi[i][0]*i_face_normal[0]
675 + gradi[i][1]*i_face_normal[1]
676 + gradi[i][2]*i_face_normal[2];
678 ddj[i] = (pj[i]-
pi[i])/distf *srfan;
680 dcc[i] = gradj[i][0]*i_face_normal[0]
681 + gradj[i][1]*i_face_normal[1]
682 + gradj[i][2]*i_face_normal[2];
683 ddi[i] = (pj[i]-
pi[i])/distf *srfan;
688 *tesqck = cs_math_3_square_norm(dcc) - cs_math_3_square_distance(ddi, ddj);
732 for (
int ij = 0; ij < 6; ij++) {
733 *testij += gradsti[ij][0]*gradstj[ij][0]
734 + gradsti[ij][1]*gradstj[ij][1]
735 + gradsti[ij][2]*gradstj[ij][2];
736 testi[ij] = gradsti[ij][0]*i_face_normal[0]
737 + gradsti[ij][1]*i_face_normal[1]
738 + gradsti[ij][2]*i_face_normal[2];
739 testj[ij] = gradstj[ij][0]*i_face_normal[0]
740 + gradstj[ij][1]*i_face_normal[1]
741 + gradstj[ij][2]*i_face_normal[2];
743 if (i_massflux > 0.) {
744 dcc[ij] = gradi[ij][0]*i_face_normal[0]
745 + gradi[ij][1]*i_face_normal[1]
746 + gradi[ij][2]*i_face_normal[2];
748 ddj[ij] = (pj[ij]-
pi[ij])/distf *srfan;
751 dcc[ij] = gradj[ij][0]*i_face_normal[0]
752 + gradj[ij][1]*i_face_normal[1]
753 + gradj[ij][2]*i_face_normal[2];
754 ddi[ij] = (pj[ij]-
pi[ij])/distf *srfan;
758 *tesqck += cs_math_sq(dcc[ij]) - cs_math_sq(ddi[ij]-ddj[ij]);
781 cs_i_compute_quantities(
const cs_real_t bldfrp,
793 cs_real_t gradpf[3] = {0.5*(gradi[0] + gradj[0]),
794 0.5*(gradi[1] + gradj[1]),
795 0.5*(gradi[2] + gradj[2])};
798 *recoi = bldfrp*(cs_math_3_dot_product(gradpf, diipf));
799 *recoj = bldfrp*(cs_math_3_dot_product(gradpf, djjpf));
823 cs_i_compute_quantities_vector(
const cs_real_t bldfrp,
839 for (
int isou = 0; isou < 3; isou++) {
841 for (
int jsou = 0; jsou < 3; jsou++)
842 dpvf[jsou] = 0.5*( gradi[isou][jsou]
843 + gradj[isou][jsou]);
847 recoi[isou] = bldfrp*(cs_math_3_dot_product(dpvf, diipf));
848 recoj[isou] = bldfrp*(cs_math_3_dot_product(dpvf, djjpf));
850 pip[isou] =
pi[isou] + recoi[isou];
851 pjp[isou] = pj[isou] + recoj[isou];
875 cs_i_compute_quantities_tensor(
const cs_real_t bldfrp,
891 for (
int isou = 0; isou < 6; isou++) {
893 for (
int jsou = 0; jsou < 3; jsou++)
894 dpvf[jsou] = 0.5*( gradi[isou][jsou]
895 + gradj[isou][jsou]);
899 recoi[isou] = bldfrp*(cs_math_3_dot_product(dpvf, diipf));
900 recoj[isou] = bldfrp*(cs_math_3_dot_product(dpvf, djjpf));
902 pip[isou] =
pi[isou] + recoi[isou];
903 pjp[isou] = pj[isou] + recoj[isou];
927 cs_i_relax_c_val(
const double relaxp,
939 *pir =
pi/relaxp - (1.-relaxp)/relaxp * pia;
940 *pjr = pj/relaxp - (1.-relaxp)/relaxp * pja;
942 *pipr = *pir + recoi;
943 *pjpr = *pjr + recoj;
965 cs_i_relax_c_val_vector(
const double relaxp,
977 for (
int isou = 0; isou < 3; isou++) {
978 pir[isou] =
pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
979 pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
981 pipr[isou] = pir[isou] + recoi[isou];
982 pjpr[isou] = pjr[isou] + recoj[isou];
1005 cs_i_relax_c_val_tensor(
const cs_real_t relaxp,
1017 for (
int isou = 0; isou < 6; isou++) {
1018 pir[isou] =
pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
1019 pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
1021 pipr[isou] = pir[isou] + recoi[isou];
1022 pjpr[isou] = pjr[isou] + recoj[isou];
1055 for (
int isou = 0; isou < 3; isou++)
1072 for (
int isou = 0; isou < 6; isou++)
1088 cs_centered_f_val(
const double pnd,
1093 *pf = pnd*pip + (1.-pnd)*pjp;
1108 cs_centered_f_val_vector(
const double pnd,
1113 for (
int isou = 0; isou < 3; isou++)
1114 pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
1129 cs_centered_f_val_tensor(
const double pnd,
1134 for (
int isou = 0; isou < 6; isou++)
1135 pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
1159 df[0] = i_face_cog[0] - cell_cen[0];
1160 df[1] = i_face_cog[1] - cell_cen[1];
1161 df[2] = i_face_cog[2] - cell_cen[2];
1163 *pf =
p + cs_math_3_dot_product(df, grad);
1187 for (
int jsou = 0; jsou < 3; jsou++)
1188 df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
1190 for (
int isou = 0; isou < 3; isou++) {
1191 pf[isou] =
p[isou] + df[0]*grad[isou][0]
1192 + df[1]*grad[isou][1]
1193 + df[2]*grad[isou][2];
1219 for (
int jsou = 0; jsou < 3; jsou++)
1220 df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
1222 for (
int isou = 0; isou < 6; isou++) {
1223 pf[isou] =
p[isou] + df[0]*grad[isou][0]
1224 + df[1]*grad[isou][1]
1225 + df[2]*grad[isou][2];
1242 cs_blend_f_val(
const double blencp,
1246 *pf = blencp * (*pf) + (1. - blencp) *
p;
1262 cs_blend_f_val_vector(
const double blencp,
1266 for (
int isou = 0; isou < 3; isou++)
1267 pf[isou] = blencp*(pf[isou])+(1.-blencp)*
p[isou];
1283 cs_blend_f_val_tensor(
const double blencp,
1287 for (
int isou = 0; isou < 6; isou++)
1288 pf[isou] = blencp*(pf[isou])+(1.-blencp)*
p[isou];
1315 cs_i_conv_flux(
const int iconvp,
1331 flui = 0.5*(i_massflux + fabs(i_massflux));
1332 fluj = 0.5*(i_massflux - fabs(i_massflux));
1334 fluxij[0] += iconvp*xcppi*(thetap*(flui*pifri + fluj*pjfri) - imasac*i_massflux*
pi);
1335 fluxij[1] += iconvp*xcppj*(thetap*(flui*pifrj + fluj*pjfrj) - imasac*i_massflux*pj);
1359 cs_i_conv_flux_vector(
const int iconvp,
1374 flui = 0.5*(i_massflux + fabs(i_massflux));
1375 fluj = 0.5*(i_massflux - fabs(i_massflux));
1377 for (
int isou = 0; isou < 3; isou++) {
1379 fluxi[isou] += iconvp*( thetap*(flui*pifri[isou] + fluj*pjfri[isou])
1380 - imasac*i_massflux*
pi[isou]);
1381 fluxj[isou] += iconvp*( thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
1382 - imasac*i_massflux*pj[isou]);
1407 cs_i_conv_flux_tensor(
const int iconvp,
1422 flui = 0.5*(i_massflux + fabs(i_massflux));
1423 fluj = 0.5*(i_massflux - fabs(i_massflux));
1425 for (
int isou = 0; isou < 6; isou++) {
1426 fluxi[isou] += iconvp*( thetap*(flui*pifri[isou] + fluj*pjfri[isou])
1427 - imasac*i_massflux*
pi[isou]);
1428 fluxj[isou] += iconvp*( thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
1429 - imasac*i_massflux*pj[isou]);
1449 cs_i_diff_flux(
const int idiffp,
1458 fluxij[0] += idiffp*thetap*i_visc*(pipr -pjp);
1459 fluxij[1] += idiffp*thetap*i_visc*(pip -pjpr);
1479 cs_i_diff_flux_vector(
const int idiffp,
1489 for (
int isou = 0; isou < 3; isou++) {
1490 fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
1491 fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
1512 cs_i_diff_flux_tensor(
const int idiffp,
1522 for (
int isou = 0; isou < 6; isou++) {
1523 fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
1524 fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
1555 cs_i_cd_steady_upwind(
const cs_real_t bldfrp,
1577 cs_i_compute_quantities(bldfrp,
1589 cs_i_relax_c_val(relaxp,
1603 cs_upwind_f_val(pir,
1607 cs_upwind_f_val(pjr,
1638 cs_i_cd_steady_upwind_vector(
const cs_real_t bldfrp,
1660 cs_i_compute_quantities_vector(bldfrp,
1672 cs_i_relax_c_val_vector(relaxp,
1684 cs_upwind_f_val_vector(
pi,
1686 cs_upwind_f_val_vector(pir,
1688 cs_upwind_f_val_vector(pj,
1690 cs_upwind_f_val_vector(pjr,
1721 cs_i_cd_steady_upwind_tensor(
const cs_real_t bldfrp,
1743 cs_i_compute_quantities_tensor(bldfrp,
1755 cs_i_relax_c_val_tensor(relaxp,
1767 cs_upwind_f_val_tensor(
pi,
1769 cs_upwind_f_val_tensor(pir,
1771 cs_upwind_f_val_tensor(pj,
1773 cs_upwind_f_val_tensor(pjr,
1797 cs_i_cd_unsteady_upwind(
const cs_real_t bldfrp,
1811 cs_i_compute_quantities(bldfrp,
1823 cs_upwind_f_val(
pi, pif);
1824 cs_upwind_f_val(pj, pjf);
1847 cs_i_cd_unsteady_upwind_vector(
const cs_real_t bldfrp,
1861 cs_i_compute_quantities_vector(bldfrp,
1873 cs_upwind_f_val_vector(
pi, pif);
1874 cs_upwind_f_val_vector(pj, pjf);
1897 cs_i_cd_unsteady_upwind_tensor(
const cs_real_t bldfrp,
1911 cs_i_compute_quantities_tensor(bldfrp,
1923 cs_upwind_f_val_tensor(
pi, pif);
1924 cs_upwind_f_val_tensor(pj, pjf);
1966 const double relaxp,
1967 const double blencp,
1994 cs_i_compute_quantities(bldfrp,
2006 cs_i_relax_c_val(relaxp,
2023 cs_centered_f_val(weight,
2027 cs_centered_f_val(weight,
2031 cs_centered_f_val(weight,
2035 cs_centered_f_val(weight,
2040 }
else if (ischcp == 0) {
2045 cs_solu_f_val(cell_ceni,
2050 cs_solu_f_val(cell_ceni,
2055 cs_solu_f_val(cell_cenj,
2060 cs_solu_f_val(cell_cenj,
2071 cs_solu_f_val(cell_ceni,
2076 cs_solu_f_val(cell_ceni,
2081 cs_solu_f_val(cell_cenj,
2086 cs_solu_f_val(cell_cenj,
2097 cs_blend_f_val(blencp,
2100 cs_blend_f_val(blencp,
2103 cs_blend_f_val(blencp,
2106 cs_blend_f_val(blencp,
2145 cs_i_cd_steady_vector(
const cs_real_t bldfrp,
2147 const double relaxp,
2148 const double blencp,
2173 cs_i_compute_quantities_vector(bldfrp,
2185 cs_i_relax_c_val_vector(relaxp,
2202 cs_centered_f_val_vector(weight,
2206 cs_centered_f_val_vector(weight,
2210 cs_centered_f_val_vector(weight,
2214 cs_centered_f_val_vector(weight,
2224 cs_solu_f_val_vector(cell_ceni,
2229 cs_solu_f_val_vector(cell_ceni,
2234 cs_solu_f_val_vector(cell_cenj,
2239 cs_solu_f_val_vector(cell_cenj,
2249 cs_blend_f_val_vector(blencp,
2252 cs_blend_f_val_vector(blencp,
2255 cs_blend_f_val_vector(blencp,
2258 cs_blend_f_val_vector(blencp,
2298 cs_i_cd_steady_tensor(
const cs_real_t bldfrp,
2300 const double relaxp,
2301 const double blencp,
2327 cs_i_compute_quantities_tensor(bldfrp,
2339 cs_i_relax_c_val_tensor(relaxp,
2356 cs_centered_f_val_tensor(weight,
2360 cs_centered_f_val_tensor(weight,
2364 cs_centered_f_val_tensor(weight,
2368 cs_centered_f_val_tensor(weight,
2378 cs_solu_f_val_tensor(cell_ceni,
2383 cs_solu_f_val_tensor(cell_ceni,
2388 cs_solu_f_val_tensor(cell_cenj,
2393 cs_solu_f_val_tensor(cell_cenj,
2404 cs_blend_f_val_tensor(blencp,
2407 cs_blend_f_val_tensor(blencp,
2410 cs_blend_f_val_tensor(blencp,
2413 cs_blend_f_val_tensor(blencp,
2451 cs_i_cd_unsteady(
const cs_real_t bldfrp,
2453 const double blencp,
2475 cs_i_compute_quantities(bldfrp,
2493 cs_centered_f_val(weight,
2497 cs_centered_f_val(weight,
2502 }
else if (ischcp == 0) {
2507 cs_solu_f_val(cell_ceni,
2512 cs_solu_f_val(cell_cenj,
2518 }
else if (ischcp == 3) {
2523 cs_centered_f_val(weight,
2527 cs_centered_f_val(weight,
2537 cs_solu_f_val(cell_ceni,
2542 cs_solu_f_val(cell_cenj,
2548 hybrid_blend_interp =
fmin(hybrid_blend_i,hybrid_blend_j);
2549 *pif = hybrid_blend_interp*(*pif) + (1. - hybrid_blend_interp)*pif_up;
2550 *pjf = hybrid_blend_interp*(*pjf) + (1. - hybrid_blend_interp)*pjf_up;
2557 cs_solu_f_val(cell_ceni,
2562 cs_solu_f_val(cell_cenj,
2574 cs_blend_f_val(blencp,
2577 cs_blend_f_val(blencp,
2611 cs_i_cd_unsteady_vector(
const cs_real_t bldfrp,
2613 const double blencp,
2634 cs_i_compute_quantities_vector(bldfrp,
2651 cs_centered_f_val_vector(weight,
2655 cs_centered_f_val_vector(weight,
2659 }
else if (ischcp == 3) {
2664 cs_centered_f_val_vector(weight,
2668 cs_centered_f_val_vector(weight,
2678 cs_solu_f_val_vector(cell_ceni,
2683 cs_solu_f_val_vector(cell_cenj,
2689 hybrid_blend_interp =
fmin(hybrid_blend_i,hybrid_blend_j);
2690 for (
int isou = 0; isou < 3; isou++) {
2691 pif[isou] = hybrid_blend_interp *pif[isou]
2692 + (1. - hybrid_blend_interp)*pif_up[isou];
2693 pjf[isou] = hybrid_blend_interp *pjf[isou]
2694 + (1. - hybrid_blend_interp)*pjf_up[isou];
2701 cs_solu_f_val_vector(cell_ceni,
2706 cs_solu_f_val_vector(cell_cenj,
2717 cs_blend_f_val_vector(blencp,
2720 cs_blend_f_val_vector(blencp,
2753 cs_i_cd_unsteady_tensor(
const cs_real_t bldfrp,
2755 const double blencp,
2774 cs_i_compute_quantities_tensor(bldfrp,
2791 cs_centered_f_val_tensor(weight,
2795 cs_centered_f_val_tensor(weight,
2805 cs_solu_f_val_tensor(cell_ceni,
2810 cs_solu_f_val_tensor(cell_cenj,
2821 cs_blend_f_val_tensor(blencp,
2824 cs_blend_f_val_tensor(blencp,
2877 cs_i_cd_steady_slope_test(
bool *upwind_switch,
2881 const double relaxp,
2882 const double blencp,
2883 const double blend_st,
2917 *upwind_switch =
false;
2919 cs_i_compute_quantities(bldfrp,
2931 cs_i_relax_c_val(relaxp,
2963 cs_centered_f_val(weight,
2967 cs_centered_f_val(weight,
2971 cs_centered_f_val(weight,
2975 cs_centered_f_val(weight,
2980 }
else if (ischcp == 0) {
2985 cs_solu_f_val(cell_ceni,
2990 cs_solu_f_val(cell_ceni,
2995 cs_solu_f_val(cell_cenj,
3000 cs_solu_f_val(cell_cenj,
3011 cs_solu_f_val(cell_ceni,
3016 cs_solu_f_val(cell_ceni,
3021 cs_solu_f_val(cell_cenj,
3026 cs_solu_f_val(cell_cenj,
3037 if (tesqck <= 0. || testij <= 0.) {
3039 cs_blend_f_val(blend_st,
3042 cs_blend_f_val(blend_st,
3045 cs_blend_f_val(blend_st,
3048 cs_blend_f_val(blend_st,
3052 *upwind_switch =
true;
3060 cs_blend_f_val(blencp,
3063 cs_blend_f_val(blencp,
3066 cs_blend_f_val(blencp,
3069 cs_blend_f_val(blencp,
3077 cs_upwind_f_val(pir,
3081 cs_upwind_f_val(pjr,
3132 cs_i_cd_steady_slope_test_vector(
bool *upwind_switch,
3136 const double relaxp,
3137 const double blencp,
3138 const double blend_st,
3171 cs_i_compute_quantities_vector(bldfrp,
3183 cs_i_relax_c_val_vector(relaxp,
3197 cs_slope_test_vector(
pi,
3210 for (isou = 0; isou < 3; isou++) {
3216 cs_centered_f_val(weight,
3220 cs_centered_f_val(weight,
3224 cs_centered_f_val(weight,
3228 cs_centered_f_val(weight,
3238 cs_solu_f_val(cell_ceni,
3243 cs_solu_f_val(cell_ceni,
3248 cs_solu_f_val(cell_cenj,
3253 cs_solu_f_val(cell_cenj,
3266 if (tesqck <= 0. || testij <= 0.) {
3267 cs_blend_f_val_vector(blend_st,
3270 cs_blend_f_val_vector(blend_st,
3273 cs_blend_f_val_vector(blend_st,
3276 cs_blend_f_val_vector(blend_st,
3280 *upwind_switch =
true;
3286 cs_blend_f_val_vector(blencp,
3289 cs_blend_f_val_vector(blencp,
3292 cs_blend_f_val_vector(blencp,
3295 cs_blend_f_val_vector(blencp,
3301 for (isou = 0; isou < 3; isou++) {
3302 cs_upwind_f_val(
pi[isou],
3304 cs_upwind_f_val(pir[isou],
3306 cs_upwind_f_val(pj[isou],
3308 cs_upwind_f_val(pjr[isou],
3360 cs_i_cd_steady_slope_test_tensor(
bool *upwind_switch,
3364 const double relaxp,
3365 const double blencp,
3366 const double blend_st,
3399 cs_i_compute_quantities_tensor(bldfrp,
3411 cs_i_relax_c_val_tensor(relaxp,
3425 cs_slope_test_tensor(
pi,
3438 for (isou = 0; isou < 6; isou++) {
3444 cs_centered_f_val(weight,
3448 cs_centered_f_val(weight,
3452 cs_centered_f_val(weight,
3456 cs_centered_f_val(weight,
3466 cs_solu_f_val(cell_ceni,
3471 cs_solu_f_val(cell_ceni,
3476 cs_solu_f_val(cell_cenj,
3481 cs_solu_f_val(cell_cenj,
3494 if (tesqck <= 0. || testij <= 0.) {
3496 cs_blend_f_val_tensor(blend_st,
3499 cs_blend_f_val_tensor(blend_st,
3502 cs_blend_f_val_tensor(blend_st,
3505 cs_blend_f_val_tensor(blend_st,
3509 *upwind_switch =
true;
3517 cs_blend_f_val_tensor(blencp,
3520 cs_blend_f_val_tensor(blencp,
3523 cs_blend_f_val_tensor(blencp,
3526 cs_blend_f_val_tensor(blencp,
3532 for (isou = 0; isou < 6; isou++) {
3533 cs_upwind_f_val(
pi[isou],
3535 cs_upwind_f_val(pir[isou],
3537 cs_upwind_f_val(pj[isou],
3539 cs_upwind_f_val(pjr[isou],
3586 cs_i_cd_unsteady_slope_test(
bool *upwind_switch,
3590 const double blencp,
3591 const double blend_st,
3620 *upwind_switch =
false;
3622 cs_i_compute_quantities(bldfrp,
3654 cs_centered_f_val(weight,
3658 cs_centered_f_val(weight,
3663 }
else if (ischcp == 0) {
3668 cs_solu_f_val(cell_ceni,
3673 cs_solu_f_val(cell_cenj,
3684 cs_solu_f_val(cell_ceni,
3689 cs_solu_f_val(cell_cenj,
3700 if (tesqck<=0. || testij<=0.) {
3702 cs_blend_f_val(blend_st,
3705 cs_blend_f_val(blend_st,
3709 *upwind_switch =
true;
3716 cs_blend_f_val(blencp,
3719 cs_blend_f_val(blencp,
3747 cs_central_downwind_cells(
const cs_lnum_t ii,
3753 if (i_massflux >= 0.) {
3816 const cs_real_t dist_du = dist_dc + dist_cu;
3820 const cs_real_t gradc = cs_math_3_dot_product(gradv_c, ndc);
3822 const cs_real_t grad2c = ((p_d - p_c)/dist_dc - gradc)/dist_dc;
3824 cs_real_t p_u = p_c + (grad2c*dist_cu - gradc)*dist_cu;
3828 const cs_real_t nvf_r_f = (dist_fc+dist_cu)/dist_du;
3829 const cs_real_t nvf_r_c = dist_cu/dist_du;
3836 if (
CS_ABS(p_d-p_u) <= _small) {
3840 const cs_real_t nvf_p_c = (p_c - p_u)/(p_d - p_u);
3842 if (nvf_p_c <= 0. || nvf_p_c >= 1.) {
3850 nvf_p_f = cs_nvd_vof_scheme_scalar(limiter,
3858 nvf_p_f = cs_nvd_scheme_scalar(limiter,
3864 *pif = p_u + nvf_p_f*(p_d - p_u);
3867 cs_blend_f_val(
beta,
3914 cs_i_cd_unsteady_slope_test_vector(
bool *upwind_switch,
3918 const double blencp,
3919 const double blend_st,
3944 cs_i_compute_quantities_vector(bldfrp,
3958 cs_slope_test_vector(
pi,
3971 for (
int isou = 0; isou < 3; isou++) {
3977 cs_centered_f_val(weight,
3981 cs_centered_f_val(weight,
3991 cs_solu_f_val(cell_ceni,
3996 cs_solu_f_val(cell_cenj,
4009 if (tesqck <= 0. || testij <= 0.) {
4011 cs_blend_f_val_vector(blend_st,
4014 cs_blend_f_val_vector(blend_st,
4018 *upwind_switch =
true;
4025 cs_blend_f_val_vector(blencp,
4028 cs_blend_f_val_vector(blencp,
4035 for (
int isou = 0; isou < 3; isou++) {
4036 cs_upwind_f_val(
pi[isou],
4038 cs_upwind_f_val(pj[isou],
4084 cs_i_cd_unsteady_slope_test_tensor(
bool *upwind_switch,
4088 const double blencp,
4089 const double blend_st,
4115 cs_i_compute_quantities_tensor(bldfrp,
4129 cs_slope_test_tensor(
pi,
4142 for (isou = 0; isou < 6; isou++) {
4149 cs_centered_f_val(weight,
4153 cs_centered_f_val(weight,
4163 cs_solu_f_val(cell_ceni,
4168 cs_solu_f_val(cell_cenj,
4178 if (tesqck <= 0. || testij <= 0.) {
4183 cs_blend_f_val_tensor(blend_st,
4186 cs_blend_f_val_tensor(blend_st,
4190 *upwind_switch =
true;
4197 cs_blend_f_val_tensor(blencp,
4200 cs_blend_f_val_tensor(blencp,
4207 for (isou = 0; isou < 6; isou++) {
4208 cs_upwind_f_val(
pi[isou],
4210 cs_upwind_f_val(pj[isou],
4233 *recoi = bldfrp * ( gradi[0]*
diipb[0]
4235 + gradi[2]*
diipb[2]);
4255 for (
int isou = 0; isou < 3; isou++) {
4256 recoi[isou] = bldfrp * ( gradi[isou][0]*
diipb[0]
4257 + gradi[isou][1]*
diipb[1]
4258 + gradi[isou][2]*
diipb[2]);
4279 for (
int isou = 0; isou < 6; isou++) {
4280 recoi[isou] = bldfrp * ( gradi[isou][0]*
diipb[0]
4281 + gradi[isou][1]*
diipb[1]
4282 + gradi[isou][2]*
diipb[2]);
4300 cs_b_relax_c_val(
const double relaxp,
4307 *pir =
pi/relaxp - (1.-relaxp)/relaxp*pia;
4308 *pipr = *pir + recoi;
4325 cs_b_relax_c_val_vector(
const double relaxp,
4332 for (
int isou = 0; isou < 3; isou++) {
4333 pir[isou] =
pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
4334 pipr[isou] = pir[isou] + recoi[isou];
4352 cs_b_relax_c_val_tensor(
const double relaxp,
4359 for (
int isou = 0; isou < 6; isou++) {
4360 pir[isou] =
pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
4361 pipr[isou] = pir[isou] + recoi[isou];
4392 cs_b_imposed_conv_flux(
int iconvp,
4420 flui = 0.5*(b_massflux +fabs(b_massflux));
4421 fluj = 0.5*(b_massflux -fabs(b_massflux));
4424 pfac = inc*coefap + coefbp*pipr;
4425 *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*
pi));
4431 pfac = inc*coface + cofbce*pipr;
4432 *flux += iconvp*xcpp*(-imasac*(b_massflux*
pi) + thetap*(pfac));
4462 cs_b_imposed_conv_flux_vector(
int iconvp,
4489 flui = 0.5*(b_massflux +fabs(b_massflux));
4490 fluj = 0.5*(b_massflux -fabs(b_massflux));
4492 for (
int isou = 0; isou < 3; isou++) {
4493 pfac = inc*coefap[isou];
4494 for (
int jsou = 0; jsou < 3; jsou++) {
4495 pfac += coefbp[isou][jsou]*pipr[jsou];
4497 flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4498 - imasac*b_massflux*
pi[isou]);
4505 for (
int isou = 0; isou < 3; isou++) {
4506 pfac = inc*coface[isou];
4507 for (
int jsou = 0; jsou < 3; jsou++) {
4508 pfac += cofbce[isou][jsou]*pipr[jsou];
4510 flux[isou] += iconvp*( thetap*pfac
4511 - imasac*b_massflux*
pi[isou]);
4540 cs_b_upwind_flux(
const int iconvp,
4561 flui = 0.5*(b_massflux +fabs(b_massflux));
4562 fluj = 0.5*(b_massflux -fabs(b_massflux));
4565 pfac = inc*coefap + coefbp*pipr;
4566 *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*
pi));
4592 cs_b_upwind_flux_vector(
const int iconvp,
4612 flui = 0.5*(b_massflux +fabs(b_massflux));
4613 fluj = 0.5*(b_massflux -fabs(b_massflux));
4615 for (
int isou = 0; isou < 3; isou++) {
4616 pfac = inc*coefa[isou];
4617 for (
int jsou = 0; jsou < 3; jsou++) {
4618 pfac += coefb[isou][jsou]*pipr[jsou];
4620 flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4621 - imasac*b_massflux*
pi[isou]);
4648 cs_b_upwind_flux_tensor(
const int iconvp,
4668 flui = 0.5*(b_massflux +fabs(b_massflux));
4669 fluj = 0.5*(b_massflux -fabs(b_massflux));
4671 for (
int isou = 0; isou < 6; isou++) {
4672 pfac = inc*coefa[isou];
4673 for (
int jsou = 0; jsou < 6; jsou++) {
4674 pfac += coefb[isou][jsou]*pipr[jsou];
4676 flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4677 - imasac*b_massflux*
pi[isou]);
4697 cs_b_diff_flux(
const int idiffp,
4706 cs_real_t pfacd = inc*cofafp + cofbfp*pipr;
4707 *flux += idiffp*thetap*b_visc*pfacd;
4726 cs_b_diff_flux_vector(
const int idiffp,
4736 for (
int isou = 0; isou < 3; isou++) {
4737 pfacd = inc*cofaf[isou];
4738 for (
int jsou = 0; jsou < 3; jsou++) {
4739 pfacd += cofbf[isou][jsou]*pipr[jsou];
4741 flux[isou] += idiffp*thetap*b_visc*pfacd;
4761 cs_b_diff_flux_tensor(
const int idiffp,
4771 for (
int isou = 0; isou < 6; isou++) {
4772 pfacd = inc*cofaf[isou];
4773 for (
int jsou = 0; jsou < 6; jsou++) {
4774 pfacd += cofbf[isou][jsou]*pipr[jsou];
4776 flux[isou] += idiffp*thetap*b_visc*pfacd;
4798 const double relaxp,
4808 cs_b_compute_quantities(
diipb,
4813 cs_b_relax_c_val(relaxp,
4838 cs_b_cd_steady_vector(
const cs_real_t bldfrp,
4839 const double relaxp,
4849 cs_b_compute_quantities_vector(
diipb,
4854 cs_b_relax_c_val_vector(relaxp,
4879 cs_b_cd_steady_tensor(
const cs_real_t bldfrp,
4880 const double relaxp,
4890 cs_b_compute_quantities_tensor(
diipb,
4895 cs_b_relax_c_val_tensor(relaxp,
4917 cs_b_cd_unsteady(
const cs_real_t bldfrp,
4925 cs_b_compute_quantities(
diipb,
4947 cs_b_cd_unsteady_vector(
const cs_real_t bldfrp,
4955 cs_b_compute_quantities_vector(
diipb,
4960 for (
int isou = 0; isou < 3; isou++)
4961 pip[isou] =
pi[isou] + recoi[isou];
4978 cs_b_cd_unsteady_tensor(
const cs_real_t bldfrp,
4986 cs_b_compute_quantities_tensor(
diipb,
4991 for(
int isou = 0; isou< 6; isou++)
4992 pip[isou] =
pi[isou] + recoi[isou];
5009 cs_b_diff_flux_coupling(
int idiffp,
5015 *fluxi += idiffp*b_visc*(
pi - pj);
5032 cs_b_diff_flux_coupling_vector(
int idiffp,
5038 for (
int k = 0;
k < 3;
k++)
5039 fluxi[
k] += idiffp*b_visc*(
pi[
k] - pj[
k]);
5053 const int *
const f_id,
5054 const int *
const init,
5055 const int *
const inc,
5057 const int *
const iccocg,
5058 const int *
const nswrgp,
5059 const int *
const imligp,
5060 const int *
const iphydp,
5061 const int *
const iwgrp,
5062 const int *
const iwarnp,
5085 const int *
const f_id,
5086 const int *
const init,
5087 const int *
const inc,
5089 const int *
const iccocg,
5090 const int *
const nswrgp,
5091 const int *
const imligp,
5092 const int *
const ircflp,
5093 const int *
const iphydp,
5094 const int *
const iwgrp,
5095 const int *
const iwarnp,
5120 const int *
const f_id,
5121 const int *
const init,
5122 const int *
const inc,
5124 const int *
const iccocg,
5125 const int *
const nswrgp,
5126 const int *
const imligp,
5127 const int *
const iphydp,
5128 const int *
const iwgrp,
5129 const int *
const iwarnp,
5151 const int *
const f_id,
5152 const int *
const init,
5153 const int *
const inc,
5155 const int *
const iccocg,
5156 const int *
const nswrgp,
5157 const int *
const imligp,
5158 const int *
const ircflp,
5159 const int *
const iphydp,
5160 const int *
const iwgrp,
5161 const int *
const iwarnp,
Definition: cs_field_pointer.h:70
void itrgrv(const int *const f_id, const int *const init, const int *const inc, const int *const imrgra, const int *const iccocg, const int *const nswrgp, const int *const imligp, const int *const ircflp, const int *const iphydp, const int *const iwgrp, const int *const iwarnp, const cs_real_t *const epsrgp, const cs_real_t *const climgp, const cs_real_t *const extrap, cs_real_3_t frcxt[], cs_real_t pvar[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t viscel[], const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_t diverg[])
Definition: cs_convection_diffusion.c:812
void cs_convection_diffusion_vector(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int icvflb, int inc, int ivisep, int imasac, cs_real_3_t *restrict pvar, const cs_real_3_t *restrict pvara, const int icvfli[], const cs_real_3_t coefav[], const cs_real_33_t coefbv[], const cs_real_3_t cofafv[], const cs_real_33_t cofbfv[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], const cs_real_t i_visc[], const cs_real_t b_visc[], const cs_real_t i_secvis[], const cs_real_t b_secvis[], cs_real_3_t *restrict rhs)
Add the explicit part of the convection/diffusion terms of a transport equation of a vector field ...
Definition: cs_convection_diffusion.c:4169
double precision, dimension(:,:), pointer diipb
Definition: mesh.f90:212
#define restrict
Definition: cs_defs.h:142
cs_real_t cs_real_2_t[2]
vector of 2 floating-point values
Definition: cs_defs.h:334
cs_real_t cs_real_6_t[6]
vector of 6 floating-point values
Definition: cs_defs.h:337
int cs_field_key_id_try(const char *name)
Return an id associated with a given key name if present.
Definition: cs_field.c:2524
void cs_anisotropic_diffusion_tensor(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, cs_real_6_t *restrict pvar, const cs_real_6_t *restrict pvara, const cs_real_6_t coefa[], const cs_real_66_t coefb[], const cs_real_6_t cofaf[], const cs_real_66_t cofbf[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t *restrict viscel, const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_6_t *restrict rhs)
Add the explicit part of the diffusion terms with a symmetric tensor diffusivity for a transport equa...
Definition: cs_convection_diffusion.c:10164
cs_nvd_type_t
Definition: cs_convection_diffusion.h:59
void cs_face_diffusion_potential(const int f_id, const cs_mesh_t *m, cs_mesh_quantities_t *fvq, int init, int inc, int imrgra, int iccocg, int nswrgp, int imligp, int iphydp, int iwgrp, int iwarnp, double epsrgp, double climgp, cs_real_3_t *restrict frcxt, cs_real_t *restrict pvar, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_t *restrict visel, cs_real_t *restrict i_massflux, cs_real_t *restrict b_massflux)
Update the face mass flux with the face pressure (or pressure increment, or pressure double increment...
Definition: cs_convection_diffusion.c:10781
void cs_anisotropic_diffusion_scalar(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, int iccocg, cs_real_t *restrict pvar, const cs_real_t *restrict pvara, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t *restrict viscel, const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_t *restrict rhs)
Add the explicit part of the diffusion terms with a symmetric tensor diffusivity for a transport equa...
Definition: cs_convection_diffusion.c:8154
Field descriptor.
Definition: cs_field.h:125
Set of parameters to handle an unsteady convection-diffusion-reaction equation with term sources...
Definition: cs_equation_param.h:177
#define CS_ABS(a)
Definition: cs_defs.h:472
cs_field_t * cs_field_by_id(int id)
Return a pointer to a field based on its id.
Definition: cs_field.c:2314
cs_real_t cs_real_66_t[6][6]
6x6 matrix of floating-point values
Definition: cs_defs.h:343
void itrgrp(const int *const f_id, const int *const init, const int *const inc, const int *const imrgra, const int *const iccocg, const int *const nswrgp, const int *const imligp, const int *const iphydp, const int *const iwgrp, const int *const iwarnp, const cs_real_t *const epsrgp, const cs_real_t *const climgp, const cs_real_t *const extrap, cs_real_3_t frcxt[], cs_real_t pvar[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_t visel[], cs_real_t diverg[])
Definition: cs_convection_diffusion.c:750
Definition: cs_convection_diffusion.h:68
void cs_slope_test_gradient_tensor(const int inc, const cs_halo_type_t halo_type, const cs_real_63_t *grad, cs_real_63_t *grdpa, const cs_real_6_t *pvar, const cs_real_6_t *coefa, const cs_real_66_t *coefb, const cs_real_t *i_massflux)
Compute the upwind gradient used in the slope tests.
Definition: cs_convection_diffusion.c:1328
double precision pi
value with 16 digits
Definition: cstnum.f90:48
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
void cs_face_convection_scalar(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int icvflb, int inc, int iccocg, int imasac, cs_real_t *restrict pvar, const cs_real_t *restrict pvara, const int icvfli[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], cs_real_2_t i_conv_flux[], cs_real_t b_conv_flux[])
Update face flux with convection contribution of a standard transport equation of a scalar field ...
Definition: cs_convection_diffusion.c:3058
const cs_real_t cs_math_epzero
#define CS_UNUSED(x)
Definition: cs_defs.h:496
void cs_slope_test_gradient_vector(const int inc, const cs_halo_type_t halo_type, const cs_real_33_t *grad, cs_real_33_t *grdpa, const cs_real_3_t *pvar, const cs_real_3_t *coefa, const cs_real_33_t *coefb, const cs_real_t *i_massflux)
Compute the upwind gradient used in the slope tests.
Definition: cs_convection_diffusion.c:1173
double precision, dimension(ncharm), save beta
Definition: cpincl.f90:99
integer(c_int), pointer, save idtvar
option for a variable time step
Definition: optcal.f90:383
void cs_anisotropic_left_diffusion_vector(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, int ivisep, cs_real_3_t *restrict pvar, const cs_real_3_t *restrict pvara, const cs_real_3_t coefav[], const cs_real_33_t coefbv[], const cs_real_3_t cofafv[], const cs_real_33_t cofbfv[], const cs_real_33_t i_visc[], const cs_real_t b_visc[], const cs_real_t i_secvis[], cs_real_3_t *restrict rhs)
Add explicit part of the terms of diffusion by a left-multiplying symmetric tensorial diffusivity for...
Definition: cs_convection_diffusion.c:8907
Definition: cs_field_pointer.h:67
void cs_math_3_length_unitv(const cs_real_t xa[3], const cs_real_t xb[3], cs_real_t *len, cs_real_3_t unitv)
Compute the length (Euclidean norm) between two points xa and xb in a Cartesian coordinate system of ...
Definition: cs_math.c:438
Definition: cs_convection_diffusion.h:63
cs_real_t * val
Definition: cs_field.h:146
#define CS_F_(e)
Macro used to return a field pointer by its enumerated value.
Definition: cs_field_pointer.h:51
Definition: cs_convection_diffusion.h:66
integer, dimension(:), allocatable icvfli
boundary convection flux indicator of a Rusanov or an analytical flux (some boundary contributions of...
Definition: cfpoin.f90:52
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
void itrmas(const int *const f_id, const int *const init, const int *const inc, const int *const imrgra, const int *const iccocg, const int *const nswrgp, const int *const imligp, const int *const iphydp, const int *const iwgrp, const int *const iwarnp, const cs_real_t *const epsrgp, const cs_real_t *const climgp, const cs_real_t *const extrap, cs_real_3_t frcxt[], cs_real_t pvar[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_t visel[], cs_real_t i_massflux[], cs_real_t b_massflux[])
Definition: cs_convection_diffusion.c:616
int cs_field_get_key_int(const cs_field_t *f, int key_id)
Return a integer value for a given key associated with a field.
Definition: cs_field.c:2991
int cs_field_key_id(const char *name)
Return an id associated with a given key name.
Definition: cs_field.c:2497
cs_equation_param_t * var_cal_opt
Definition: keywords.h:135
void cs_halo_sync_var(const cs_halo_t *halo, cs_halo_type_t sync_mode, cs_real_t var[])
Definition: cs_halo.c:1903
double precision, dimension(ncharm), save b2
Definition: cpincl.f90:233
int iconv
Definition: cs_equation_param.h:437
Definition: cs_convection_diffusion.h:65
cs_lnum_t * group_index
Definition: cs_numbering.h:98
void cs_anisotropic_right_diffusion_vector(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, cs_real_3_t *restrict pvar, const cs_real_3_t *restrict pvara, const cs_real_3_t coefav[], const cs_real_33_t coefbv[], const cs_real_3_t cofafv[], const cs_real_33_t cofbfv[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t *restrict viscel, const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_3_t *restrict rhs)
Add explicit part of the terms of diffusion by a right-multiplying symmetric tensorial diffusivity fo...
Definition: cs_convection_diffusion.c:9453
Definition: cs_field_pointer.h:65
cs_mesh_quantities_t * cs_glob_mesh_quantities
Definition: cs_mesh_quantities.h:89
double blencv
Definition: cs_equation_param.h:457
#define CS_MIN(a, b)
Definition: cs_defs.h:473
cs_halo_type_t
Definition: cs_halo.h:56
void cs_face_anisotropic_diffusion_potential(const int f_id, const cs_mesh_t *m, cs_mesh_quantities_t *fvq, int init, int inc, int imrgra, int iccocg, int nswrgp, int imligp, int ircflp, int iphydp, int iwgrp, int iwarnp, double epsrgp, double climgp, cs_real_3_t *restrict frcxt, cs_real_t *restrict pvar, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t *restrict viscel, const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_t *restrict i_massflux, cs_real_t *restrict b_massflux)
Add the explicit part of the pressure gradient term to the mass flux in case of anisotropic diffusion...
Definition: cs_convection_diffusion.c:11130
Definition: cs_convection_diffusion.h:62
cs_lnum_t cs_lnum_2_t[2]
vector of 2 local mesh-entity ids
Definition: cs_defs.h:328
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:335
int n_groups
Definition: cs_numbering.h:90
int isstpc
Definition: cs_equation_param.h:447
void cs_anisotropic_diffusion_potential(const int f_id, const cs_mesh_t *m, cs_mesh_quantities_t *fvq, int init, int inc, int imrgra, int iccocg, int nswrgp, int imligp, int ircflp, int iphydp, int iwgrp, int iwarnp, double epsrgp, double climgp, cs_real_3_t *restrict frcxt, cs_real_t *restrict pvar, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t *restrict viscel, const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_t *restrict diverg)
Add the explicit part of the divergence of the mass flux due to the pressure gradient (routine analog...
Definition: cs_convection_diffusion.c:11993
Definition: cs_convection_diffusion.h:74
void cs_slope_test_gradient(int f_id, int inc, cs_halo_type_t halo_type, const cs_real_3_t *grad, cs_real_3_t *grdpa, const cs_real_t *pvar, const cs_real_t *coefap, const cs_real_t *coefbp, const cs_real_t *i_massflux)
Compute the upwind gradient used in the slope tests.
Definition: cs_convection_diffusion.c:901
void cs_convection_diffusion_tensor(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int icvflb, int inc, int imasac, cs_real_6_t *restrict pvar, const cs_real_6_t *restrict pvara, const cs_real_6_t coefa[], const cs_real_66_t coefb[], const cs_real_6_t cofaf[], const cs_real_66_t cofbf[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t *restrict rhs)
Add the explicit part of the convection/diffusion terms of a transport equation of a vector field ...
Definition: cs_convection_diffusion.c:5857
double precision, save fmin
Definition: coincl.f90:133
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
cs_lnum_t n_cells_with_ghosts
Definition: cs_mesh.h:150
Definition: cs_convection_diffusion.h:70
#define END_C_DECLS
Definition: cs_defs.h:511
Definition: cs_convection_diffusion.h:67
Definition: cs_convection_diffusion.h:72
cs_numbering_t * b_face_numbering
Definition: cs_mesh.h:162
cs_numbering_t * i_face_numbering
Definition: cs_mesh.h:161
#define CS_PROCF(x, y)
Definition: cs_defs.h:524
#define CS_MAX(a, b)
Definition: cs_defs.h:474
Definition: cs_parameters.h:93
int n_threads
Definition: cs_numbering.h:89
void cs_diffusion_potential(const int f_id, const cs_mesh_t *m, cs_mesh_quantities_t *fvq, int init, int inc, int imrgra, int iccocg, int nswrgp, int imligp, int iphydp, int iwgrp, int iwarnp, double epsrgp, double climgp, cs_real_3_t *restrict frcxt, cs_real_t *restrict pvar, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_t visel[], cs_real_t *restrict diverg)
Update the cell mass flux divergence with the face pressure (or pressure increment, or pressure double increment) gradient.
Definition: cs_convection_diffusion.c:11615
integer, save kimasf
interior and boundary convective mass flux key ids of the variables
Definition: numvar.f90:187
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:342
Definition: cs_convection_diffusion.h:71
Definition: cs_convection_diffusion.h:61
Definition: cs_convection_diffusion.h:64
void cs_convection_diffusion_scalar(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int icvflb, int inc, int iccocg, int imasac, cs_real_t *restrict pvar, const cs_real_t *restrict pvara, const int icvfli[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_t *restrict rhs)
Add the explicit part of the convection/diffusion terms of a standard transport equation of a scalar ...
Definition: cs_convection_diffusion.c:1625
cs_real_t cs_real_63_t[6][3]
Definition: cs_defs.h:350
cs_real_t * cell_vol
Definition: cs_mesh_quantities.h:92
integer, save kbmasf
Definition: numvar.f90:187
cs_lnum_2_t * i_face_cells
Definition: cs_mesh.h:110
void itrmav(const int *const f_id, const int *const init, const int *const inc, const int *const imrgra, const int *const iccocg, const int *const nswrgp, const int *const imligp, const int *const ircflp, const int *const iphydp, const int *const iwgrp, const int *const iwarnp, const cs_real_t *const epsrgp, const cs_real_t *const climgp, const cs_real_t *const extrap, cs_real_3_t frcxt[], cs_real_t pvar[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_visc[], const cs_real_t b_visc[], cs_real_6_t viscel[], const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_t i_massflux[], cs_real_t b_massflux[])
Definition: cs_convection_diffusion.c:680
void cs_beta_limiter_building(int f_id, int inc, const cs_real_t rovsdt[])
Compute the beta blending coefficient of the beta limiter (ensuring preservation of a given min/max p...
Definition: cs_convection_diffusion.c:1474
void cs_convection_diffusion_thermal(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, int iccocg, int imasac, cs_real_t *restrict pvar, const cs_real_t *restrict pvara, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], const cs_real_t i_visc[], const cs_real_t b_visc[], const cs_real_t xcpp[], cs_real_t *restrict rhs)
Add the explicit part of the convection/diffusion terms of a transport equation of a scalar field su...
Definition: cs_convection_diffusion.c:6820
double precision, dimension(ncharm), save b1
Definition: cpincl.f90:233
void cs_upwind_gradient(const int f_id, const int inc, const cs_halo_type_t halo_type, const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t i_massflux[], const cs_real_t b_massflux[], const cs_real_t *restrict pvar, cs_real_3_t *restrict grdpa)
Compute the upwind gradient in order to cope with SOLU schemes observed in the litterature.
Definition: cs_convection_diffusion.c:1043
Definition: cs_convection_diffusion.h:69
integer(c_int), pointer, save imrgra
type of gradient reconstruction
Definition: optcal.f90:260
cs_halo_t * halo
Definition: cs_mesh.h:155
cs_lnum_t * b_face_cells
Definition: cs_mesh.h:111
Definition: cs_convection_diffusion.h:73