1 #ifndef __CS_CONVECTION_DIFFUSION_PRIV_H__ 
    2 #define __CS_CONVECTION_DIFFUSION_PRIV_H__ 
  101     rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  103     if (nvf_p_c < beta_m) {
 
  104       nvf_p_f = nvf_p_c*(1.+rfc*(1.-nvf_p_c)/beta_m);
 
  106       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  108       nvf_p_f = r1f*nvf_p_c+rfc;
 
  114     if (nvf_p_c < (nvf_r_c/3.)) {
 
  115       r1 = nvf_r_f*(1.-3.*nvf_r_c+2.*nvf_r_f);
 
  116       r2 = nvf_r_c*(1.-nvf_r_c);
 
  118       nvf_p_f = nvf_p_c*r1/r2;
 
  119     } 
else if (nvf_p_c <= (nvf_r_c*(1.+nvf_r_f-nvf_r_c)/nvf_r_f)) {
 
  120       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  121       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  123       nvf_p_f = nvf_r_f*(r1f*nvf_p_c/nvf_r_c + rfc);
 
  131     if (nvf_p_c < (3.*nvf_r_c/4.)) {
 
  132       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  134       nvf_p_f = nvf_r_f*(1.+rfc/3.)*nvf_p_c/nvf_r_c;
 
  135     } 
else if (nvf_p_c <= (nvf_r_c*(1.+2.*(nvf_r_f-nvf_r_c))/(2.*nvf_r_f-nvf_r_c))) {
 
  136       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  137       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  139       nvf_p_f = nvf_r_f*(r1f*nvf_p_c/nvf_r_c+rfc);
 
  141       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  143       nvf_p_f = 1.-.5*r1f*(1.-nvf_p_c);
 
  149     if (nvf_p_c < (nvf_r_c/(2.-nvf_r_c))) {
 
  150       nvf_p_f = (2.*nvf_r_f-nvf_r_c)*nvf_p_c/nvf_r_c;
 
  151     } 
else if (nvf_p_c < nvf_r_c) {
 
  152       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  153       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  155       nvf_p_f = r1f*nvf_p_c+rfc;
 
  156     } 
else if (nvf_p_c < (nvf_r_c/nvf_r_f)) {
 
  157       nvf_p_f = nvf_r_f*nvf_p_c/nvf_r_c;
 
  165     if (nvf_p_c < (.5*nvf_r_c)) {
 
  166       nvf_p_f = (2.*nvf_r_f-nvf_r_c)*nvf_p_c/nvf_r_c;
 
  167     } 
else if (nvf_p_c < (1.+nvf_r_c-nvf_r_f)) {
 
  168       nvf_p_f = nvf_p_c+nvf_r_f-nvf_r_c;
 
  176     if (nvf_p_c < nvf_r_c) {
 
  177       nvf_p_f = nvf_r_f*nvf_p_c/nvf_r_c;
 
  179       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  180       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  182       nvf_p_f = r1f*nvf_p_c+rfc;
 
  188     r1 = nvf_r_c*nvf_r_c-nvf_r_f;
 
  189     r2 = nvf_r_c*(nvf_r_c-1.);
 
  190     r3 = nvf_r_f-nvf_r_c;
 
  192     nvf_p_f = nvf_p_c*(r1+r3*nvf_p_c)/r2;
 
  197     b1 = (nvf_r_c-nvf_r_f)*nvf_r_c;
 
  198     b2 = nvf_r_c+nvf_r_f+2.*nvf_r_f*nvf_r_f-4.*nvf_r_f*nvf_r_c;
 
  200     if (nvf_p_c < (
b1/
b2)) {
 
  201       r1 = -nvf_r_f*(1.-3.*nvf_r_c+2.*nvf_r_f);
 
  202       r2 = nvf_r_c*(nvf_r_c-1.);
 
  204       nvf_p_f = nvf_p_c*r1/r2;
 
  205     } 
else if (nvf_p_c < nvf_r_c) {
 
  206       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  207       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  209       nvf_p_f = r1f*nvf_p_c+rfc;
 
  210     } 
else if (nvf_p_c < (nvf_r_c*(1.+nvf_r_f-nvf_r_c)/nvf_r_f)) {
 
  211       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  212       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  214       nvf_p_f = nvf_r_f*(nvf_p_c*r1f/nvf_r_c+rfc);
 
  222     if (nvf_p_c < (nvf_r_c/nvf_r_f)) {
 
  223       nvf_p_f = nvf_r_f*nvf_p_c/nvf_r_c;
 
  231     r1 = nvf_r_c*nvf_r_f*(nvf_r_f-nvf_r_c);
 
  232     r2 = 2.*nvf_r_c*(1.-nvf_r_c)-nvf_r_f*(1.-nvf_r_f);
 
  234     if (nvf_p_c < (r1/r2)) {
 
  235       nvf_p_f = 2.*nvf_p_c;
 
  236     } 
else if (nvf_p_c <= (nvf_r_c*(1.+nvf_r_f-nvf_r_c)/nvf_r_f)) {
 
  237       rfc = (nvf_r_f-nvf_r_c)/(1.-nvf_r_c);
 
  238       r1f = (1.-nvf_r_f)/(1.-nvf_r_c);
 
  240       nvf_p_f = nvf_r_f*(nvf_p_c*r1f/nvf_r_c+rfc);
 
  285   cs_real_t blend, high_order, low_order, ratio;
 
  295       high_order = 2.*nvf_p_c;
 
  315     nvf_p_f = blend*high_order + (1.-blend)*low_order;
 
  318     if (c_courant < .7 && c_courant > .3) {
 
  319       nvf_p_f = nvf_p_f + (nvf_p_f - low_order)*(.7 - c_courant )/.4;
 
  320     } 
else if (c_courant >= .7) {
 
  325     if (c_courant <= .3) {
 
  327     } 
else if (c_courant <= .6) {
 
  329     } 
else if (c_courant <= .7) {
 
  334       high_order =  10.*(  (.7-c_courant)*
cs_math_fmin(1., nvf_p_c/.3)
 
  335                          + (c_courant-.6)*superbee);
 
  359     nvf_p_f = blend*high_order + (1.-blend)*low_order;
 
  382     nvf_p_f = blend*high_order + (1.-blend)*low_order;
 
  423   *testij =   grdpai[0]*grdpaj[0]
 
  424             + grdpai[1]*grdpaj[1]
 
  425             + grdpai[2]*grdpaj[2];
 
  427   if (i_massflux > 0.) {
 
  428     dcc =   gradi[0]*i_face_u_normal[0]
 
  429           + gradi[1]*i_face_u_normal[1]
 
  430           + gradi[2]*i_face_u_normal[2];
 
  431     ddi =   grdpai[0]*i_face_u_normal[0]
 
  432           + grdpai[1]*i_face_u_normal[1]
 
  433           + grdpai[2]*i_face_u_normal[2];
 
  437     dcc =   gradj[0]*i_face_u_normal[0]
 
  438           + gradj[1]*i_face_u_normal[1]
 
  439           + gradj[2]*i_face_u_normal[2];
 
  441     ddj =   grdpaj[0]*i_face_u_normal[0]
 
  442           + grdpaj[1]*i_face_u_normal[1]
 
  443           + grdpaj[2]*i_face_u_normal[2];
 
  470 template <cs_lnum_t str
ide>
 
  484   cs_real_t dcc[stride], ddi[stride], ddj[stride];
 
  491   for (
int i = 0; i < stride; i++) {
 
  492     *testij +=   gradsti[i][0]*gradstj[i][0]
 
  493                + gradsti[i][1]*gradstj[i][1]
 
  494                + gradsti[i][2]*gradstj[i][2];
 
  496     if (i_massflux > 0.) {
 
  497       dcc[i] =   gradi[i][0]*i_face_u_normal[0]
 
  498                + gradi[i][1]*i_face_u_normal[1]
 
  499                + gradi[i][2]*i_face_u_normal[2];
 
  500       ddi[i] =   gradsti[i][0]*i_face_u_normal[0]
 
  501                + gradsti[i][1]*i_face_u_normal[1]
 
  502                + gradsti[i][2]*i_face_u_normal[2];
 
  503       ddj[i] = (pj[i]-
pi[i])/distf;
 
  506       dcc[i] =   gradj[i][0]*i_face_u_normal[0]
 
  507                + gradj[i][1]*i_face_u_normal[1]
 
  508                + gradj[i][2]*i_face_u_normal[2];
 
  509       ddi[i] = (pj[i]-
pi[i])/distf;
 
  510       ddj[i] =   gradstj[i][0]*i_face_u_normal[0]
 
  511                + gradstj[i][1]*i_face_u_normal[1]
 
  512                + gradstj[i][2]*i_face_u_normal[2];
 
  550   cs_real_t gradpf[3] = {0.5*(gradi[0] + gradj[0]),
 
  551                          0.5*(gradi[1] + gradj[1]),
 
  552                          0.5*(gradi[2] + gradj[2])};
 
  582 template <cs_lnum_t str
ide>
 
  600   for (
int isou = 0; isou < stride; isou++) {
 
  602     for (
int jsou = 0; jsou < 3; jsou++)
 
  603       dpvf[jsou] = 0.5*( gradi[isou][jsou]
 
  604                        + gradj[isou][jsou]);
 
  611     pip[isou] = 
pi[isou] + recoi[isou];
 
  612     pjp[isou] = pj[isou] + recoj[isou];
 
  648   *pir = 
pi/relaxp - (1.-relaxp)/relaxp * pia;
 
  649   *pjr = pj/relaxp - (1.-relaxp)/relaxp * pja;
 
  651   *pipr = *pir + recoi;
 
  652   *pjpr = *pjr + recoj;
 
  676 template <cs_lnum_t str
ide>
 
  690   for (
int isou = 0; isou < stride; isou++) {
 
  691     pir[isou] = 
pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
 
  692     pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
 
  694     pipr[isou] = pir[isou] + recoi[isou];
 
  695     pjpr[isou] = pjr[isou] + recoj[isou];
 
  727 template <cs_lnum_t str
ide>
 
  732   for (
int isou = 0; isou < stride; isou++)
 
  753   *pf = pnd*pip + (1.-pnd)*pjp;
 
  770 template <cs_lnum_t str
ide>
 
  777   for (
int isou = 0; isou < stride; isou++)
 
  778     pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
 
  802   df[0] = i_face_cog[0] - cell_cen[0];
 
  803   df[1] = i_face_cog[1] - cell_cen[1];
 
  804   df[2] = i_face_cog[2] - cell_cen[2];
 
  824 template <cs_lnum_t str
ide>
 
  834   for (
cs_lnum_t jsou = 0; jsou < 3; jsou++)
 
  835     df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
 
  837   for (
cs_lnum_t isou = 0; isou < stride; isou++) {
 
  838      pf[isou] = 
p[isou] + df[0]*grad[isou][0]
 
  839                         + df[1]*grad[isou][1]
 
  840                         + df[2]*grad[isou][2];
 
  861   *pf = blencp * (*pf) + (1. - blencp) * 
p;
 
  879 template <cs_lnum_t str
ide>
 
  885   for (
int isou = 0; isou < stride; isou++)
 
  886     pf[isou] = blencp*(pf[isou])+(1.-blencp)*
p[isou];
 
  929   flui = 0.5*(i_massflux + fabs(i_massflux));
 
  930   fluj = 0.5*(i_massflux - fabs(i_massflux));
 
  932   fluxij[0] += iconvp*xcppi*(thetap*(flui*pifri + fluj*pjfri) - imasac*i_massflux*
pi);
 
  933   fluxij[1] += iconvp*xcppj*(thetap*(flui*pifrj + fluj*pjfrj) - imasac*i_massflux*pj);
 
  959 template <cs_lnum_t str
ide>
 
  976   flui = 0.5*(i_massflux + fabs(i_massflux));
 
  977   fluj = 0.5*(i_massflux - fabs(i_massflux));
 
  979   for (
int isou = 0; isou < stride; isou++) {
 
  980     fluxi[isou] +=  iconvp*(  thetap*(flui*pifri[isou] + fluj*pjfri[isou])
 
  981                             - imasac*i_massflux*
pi[isou]);
 
  982     fluxj[isou] +=  iconvp*(  thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
 
  983                             - imasac*i_massflux*pj[isou]);
 
 1012   fluxij[0] += idiffp*thetap*i_visc*(pipr -pjp);
 
 1013   fluxij[1] += idiffp*thetap*i_visc*(pip -pjpr);
 
 1035 template <cs_lnum_t str
ide>
 
 1047   for (
int isou = 0; isou < stride; isou++) {
 
 1048     fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
 
 1049     fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
 
 1165 template <cs_lnum_t str
ide>
 
 1189   cs_i_compute_quantities_strided<stride>(bldfrp,
 
 1201   cs_i_relax_c_val_strided<stride>(relaxp,
 
 1213   cs_upwind_f_val_strided<stride>(
pi, pifrj);
 
 1214   cs_upwind_f_val_strided<stride>(pir, pifri);
 
 1215   cs_upwind_f_val_strided<stride>(pj, pjfri);
 
 1216   cs_upwind_f_val_strided<stride>(pjr, pjfrj);
 
 1291 template <cs_lnum_t str
ide>
 
 1307   cs_i_compute_quantities_strided<stride>(bldfrp,
 
 1319   cs_upwind_f_val_strided<stride>(
pi, pif);
 
 1320   cs_upwind_f_val_strided<stride>(pj, pjf);
 
 1361                const double      relaxp,
 
 1362                const double      blencp,
 
 1435   } 
else if (ischcp == 0) {
 
 1542 template <cs_lnum_t str
ide>
 
 1573   cs_i_compute_quantities_strided<stride>(bldfrp,
 
 1585   cs_i_relax_c_val_strided<stride>(relaxp,
 
 1602     cs_centered_f_val_strided<stride>(weight, pip, pjpr, pifrj);
 
 1603     cs_centered_f_val_strided<stride>(weight, pipr, pjp, pifri);
 
 1604     cs_centered_f_val_strided<stride>(weight, pipr, pjp, pjfri);
 
 1605     cs_centered_f_val_strided<stride>(weight, pip, pjpr, pjfrj);
 
 1613     cs_solu_f_val_strided<stride>(cell_ceni,
 
 1618     cs_solu_f_val_strided<stride>(cell_ceni,
 
 1623     cs_solu_f_val_strided<stride>(cell_cenj,
 
 1628     cs_solu_f_val_strided<stride>(cell_cenj,
 
 1639   cs_blend_f_val_strided<stride>(blencp, 
pi, pifrj);
 
 1640   cs_blend_f_val_strided<stride>(blencp, pir, pifri);
 
 1641   cs_blend_f_val_strided<stride>(blencp, pj, pjfri);
 
 1642   cs_blend_f_val_strided<stride>(blencp, pjr, pjfrj);
 
 1680                  const double       blencp,
 
 1729   } 
else if (ischcp == 0) {
 
 1745   } 
else if (ischcp == 3) {
 
 1775     hybrid_blend_interp = 
fmin(hybrid_blend_i,hybrid_blend_j);
 
 1776     *pif = hybrid_blend_interp*(*pif) + (1. - hybrid_blend_interp)*pif_up;
 
 1777     *pjf = hybrid_blend_interp*(*pjf) + (1. - hybrid_blend_interp)*pjf_up;
 
 1839 template <cs_lnum_t str
ide>
 
 1864   cs_i_compute_quantities_strided<stride>(bldfrp,
 
 1881     cs_centered_f_val_strided<stride>(weight, pip, pjp, pif);
 
 1882     cs_centered_f_val_strided<stride>(weight, pip, pjp, pjf);
 
 1885   else if (ischcp == 3) {
 
 1890     cs_centered_f_val_strided<stride>(weight, pip, pjp, pif);
 
 1891     cs_centered_f_val_strided<stride>(weight, pip, pjp, pjf);
 
 1895     cs_real_t pif_up[stride], pjf_up[stride];
 
 1898     cs_solu_f_val_strided<stride>(cell_ceni,
 
 1903     cs_solu_f_val_strided<stride>(cell_cenj,
 
 1909     hybrid_blend_interp = 
fmin(hybrid_blend_i, hybrid_blend_j);
 
 1910     for (
int isou = 0; isou < stride; isou++) {
 
 1911       pif[isou] =   hybrid_blend_interp      *pif[isou]
 
 1912                  + (1. - hybrid_blend_interp)*pif_up[isou];
 
 1913       pjf[isou] =   hybrid_blend_interp      *pjf[isou]
 
 1914                  + (1. - hybrid_blend_interp)*pjf_up[isou];
 
 1922     cs_solu_f_val_strided<stride>(cell_ceni,
 
 1927     cs_solu_f_val_strided<stride>(cell_cenj,
 
 1938   cs_blend_f_val_strided<stride>(blencp, 
pi, pif);
 
 1939   cs_blend_f_val_strided<stride>(blencp, pj, pjf);
 
 1992                           const double       relaxp,
 
 1993                           const double       blencp,
 
 1994                           const double       blend_st,
 
 2027   *upwind_switch = 
false;
 
 2089     } 
else if (ischcp == 0) {
 
 2146     if (tesqck <= 0. || testij <= 0.) {
 
 2161       *upwind_switch = 
true;
 
 2239 template <cs_lnum_t str
ide>
 
 2279   cs_i_compute_quantities_strided<stride>(bldfrp,
 
 2291   cs_i_relax_c_val_strided<stride>(relaxp,
 
 2305     cs_slope_test_strided<stride>(
pi,
 
 2317     for (isou = 0; isou < stride; isou++) {
 
 2336         cs_solu_f_val(cell_ceni, i_face_cog, gradi[isou], pir[isou],
 
 2340         cs_solu_f_val(cell_cenj, i_face_cog, gradj[isou], pjr[isou],
 
 2350     if (tesqck <= 0. || testij <= 0.) {
 
 2352       cs_blend_f_val_strided<stride>(blend_st, 
pi, pifrj);
 
 2353       cs_blend_f_val_strided<stride>(blend_st, pir, pifri);
 
 2354       cs_blend_f_val_strided<stride>(blend_st, pj, pjfri);
 
 2355       cs_blend_f_val_strided<stride>(blend_st, pjr, pjfrj);
 
 2357       *upwind_switch = 
true;
 
 2364     cs_blend_f_val_strided<stride>(blencp, 
pi, pifrj);
 
 2365     cs_blend_f_val_strided<stride>(blencp, pir, pifri);
 
 2366     cs_blend_f_val_strided<stride>(blencp, pj, pjfri);
 
 2367     cs_blend_f_val_strided<stride>(blencp, pjr, pjfrj);
 
 2372     for (isou = 0; isou < stride; isou++) {
 
 2424                             const double       blencp,
 
 2425                             const double       blend_st,
 
 2453   *upwind_switch = 
false;
 
 2495     } 
else if (ischcp == 0) {
 
 2532     if (tesqck<=0. || testij<=0.) {
 
 2541       *upwind_switch = 
true;
 
 2585   if (i_massflux >= 0.) {
 
 2638   cs_real_t diff[3] = {cell_cen_d[0] - cell_cen_c[0],
 
 2639                        cell_cen_d[1] - cell_cen_c[1],
 
 2640                        cell_cen_d[2] - cell_cen_c[2]};
 
 2653   const cs_real_t dist_du = dist_dc + dist_cu;
 
 2659   const cs_real_t grad2c = ((p_d - p_c)/dist_dc - gradc)/dist_dc;
 
 2661   cs_real_t p_u = p_c + (grad2c*dist_cu - gradc)*dist_cu;
 
 2665   const cs_real_t nvf_r_f = (dist_fc+dist_cu)/dist_du;
 
 2666   const cs_real_t nvf_r_c = dist_cu/dist_du;
 
 2673   if (
CS_ABS(p_d-p_u) <= _small) {
 
 2677     const cs_real_t nvf_p_c = (p_c - p_u)/(p_d - p_u);
 
 2679     if (nvf_p_c <= 0. || nvf_p_c >= 1.) {
 
 2701       *pif = p_u + nvf_p_f*(p_d - p_u);
 
 2752 template <cs_lnum_t str
ide>
 
 2784   cs_i_compute_quantities_strided<stride>(bldfrp,
 
 2798     cs_slope_test_strided<stride>(
pi,
 
 2810     for (isou = 0; isou < stride; isou++) {
 
 2847     if (tesqck <= 0. || testij <= 0.) {
 
 2852       cs_blend_f_val_strided<stride>(blend_st, 
pi, pif);
 
 2853       cs_blend_f_val_strided<stride>(blend_st, pj,  pjf);
 
 2855       *upwind_switch = 
true;
 
 2861     cs_blend_f_val_strided<stride>(blencp, 
pi, pif);
 
 2862     cs_blend_f_val_strided<stride>(blencp, pj, pjf);
 
 2868     for (isou = 0; isou < stride; isou++) {
 
 2892   *recoi = bldfrp * (  gradi[0]*
diipb[0]
 
 2894                      + gradi[2]*
diipb[2]);
 
 2911 template <cs_lnum_t str
ide>
 
 2918   for (
int isou = 0; isou < stride; isou++) {
 
 2919     recoi[isou] = bldfrp * (  gradi[isou][0]*
diipb[0]
 
 2920                             + gradi[isou][1]*
diipb[1]
 
 2921                             + gradi[isou][2]*
diipb[2]);
 
 2946   *pir  = 
pi/relaxp - (1.-relaxp)/relaxp*pia;
 
 2947   *pipr = *pir + recoi;
 
 2966 template <cs_lnum_t str
ide>
 
 2975   for (
int isou = 0; isou < stride; isou++) {
 
 2976     pir[isou]  = 
pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
 
 2977     pipr[isou] = pir[isou] + recoi[isou];
 
 3036       flui = 0.5*(b_massflux +fabs(b_massflux));
 
 3037       fluj = 0.5*(b_massflux -fabs(b_massflux));
 
 3040     pfac  = inc*coefap + coefbp*pipr;
 
 3041     *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*
pi));
 
 3047     pfac = inc*coface + cofbce*pipr;
 
 3048     *flux += iconvp*xcpp*(-imasac*(b_massflux*
pi) + thetap*(pfac));
 
 3080 template <cs_lnum_t str
ide>
 
 3111       flui = 0.5*(b_massflux +fabs(b_massflux));
 
 3112       fluj = 0.5*(b_massflux -fabs(b_massflux));
 
 3114     for (
int isou = 0; isou < stride; isou++) {
 
 3115       pfac[isou]  = inc*coefap[isou];
 
 3116       for (
int jsou = 0; jsou < stride; jsou++) {
 
 3117         pfac[isou] += coefbp[isou][jsou]*pipr[jsou];
 
 3119       flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac[isou])
 
 3120                            - imasac*b_massflux*
pi[isou]);
 
 3128     for (
int isou = 0; isou < stride; isou++) {
 
 3129       pfac[isou]  = inc*coface[isou];
 
 3130       for (
int jsou = 0; jsou < stride; jsou++) {
 
 3131         pfac[isou] += cofbce[isou][jsou]*pipr[jsou];
 
 3133       flux[isou] += iconvp*(  thetap*pfac[isou]
 
 3134                             - imasac*b_massflux*
pi[isou]);
 
 3184     flui = 0.5*(b_massflux +fabs(b_massflux));
 
 3185     fluj = 0.5*(b_massflux -fabs(b_massflux));
 
 3188   pfac  = inc*coefap + coefbp*pipr;
 
 3189   *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*
pi));
 
 3218 template <cs_lnum_t str
ide>
 
 3241     flui = 0.5*(b_massflux +fabs(b_massflux));
 
 3242     fluj = 0.5*(b_massflux -fabs(b_massflux));
 
 3244   for (
int isou = 0; isou < stride; isou++) {
 
 3245     pfac[isou] = inc*coefa[isou];
 
 3246     for (
int jsou = 0; jsou < stride; jsou++) {
 
 3247       pfac[isou] += coefb[isou][jsou]*pipr[jsou];
 
 3249     flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac[isou])
 
 3250                          - imasac*b_massflux*
pi[isou]);
 
 3279   cs_real_t pfacd = inc*cofafp + cofbfp*pipr;
 
 3280   *flux += idiffp*thetap*b_visc*pfacd;
 
 3301 template <cs_lnum_t str
ide>
 
 3313   for (
int isou = 0; isou < stride; isou++) {
 
 3314     pfacd  = inc*cofaf[isou];
 
 3315     for (
int jsou = 0; jsou < stride; jsou++) {
 
 3316       pfacd += cofbf[isou][jsou]*pipr[jsou];
 
 3318     flux[isou] += idiffp*thetap*b_visc*pfacd;
 
 3340                const double       relaxp,
 
 3382 template <cs_lnum_t str
ide>
 
 3395   cs_b_compute_quantities_strided<stride>(
diipb,
 
 3400   cs_b_relax_c_val_strided<stride>(relaxp,
 
 3454 template <cs_lnum_t str
ide>
 
 3464   cs_b_compute_quantities_strided<stride>(
diipb,
 
 3469   for (
int isou = 0; isou< stride; isou++)
 
 3470     pip[isou] = 
pi[isou] + recoi[isou];
 
 3493   *fluxi += idiffp*b_visc*(
pi - pj);
 
 3512 template <cs_lnum_t str
ide>
 
 3520   for (
int k = 0; 
k < stride; 
k++)
 
 3521     fluxi[
k] += idiffp*b_visc*(
pi[
k] - pj[
k]);
 
cs_nvd_type_t
Definition: cs_convection_diffusion.h:123
@ CS_NVD_SUPERBEE
Definition: cs_convection_diffusion.h:128
@ CS_NVD_SMART
Definition: cs_convection_diffusion.h:126
@ CS_NVD_CUBISTA
Definition: cs_convection_diffusion.h:127
@ CS_NVD_STOIC
Definition: cs_convection_diffusion.h:132
@ CS_NVD_WASEB
Definition: cs_convection_diffusion.h:134
@ CS_NVD_CLAM
Definition: cs_convection_diffusion.h:131
@ CS_NVD_OSHER
Definition: cs_convection_diffusion.h:133
@ CS_NVD_VOF_CICSAM
Definition: cs_convection_diffusion.h:136
@ CS_NVD_GAMMA
Definition: cs_convection_diffusion.h:125
@ CS_NVD_MINMOD
Definition: cs_convection_diffusion.h:130
@ CS_NVD_VOF_HRIC
Definition: cs_convection_diffusion.h:135
@ CS_NVD_MUSCL
Definition: cs_convection_diffusion.h:129
static CS_F_HOST_DEVICE void cs_b_diff_flux_coupling(int idiffp, cs_real_t pi, cs_real_t pj, cs_real_t b_visc, cs_real_t *fluxi)
Add diffusive flux to flux at an internal coupling face.
Definition: cs_convection_diffusion_priv.h:3487
static CS_F_HOST_DEVICE void cs_i_diff_flux_strided(int idiffp, cs_real_t thetap, const cs_real_t pip[stride], const cs_real_t pjp[stride], const cs_real_t pipr[stride], const cs_real_t pjpr[stride], const cs_real_t i_visc, cs_real_t fluxi[stride], cs_real_t fluxj[stride])
Add diffusive fluxes to fluxes at face ij.
Definition: cs_convection_diffusion_priv.h:1037
static CS_F_HOST_DEVICE void cs_centered_f_val_strided(double pnd, const cs_real_t pip[stride], const cs_real_t pjp[stride], cs_real_t pf[stride])
Prepare value at face ij by using a centered scheme.
Definition: cs_convection_diffusion_priv.h:772
static CS_F_HOST_DEVICE void cs_i_cd_steady_slope_test(bool *upwind_switch, const int iconvp, const cs_real_t bldfrp, const int ischcp, const double relaxp, const double blencp, const double blend_st, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t cell_ceni[3], const cs_real_t cell_cenj[3], const cs_real_t i_face_u_normal[3], const cs_real_t i_face_cog[3], const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t i_massflux, const cs_real_t gradi[3], const cs_real_t gradj[3], const cs_real_t gradupi[3], const cs_real_t gradupj[3], const cs_real_t gradsti[3], const cs_real_t gradstj[3], const cs_real_t pi, const cs_real_t pj, const cs_real_t pia, const cs_real_t pja, cs_real_t *pifri, cs_real_t *pifrj, cs_real_t *pjfri, cs_real_t *pjfrj, cs_real_t *pip, cs_real_t *pjp, cs_real_t *pipr, cs_real_t *pjpr)
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:1988
static CS_F_HOST_DEVICE void cs_i_cd_unsteady_strided(cs_real_t bldfrp, int ischcp, double blencp, cs_real_t weight, const cs_real_t cell_ceni[3], const cs_real_t cell_cenj[3], const cs_real_t i_face_cog[3], const cs_real_t hybrid_blend_i, const cs_real_t hybrid_blend_j, const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], cs_real_t pif[stride], cs_real_t pjf[stride], cs_real_t pip[stride], cs_real_t pjp[stride])
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion_priv.h:1841
static CS_F_HOST_DEVICE void cs_b_diff_flux_strided(int idiffp, cs_real_t thetap, int inc, const cs_real_t pipr[stride], const cs_real_t cofaf[stride], const cs_real_t cofbf[stride][stride], cs_real_t b_visc, cs_real_t flux[stride])
Add diffusive flux to flux at boundary face.
Definition: cs_convection_diffusion_priv.h:3303
static CS_F_HOST_DEVICE void cs_b_cd_steady(const cs_real_t bldfrp, const double relaxp, const cs_real_3_t diipb, const cs_real_3_t gradi, const cs_real_t pi, const cs_real_t pia, cs_real_t *pir, cs_real_t *pipr)
Handle preparation of boundary face values for the flux computation in case of a steady algorithm.
Definition: cs_convection_diffusion_priv.h:3339
static CS_F_HOST_DEVICE void cs_i_cd_unsteady(const cs_real_t bldfrp, const int ischcp, const double blencp, const cs_real_t weight, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_cog, const cs_real_t hybrid_blend_i, const cs_real_t hybrid_blend_j, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t gradupi, const cs_real_3_t gradupj, const cs_real_t pi, const cs_real_t pj, cs_real_t *pif, cs_real_t *pjf, cs_real_t *pip, cs_real_t *pjp)
Handle preparation of internal face values for the fluxes computation in case of a unsteady algorithm...
Definition: cs_convection_diffusion_priv.h:1678
static CS_F_HOST_DEVICE void cs_i_relax_c_val_strided(cs_real_t relaxp, const cs_real_t pia[stride], const cs_real_t pja[stride], const cs_real_t recoi[stride], const cs_real_t recoj[stride], const cs_real_t pi[stride], const cs_real_t pj[stride], cs_real_t pir[stride], cs_real_t pjr[stride], cs_real_t pipr[stride], cs_real_t pjpr[stride])
Compute relaxed values at cell i and j.
Definition: cs_convection_diffusion_priv.h:678
static CS_F_HOST_DEVICE void cs_i_cd_steady_upwind_strided(const cs_real_t bldfrp, const cs_real_t relaxp, const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], const cs_real_t pia[stride], const cs_real_t pja[stride], cs_real_t pifri[stride], cs_real_t pifrj[stride], cs_real_t pjfri[stride], cs_real_t pjfrj[stride], cs_real_t pip[stride], cs_real_t pjp[stride], cs_real_t pipr[stride], cs_real_t pjpr[stride])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:1167
static CS_F_HOST_DEVICE void cs_i_cd_unsteady_slope_test(bool *upwind_switch, const int iconvp, const cs_real_t bldfrp, const int ischcp, const double blencp, const double blend_st, const cs_real_t weight, const cs_real_t i_dist, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_u_normal, const cs_real_3_t i_face_cog, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_t i_massflux, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t gradupi, const cs_real_3_t gradupj, const cs_real_3_t gradsti, const cs_real_3_t gradstj, const cs_real_t pi, const cs_real_t pj, cs_real_t *pif, cs_real_t *pjf, cs_real_t *pip, cs_real_t *pjp)
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:2420
static CS_F_HOST_DEVICE void cs_b_relax_c_val_strided(const double relaxp, const cs_real_t pi[stride], const cs_real_t pia[stride], const cs_real_t recoi[stride], cs_real_t pir[stride], cs_real_t pipr[stride])
Compute relaxed values at boundary cell i.
Definition: cs_convection_diffusion_priv.h:2968
static CS_F_HOST_DEVICE void cs_i_compute_quantities_strided(const cs_real_t bldfrp, const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], cs_real_t recoi[stride], cs_real_t recoj[stride], cs_real_t pip[stride], cs_real_t pjp[stride])
Reconstruct values in I' and J'.
Definition: cs_convection_diffusion_priv.h:584
static CS_F_HOST_DEVICE void cs_b_cd_unsteady(const cs_real_t bldfrp, const cs_real_3_t diipb, const cs_real_3_t gradi, const cs_real_t pi, cs_real_t *pip)
Handle preparation of boundary face values for the flux computation in case of an unsteady algorithm.
Definition: cs_convection_diffusion_priv.h:3422
static CS_F_HOST_DEVICE void cs_b_upwind_flux(const int iconvp, const cs_real_t thetap, const int imasac, const int inc, const int bc_type, const cs_real_t pi, const cs_real_t pir, const cs_real_t pipr, const cs_real_t coefap, const cs_real_t coefbp, const cs_real_t b_massflux, const cs_real_t xcpp, cs_real_t *flux)
Add convective flux (substracting the mass accumulation from it) to flux at boundary face....
Definition: cs_convection_diffusion_priv.h:3163
static CS_F_HOST_DEVICE void cs_solu_f_val(const cs_real_t cell_cen[3], const cs_real_t i_face_cog[3], const cs_real_t grad[3], const cs_real_t p, cs_real_t *pf)
Prepare value at face ij by using a Second Order Linear Upwind scheme.
Definition: cs_convection_diffusion_priv.h:794
static void cs_sync_scalar_halo(const cs_mesh_t *m, cs_halo_type_t halo_type, cs_real_t pvar[])
Definition: cs_convection_diffusion_priv.h:67
static CS_F_HOST_DEVICE void cs_i_relax_c_val(const double relaxp, const cs_real_t pia, const cs_real_t pja, const cs_real_t recoi, const cs_real_t recoj, const cs_real_t pi, const cs_real_t pj, cs_real_t *pir, cs_real_t *pjr, cs_real_t *pipr, cs_real_t *pjpr)
Compute relaxed values at cell i and j.
Definition: cs_convection_diffusion_priv.h:636
static CS_F_HOST_DEVICE cs_real_t cs_nvd_vof_scheme_scalar(cs_nvd_type_t limiter, const cs_real_t i_face_u_normal[3], cs_real_t nvf_p_c, cs_real_t nvf_r_f, cs_real_t nvf_r_c, const cs_real_t gradv_c[3], const cs_real_t c_courant)
Compute the normalised face scalar using the specified NVD scheme for the case of a Volume-of-Fluid (...
Definition: cs_convection_diffusion_priv.h:274
static CS_F_HOST_DEVICE void cs_b_cd_unsteady_strided(cs_real_t bldfrp, const cs_real_t diipb[3], const cs_real_t gradi[stride][3], const cs_real_t pi[stride], cs_real_t pip[stride])
Handle preparation of boundary face values for the flux computation in case of a steady algorithm.
Definition: cs_convection_diffusion_priv.h:3456
static CS_F_HOST_DEVICE void cs_b_upwind_flux_strided(int iconvp, cs_real_t thetap, int imasac, int inc, int bc_type, const cs_real_t pi[stride], const cs_real_t pir[stride], const cs_real_t pipr[stride], const cs_real_t coefa[stride], const cs_real_t coefb[stride][stride], cs_real_t b_massflux, cs_real_t pfac[stride], cs_real_t flux[stride])
Add convective flux (substracting the mass accumulation from it) to flux at boundary face....
Definition: cs_convection_diffusion_priv.h:3220
static CS_F_HOST_DEVICE void cs_b_diff_flux_coupling_strided(int idiffp, const cs_real_t pi[stride], const cs_real_t pj[stride], cs_real_t b_visc, cs_real_t fluxi[stride])
Add diffusive flux to flux at an internal coupling face for a vector.
Definition: cs_convection_diffusion_priv.h:3514
static CS_F_HOST_DEVICE void cs_slope_test(const cs_real_t pi, const cs_real_t pj, const cs_real_t distf, const cs_real_t i_face_u_normal[3], const cs_real_t gradi[3], const cs_real_t gradj[3], const cs_real_t grdpai[3], const cs_real_t grdpaj[3], const cs_real_t i_massflux, cs_real_t *testij, cs_real_t *tesqck)
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion_priv.h:407
static CS_F_HOST_DEVICE void cs_upwind_f_val_strided(const cs_real_t p[stride], cs_real_t pf[stride])
Prepare value at face ij by using an upwind scheme.
Definition: cs_convection_diffusion_priv.h:729
static CS_F_HOST_DEVICE void cs_i_cd_unsteady_slope_test_strided(bool *upwind_switch, int iconvp, cs_real_t bldfrp, int ischcp, double blencp, double blend_st, cs_real_t weight, cs_real_t i_dist, const cs_real_t cell_ceni[3], const cs_real_t cell_cenj[3], const cs_real_t i_face_u_normal[3], const cs_real_t i_face_cog[3], const cs_real_t diipf[3], const cs_real_t djjpf[3], cs_real_t i_massflux, const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t grdpai[stride][3], const cs_real_t grdpaj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], cs_real_t pif[stride], cs_real_t pjf[stride], cs_real_t pip[stride], cs_real_t pjp[stride])
Handle preparation of internal face values for the fluxes computation in case of a unsteady algorithm...
Definition: cs_convection_diffusion_priv.h:2754
static CS_F_HOST_DEVICE void cs_b_relax_c_val(const double relaxp, const cs_real_t pi, const cs_real_t pia, const cs_real_t recoi, cs_real_t *pir, cs_real_t *pipr)
Compute relaxed values at boundary cell i.
Definition: cs_convection_diffusion_priv.h:2939
static CS_F_HOST_DEVICE void cs_b_imposed_conv_flux_strided(int iconvp, cs_real_t thetap, int imasac, int inc, int bc_type, int icvfli, const cs_real_t pi[stride], const cs_real_t pir[stride], const cs_real_t pipr[stride], const cs_real_t coefap[stride], const cs_real_t coefbp[stride][stride], const cs_real_t coface[stride], const cs_real_t cofbce[stride][stride], cs_real_t b_massflux, cs_real_t pfac[stride], cs_real_t flux[stride])
Add convective flux (substracting the mass accumulation from it) to flux at boundary face....
Definition: cs_convection_diffusion_priv.h:3082
static CS_F_HOST_DEVICE void cs_i_cd_unsteady_upwind_strided(const cs_real_t bldfrp, const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], cs_real_t pif[stride], cs_real_t pjf[stride], cs_real_t pip[stride], cs_real_t pjp[stride])
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion_priv.h:1293
static CS_F_HOST_DEVICE void cs_centered_f_val(double pnd, cs_real_t pip, cs_real_t pjp, cs_real_t *pf)
Prepare value at face ij by using a centered scheme.
Definition: cs_convection_diffusion_priv.h:748
static CS_F_HOST_DEVICE void cs_b_compute_quantities_strided(const cs_real_t diipb[3], const cs_real_t gradi[stride][3], const cs_real_t bldfrp, cs_real_t recoi[stride])
Reconstruct values in I' at boundary cell i.
Definition: cs_convection_diffusion_priv.h:2913
static CS_F_HOST_DEVICE void cs_blend_f_val_strided(const double blencp, const cs_real_t p[stride], cs_real_t pf[stride])
Blend face values for a centered or SOLU scheme with face values for an upwind scheme.
Definition: cs_convection_diffusion_priv.h:881
static CS_F_HOST_DEVICE void cs_i_compute_quantities(const cs_real_t bldfrp, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_t pi, const cs_real_t pj, cs_real_t *recoi, cs_real_t *recoj, cs_real_t *pip, cs_real_t *pjp)
Reconstruct values in I' and J'.
Definition: cs_convection_diffusion_priv.h:538
static CS_F_HOST_DEVICE void cs_b_compute_quantities(const cs_real_3_t diipb, const cs_real_3_t gradi, const cs_real_t bldfrp, cs_real_t *recoi)
Reconstruct values in I' at boundary cell i.
Definition: cs_convection_diffusion_priv.h:2887
static CS_F_HOST_DEVICE void cs_i_conv_flux_strided(int iconvp, cs_real_t thetap, int imasac, const cs_real_t pi[stride], const cs_real_t pj[stride], const cs_real_t pifri[stride], const cs_real_t pifrj[stride], const cs_real_t pjfri[stride], const cs_real_t pjfrj[stride], cs_real_t i_massflux, cs_real_t fluxi[stride], cs_real_t fluxj[stride])
Add convective fluxes (substracting the mass accumulation from them) to fluxes at face ij.
Definition: cs_convection_diffusion_priv.h:961
static CS_F_HOST_DEVICE void cs_upwind_f_val(const cs_real_t p, cs_real_t *pf)
Prepare value at face ij by using an upwind scheme.
Definition: cs_convection_diffusion_priv.h:709
static CS_F_HOST_DEVICE void cs_b_diff_flux(const int idiffp, const cs_real_t thetap, const int inc, const cs_real_t pipr, const cs_real_t cofafp, const cs_real_t cofbfp, const cs_real_t b_visc, cs_real_t *flux)
Add diffusive flux to flux at boundary face.
Definition: cs_convection_diffusion_priv.h:3270
static CS_F_HOST_DEVICE void cs_i_cd_unsteady_nvd(const cs_nvd_type_t limiter, const double beta, const cs_real_3_t cell_cen_c, const cs_real_3_t cell_cen_d, const cs_real_3_t i_face_u_normal, const cs_real_3_t i_face_cog, const cs_real_3_t gradv_c, const cs_real_t p_c, const cs_real_t p_d, const cs_real_t local_max_c, const cs_real_t local_min_c, const cs_real_t courant_c, cs_real_t *pif, cs_real_t *pjf)
Handle preparation of internal face values for the convection flux computation in case of an unsteady...
Definition: cs_convection_diffusion_priv.h:2618
static CS_F_HOST_DEVICE void cs_i_cd_steady_strided(cs_real_t bldfrp, int ischcp, double relaxp, double blencp, cs_real_t weight, const cs_real_t cell_ceni[3], const cs_real_t cell_cenj[3], const cs_real_t i_face_cog[3], const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], const cs_real_t pia[stride], const cs_real_t pja[stride], cs_real_t pifri[stride], cs_real_t pifrj[stride], cs_real_t pjfri[stride], cs_real_t pjfrj[stride], cs_real_t pip[stride], cs_real_t pjp[stride], cs_real_t pipr[stride], cs_real_t pjpr[stride])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:1544
static CS_F_HOST_DEVICE void cs_i_diff_flux(const int idiffp, const cs_real_t thetap, const cs_real_t pip, const cs_real_t pjp, const cs_real_t pipr, const cs_real_t pjpr, const cs_real_t i_visc, cs_real_t fluxij[2])
Add diffusive fluxes to fluxes at face ij.
Definition: cs_convection_diffusion_priv.h:1003
static CS_F_HOST_DEVICE void cs_i_cd_unsteady_upwind(const cs_real_t bldfrp, const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[3], const cs_real_t gradj[3], const cs_real_t pi, const cs_real_t pj, cs_real_t *pif, cs_real_t *pjf, cs_real_t *pip, cs_real_t *pjp)
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion_priv.h:1239
static CS_F_HOST_DEVICE void cs_solu_f_val_strided(const cs_real_t cell_cen[3], const cs_real_t i_face_cog[3], const cs_real_t grad[stride][3], const cs_real_t p[stride], cs_real_t pf[stride])
Prepare value at face ij by using a Second Order Linear Upwind scheme.
Definition: cs_convection_diffusion_priv.h:826
static CS_F_HOST_DEVICE void cs_b_cd_steady_strided(cs_real_t bldfrp, double relaxp, const cs_real_t diipb[3], const cs_real_t gradi[stride][3], const cs_real_t pi[stride], const cs_real_t pia[stride], cs_real_t pir[stride], cs_real_t pipr[stride])
Handle preparation of boundary face values for the flux computation in case of a steady algorithm.
Definition: cs_convection_diffusion_priv.h:3384
static CS_F_HOST_DEVICE void cs_central_downwind_cells(const cs_lnum_t ii, const cs_lnum_t jj, const cs_real_t i_massflux, cs_lnum_t *ic, cs_lnum_t *id)
Determine the upwind and downwind sides of an internal face and matching cell indices.
Definition: cs_convection_diffusion_priv.h:2579
static CS_F_HOST_DEVICE void cs_i_conv_flux(const int iconvp, const cs_real_t thetap, const int imasac, const cs_real_t pi, const cs_real_t pj, const cs_real_t pifri, const cs_real_t pifrj, const cs_real_t pjfri, const cs_real_t pjfrj, const cs_real_t i_massflux, const cs_real_t xcppi, const cs_real_t xcppj, cs_real_2_t fluxij)
Add convective fluxes (substracting the mass accumulation from them) to fluxes at face ij.
Definition: cs_convection_diffusion_priv.h:913
static CS_F_HOST_DEVICE void cs_i_cd_steady(const cs_real_t bldfrp, const int ischcp, const double relaxp, const double blencp, const cs_real_t weight, const cs_real_t cell_ceni[3], const cs_real_t cell_cenj[3], const cs_real_t i_face_cog[3], const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[3], const cs_real_t gradj[3], const cs_real_t gradupi[3], const cs_real_t gradupj[3], const cs_real_t pi, const cs_real_t pj, const cs_real_t pia, const cs_real_t pja, cs_real_t *pifri, cs_real_t *pifrj, cs_real_t *pjfri, cs_real_t *pjfrj, cs_real_t *pip, cs_real_t *pjp, cs_real_t *pipr, cs_real_t *pjpr)
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:1359
static CS_F_HOST_DEVICE cs_real_t cs_nvd_scheme_scalar(const cs_nvd_type_t limiter, const cs_real_t nvf_p_c, const cs_real_t nvf_r_f, const cs_real_t nvf_r_c)
Compute the normalized face scalar using the specified NVD scheme.
Definition: cs_convection_diffusion_priv.h:89
static CS_F_HOST_DEVICE void cs_blend_f_val(const double blencp, const cs_real_t p, cs_real_t *pf)
Blend face values for a centered or SOLU scheme with face values for an upwind scheme.
Definition: cs_convection_diffusion_priv.h:857
static CS_F_HOST_DEVICE void cs_i_cd_steady_slope_test_strided(bool *upwind_switch, int iconvp, cs_real_t bldfrp, int ischcp, double relaxp, double blencp, double blend_st, cs_real_t weight, cs_real_t i_dist, const cs_real_t cell_ceni[3], const cs_real_t cell_cenj[3], const cs_real_t i_face_u_normal[3], const cs_real_t i_face_cog[3], const cs_real_t diipf[3], const cs_real_t djjpf[3], cs_real_t i_massflux, const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t grdpai[stride][3], const cs_real_t grdpaj[stride][3], const cs_real_t pi[stride], const cs_real_t pj[stride], const cs_real_t pia[stride], const cs_real_t pja[stride], cs_real_t pifri[stride], cs_real_t pifrj[stride], cs_real_t pjfri[stride], cs_real_t pjfrj[stride], cs_real_t pip[stride], cs_real_t pjp[stride], cs_real_t pipr[stride], cs_real_t pjpr[stride])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:2241
static CS_F_HOST_DEVICE void cs_slope_test_strided(const cs_real_t pi[stride], const cs_real_t pj[stride], const cs_real_t distf, const cs_real_t i_face_u_normal[3], const cs_real_t gradi[stride][3], const cs_real_t gradj[stride][3], const cs_real_t gradsti[stride][3], const cs_real_t gradstj[stride][3], const cs_real_t i_massflux, cs_real_t *testij, cs_real_t *tesqck)
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion_priv.h:472
static CS_F_HOST_DEVICE void cs_b_imposed_conv_flux(int iconvp, cs_real_t thetap, int imasac, int inc, int bc_type, int icvfli, cs_real_t pi, cs_real_t pir, cs_real_t pipr, cs_real_t coefap, cs_real_t coefbp, cs_real_t coface, cs_real_t cofbce, cs_real_t b_massflux, cs_real_t xcpp, cs_real_t *flux)
Add convective flux (substracting the mass accumulation from it) to flux at boundary face....
Definition: cs_convection_diffusion_priv.h:3008
static CS_F_HOST_DEVICE void cs_i_cd_steady_upwind(const cs_real_t bldfrp, const cs_real_t relaxp, const cs_real_t diipf[3], const cs_real_t djjpf[3], const cs_real_t gradi[3], const cs_real_t gradj[3], const cs_real_t pi, const cs_real_t pj, const cs_real_t pia, const cs_real_t pja, cs_real_t *pifri, cs_real_t *pifrj, cs_real_t *pjfri, cs_real_t *pjfrj, cs_real_t *pip, cs_real_t *pjp, cs_real_t *pipr, cs_real_t *pjpr)
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion_priv.h:1080
#define CS_F_HOST_DEVICE
Definition: cs_defs.h:546
double cs_real_t
Floating-point value.
Definition: cs_defs.h:332
#define CS_ABS(a)
Definition: cs_defs.h:490
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:347
cs_real_t cs_real_2_t[2]
vector of 2 floating-point values
Definition: cs_defs.h:346
#define CS_UNUSED(x)
Definition: cs_defs.h:514
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:325
@ p
Definition: cs_field_pointer.h:67
@ k
Definition: cs_field_pointer.h:70
void cs_halo_sync_var(const cs_halo_t *halo, cs_halo_type_t sync_mode, cs_real_t var[])
Definition: cs_halo.cpp:2071
cs_halo_type_t
Definition: cs_halo.h:56
static CS_F_HOST_DEVICE cs_real_t cs_math_3_distance(const cs_real_t xa[3], const cs_real_t xb[3])
Compute the (euclidean) distance between two points xa and xb in a Cartesian coordinate system of dim...
Definition: cs_math.h:324
static CS_F_HOST_DEVICE cs_real_t cs_math_3_dot_product(const cs_real_t u[3], const cs_real_t v[3])
Compute the dot product of two vectors of 3 real values.
Definition: cs_math.h:391
const cs_real_t cs_math_epzero
static CS_F_HOST_DEVICE cs_real_t cs_math_3_norm(const cs_real_t v[3])
Compute the euclidean norm of a vector of dimension 3.
Definition: cs_math.h:460
static CS_F_HOST_DEVICE cs_real_t cs_math_fabs(cs_real_t x)
Compute the absolute value of a real value.
Definition: cs_math.h:163
static CS_F_HOST_DEVICE cs_real_t cs_math_fmin(cs_real_t x, cs_real_t y)
Compute the min value of two real values.
Definition: cs_math.h:181
static CS_F_HOST_DEVICE cs_real_t cs_math_sq(cs_real_t x)
Compute the square of a real value.
Definition: cs_math.h:242
static CS_F_HOST_DEVICE cs_real_t cs_math_fmax(cs_real_t x, cs_real_t y)
Compute the max value of two real values.
Definition: cs_math.h:200
@ CS_COUPLED_FD
Definition: cs_parameters.h:101
integer, dimension(:), allocatable, target icvfli
boundary convection flux indicator of a Rusanov or an analytical flux (some boundary contributions of...
Definition: cfpoin.f90:55
double precision pi
value with 16 digits
Definition: cstnum.f90:48
double precision, dimension(:,:), pointer diipb
vector II' for interior faces for every boundary face, the three components of the vector ....
Definition: mesh.f90:168
real(c_double), pointer, save fmin
Definition: coincl.f90:185
real(c_double), dimension(:), pointer, save b2
Definition: cpincl.f90:109
real(c_double), dimension(:), pointer, save b1
Definition: cpincl.f90:109
cs_halo_t * halo
Definition: cs_mesh.h:156