programmer's documentation
cs_convection_diffusion.h
Go to the documentation of this file.
1 #ifndef __CS_CONVECTION_DIFFUSION_H__
2 #define __CS_CONVECTION_DIFFUSION_H__
3 
4 /*============================================================================
5  * Convection-diffusion operators.
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2016 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 #include "cs_defs.h"
31 
32 /*----------------------------------------------------------------------------
33  * Local headers
34  *----------------------------------------------------------------------------*/
35 
36 #include "cs_base.h"
37 #include "cs_halo.h"
38 
39 /*----------------------------------------------------------------------------*/
40 
42 
43 /*=============================================================================
44  * Local Macro definitions
45  *============================================================================*/
46 
47 enum {X, Y, Z};
48 #define _CS_DOT_PRODUCT(vect1, vect2) \
49  (vect1[X] * vect2[X] + vect1[Y] * vect2[Y] + vect1[Z] * vect2[Z])
50 
51 /*============================================================================
52  * Type definition
53  *============================================================================*/
54 
55 /*============================================================================
56  * Global variables
57  *============================================================================*/
58 
59 /*============================================================================
60  * Private function definitions
61  *============================================================================*/
62 
63 /*----------------------------------------------------------------------------*/
74 /*----------------------------------------------------------------------------*/
75 
76 cs_real_t cs_limiter_function(const int limiter,
77  cs_real_t r);
78 
79 /*----------------------------------------------------------------------------*/
98 /*----------------------------------------------------------------------------*/
99 
100 inline static void
102  const cs_real_t thetap,
103  const int imasac,
104  const int limiter,
105  const cs_real_t lambdaij,
106  const cs_real_t rij,
107  const cs_real_t pi,
108  const cs_real_t pj,
109  const cs_real_t pifri,
110  const cs_real_t pifrj,
111  const cs_real_t pjfri,
112  const cs_real_t pjfrj,
113  const cs_real_t i_massflux,
114  cs_real_2_t fluxij)
115 {
116  cs_real_t flui, fluj;
117  cs_real_t phi;
118  phi = cs_limiter_function(limiter, rij);
119 
120  flui = 0.5*(i_massflux + fabs(i_massflux));
121  fluj = 0.5*(i_massflux - fabs(i_massflux));
122 
123  // FIXME not homogeneous, divide by rho
124  fluxij[0] += iconvp * (thetap * (flui*pifri + fluj*pjfri
125  + lambdaij * phi*0.5*( CS_ABS(i_massflux)
126  - lambdaij*i_massflux
127  *i_massflux)
128  * (pj - pi))
129  * - imasac * i_massflux * pi);
130  fluxij[1] += iconvp * (thetap * (flui*pifrj + fluj*pjfrj
131  + lambdaij * phi*0.5*( CS_ABS(i_massflux)
132  - lambdaij*i_massflux
133  *i_massflux)
134  * (pj-pi))
135  - imasac * i_massflux * pj);
136 }
137 
138 /*----------------------------------------------------------------------------*/
155 /*----------------------------------------------------------------------------*/
156 
157 inline static void
159  const cs_real_t pj,
160  const cs_real_t distf,
161  const cs_real_t srfan,
162  const cs_real_3_t i_face_normal,
163  const cs_real_3_t gradi,
164  const cs_real_3_t gradj,
165  const cs_real_3_t grdpai,
166  const cs_real_3_t grdpaj,
167  const cs_real_t i_massflux,
168  double *testij,
169  double *tesqck)
170 {
171  double testi, testj;
172  double dcc, ddi, ddj;
173 
174  /* Slope test
175  ----------*/
176 
177  testi = grdpai[0]*i_face_normal[0]
178  + grdpai[1]*i_face_normal[1]
179  + grdpai[2]*i_face_normal[2];
180  testj = grdpaj[0]*i_face_normal[0]
181  + grdpaj[1]*i_face_normal[1]
182  + grdpaj[2]*i_face_normal[2];
183  *testij = grdpai[0]*grdpaj[0]
184  + grdpai[1]*grdpaj[1]
185  + grdpai[2]*grdpaj[2];
186 
187  if (i_massflux>0.) {
188  dcc = gradi[0]*i_face_normal[0]
189  + gradi[1]*i_face_normal[1]
190  + gradi[2]*i_face_normal[2];
191  ddi = testi;
192  ddj = (pj-pi)/distf *srfan;
193  } else {
194  dcc = gradj[0]*i_face_normal[0]
195  + gradj[1]*i_face_normal[1]
196  + gradj[2]*i_face_normal[2];
197  ddi = (pj-pi)/distf *srfan;
198  ddj = testj;
199  }
200  *tesqck = pow(dcc, 2.) - pow(ddi-ddj, 2.);
201 }
202 
203 /*----------------------------------------------------------------------------*/
220 /*----------------------------------------------------------------------------*/
221 
222 inline static void
224  const cs_real_3_t pj,
225  const cs_real_t distf,
226  const cs_real_t srfan,
227  const cs_real_3_t i_face_normal,
228  const cs_real_33_t gradi,
229  const cs_real_33_t gradj,
230  const cs_real_33_t grdpai,
231  const cs_real_33_t grdpaj,
232  const cs_real_t i_massflux,
233  cs_real_t testij[3],
234  cs_real_t tesqck[3])
235 {
236  double testi[3], testj[3];
237  double dcc[3], ddi[3], ddj[3];
238 
239  /* Slope test
240  ----------*/
241  for (int isou = 0; isou < 3; isou++) {
242  testi[isou] = grdpai[isou][0]*i_face_normal[0]
243  + grdpai[isou][1]*i_face_normal[1]
244  + grdpai[isou][2]*i_face_normal[2];
245  testj[isou] = grdpaj[isou][0]*i_face_normal[0]
246  + grdpaj[isou][1]*i_face_normal[1]
247  + grdpaj[isou][2]*i_face_normal[2];
248  testij[isou] = grdpai[isou][0]*grdpaj[isou][0]
249  + grdpai[isou][1]*grdpaj[isou][1]
250  + grdpai[isou][2]*grdpaj[isou][2];
251 
252  if (i_massflux>0.) {
253  dcc[isou] = gradi[isou][0]*i_face_normal[0]
254  + gradi[isou][1]*i_face_normal[1]
255  + gradi[isou][2]*i_face_normal[2];
256  ddi[isou] = testi[isou];
257  ddj[isou] = (pj[isou]-pi[isou])/distf *srfan;
258  } else {
259  dcc[isou] = gradj[isou][0]*i_face_normal[0]
260  + gradj[isou][1]*i_face_normal[1]
261  + gradj[isou][2]*i_face_normal[2];
262  ddi[isou] = (pj[isou]-pi[isou])/distf *srfan;
263  ddj[isou] = testj[isou];
264  }
265  tesqck[isou] = pow(dcc[isou], 2.) - pow(ddi[isou]-ddj[isou], 2.);
266  }
267 }
268 
269 /*----------------------------------------------------------------------------*/
286 /*----------------------------------------------------------------------------*/
287 
288 inline static void
290  const cs_real_6_t pj,
291  const cs_real_t distf,
292  const cs_real_t srfan,
293  const cs_real_3_t i_face_normal,
294  const cs_real_63_t gradi,
295  const cs_real_63_t gradj,
296  const cs_real_63_t grdpai,
297  const cs_real_63_t grdpaj,
298  const cs_real_t i_massflux,
299  cs_real_t testij[6],
300  cs_real_t tesqck[6])
301 {
302  double testi[6], testj[6];
303  double dcc[6], ddi[6], ddj[6];
304 
305  /* Slope test */
306 
307  for (int isou = 0; isou < 6; isou++) {
308  testi[isou] = grdpai[isou][0]*i_face_normal[0]
309  + grdpai[isou][1]*i_face_normal[1]
310  + grdpai[isou][2]*i_face_normal[2];
311  testj[isou] = grdpaj[isou][0]*i_face_normal[0]
312  + grdpaj[isou][1]*i_face_normal[1]
313  + grdpaj[isou][2]*i_face_normal[2];
314  testij[isou] = grdpai[isou][0]*grdpaj[isou][0]
315  + grdpai[isou][1]*grdpaj[isou][1]
316  + grdpai[isou][2]*grdpaj[isou][2];
317 
318  if (i_massflux>0.) {
319  dcc[isou] = gradi[isou][0]*i_face_normal[0]
320  + gradi[isou][1]*i_face_normal[1]
321  + gradi[isou][2]*i_face_normal[2];
322  ddi[isou] = testi[isou];
323  ddj[isou] = (pj[isou]-pi[isou])/distf *srfan;
324  } else {
325  dcc[isou] = gradj[isou][0]*i_face_normal[0]
326  + gradj[isou][1]*i_face_normal[1]
327  + gradj[isou][2]*i_face_normal[2];
328  ddi[isou] = (pj[isou]-pi[isou])/distf *srfan;
329  ddj[isou] = testj[isou];
330  }
331  tesqck[isou] = pow(dcc[isou], 2.) - pow(ddi[isou]-ddj[isou], 2.);
332  }
333 }
334 
335 /*----------------------------------------------------------------------------*/
354 /*----------------------------------------------------------------------------*/
355 
356 inline static void
357 cs_i_compute_quantities(const int ircflp,
358  const double pnd,
359  const cs_real_3_t cell_ceni,
360  const cs_real_3_t cell_cenj,
361  const cs_real_3_t i_face_cog,
362  const cs_real_3_t dijpf,
363  const cs_real_3_t gradi,
364  const cs_real_3_t gradj,
365  const cs_real_t pi,
366  const cs_real_t pj,
367  cs_real_t *recoi,
368  cs_real_t *recoj,
369  cs_real_t *pip,
370  cs_real_t *pjp)
371 {
372  cs_real_t diipfx, diipfy, diipfz, djjpfx, djjpfy, djjpfz;
373  cs_real_t dpxf, dpyf, dpzf;//FIXME
374 
375  /* Recompute II' and JJ' at this level */
376 
377  diipfx = i_face_cog[0] - (cell_ceni[0] + (1.-pnd) * dijpf[0]);
378  diipfy = i_face_cog[1] - (cell_ceni[1] + (1.-pnd) * dijpf[1]);
379  diipfz = i_face_cog[2] - (cell_ceni[2] + (1.-pnd) * dijpf[2]);
380 
381  djjpfx = i_face_cog[0] - cell_cenj[0] + pnd * dijpf[0];
382  djjpfy = i_face_cog[1] - cell_cenj[1] + pnd * dijpf[1];
383  djjpfz = i_face_cog[2] - cell_cenj[2] + pnd * dijpf[2];
384 
385  dpxf = 0.5*(gradi[0] + gradj[0]);
386  dpyf = 0.5*(gradi[1] + gradj[1]);
387  dpzf = 0.5*(gradi[2] + gradj[2]);
388 
389  /* reconstruction only if IRCFLP = 1 */
390  *recoi = ircflp*(dpxf*diipfx+dpyf*diipfy+dpzf*diipfz);
391  *recoj = ircflp*(dpxf*djjpfx+dpyf*djjpfy+dpzf*djjpfz);
392  *pip = pi + *recoi;
393  *pjp = pj + *recoj;
394 }
395 
396 /*----------------------------------------------------------------------------*/
415 /*----------------------------------------------------------------------------*/
416 
417 inline static void
419  const double pnd,
420  const cs_real_3_t cell_ceni,
421  const cs_real_3_t cell_cenj,
422  const cs_real_3_t i_face_cog,
423  const cs_real_3_t dijpf,
424  const cs_real_33_t gradi,
425  const cs_real_33_t gradj,
426  const cs_real_3_t pi,
427  const cs_real_3_t pj,
428  cs_real_t recoi[3],
429  cs_real_t recoj[3],
430  cs_real_t pip[3],
431  cs_real_t pjp[3])
432 {
433  cs_real_3_t dijpfv, diipfv, djjpfv;
434  cs_real_3_t dpvf;
435 
436  for (int jsou = 0; jsou < 3; jsou++)
437  dijpfv[jsou] = dijpf[jsou];
438 
439  /* Recompute II' and JJ' at this level */
440  for (int jsou = 0; jsou < 3; jsou++) {
441  diipfv[jsou] = i_face_cog[jsou]
442  - (cell_ceni[jsou] + (1.-pnd) * dijpfv[jsou]);
443  djjpfv[jsou] = i_face_cog[jsou]
444  - cell_cenj[jsou] + pnd * dijpfv[jsou];
445  }
446 
447  /* x-y-z components, p = u, v, w */
448 
449  for (int isou = 0; isou < 3; isou++) {
450 
451  for (int jsou = 0; jsou < 3; jsou++)
452  dpvf[jsou] = 0.5*( gradi[isou][jsou]
453  + gradj[isou][jsou]);
454 
455  /* reconstruction only if IRCFLP = 1 */
456 
457  recoi[isou] = ircflp*( dpvf[0]*diipfv[0]
458  + dpvf[1]*diipfv[1]
459  + dpvf[2]*diipfv[2]);
460 
461 
462  recoj[isou] = ircflp*( dpvf[0]*djjpfv[0]
463  + dpvf[1]*djjpfv[1]
464  + dpvf[2]*djjpfv[2]);
465 
466  pip[isou] = pi[isou] + recoi[isou];
467 
468  pjp[isou] = pj[isou] + recoj[isou];
469 
470  }
471 }
472 
473 /*----------------------------------------------------------------------------*/
492 /*----------------------------------------------------------------------------*/
493 
494 inline static void
496  const double pnd,
497  const cs_real_3_t cell_ceni,
498  const cs_real_3_t cell_cenj,
499  const cs_real_3_t i_face_cog,
500  const cs_real_3_t dijpf,
501  const cs_real_63_t gradi,
502  const cs_real_63_t gradj,
503  const cs_real_6_t pi,
504  const cs_real_6_t pj,
505  cs_real_t recoi[6],
506  cs_real_t recoj[6],
507  cs_real_t pip[6],
508  cs_real_t pjp[6])
509 {
510  cs_real_3_t dijpfv, diipfv, djjpfv;
511  cs_real_3_t dpvf;
512 
513  for (int jsou = 0; jsou < 3; jsou++)
514  dijpfv[jsou] = dijpf[jsou];
515 
516  /* Recompute II' and JJ' at this level */
517 
518  for (int jsou = 0; jsou < 3; jsou++) {
519  diipfv[jsou] = i_face_cog[jsou]
520  - (cell_ceni[jsou] + (1.-pnd) * dijpfv[jsou]);
521  djjpfv[jsou] = i_face_cog[jsou]
522  - cell_cenj[jsou] + pnd * dijpfv[jsou];
523  }
524 
525  /* x-y-z components, p = u, v, w */
526 
527  for (int isou = 0; isou < 6; isou++) {
528 
529  for (int jsou = 0; jsou < 3; jsou++)
530  dpvf[jsou] = 0.5*( gradi[isou][jsou]
531  + gradj[isou][jsou]);
532 
533  /* reconstruction only if IRCFLP = 1 */
534 
535  recoi[isou] = ircflp*( dpvf[0]*diipfv[0]
536  + dpvf[1]*diipfv[1]
537  + dpvf[2]*diipfv[2]);
538 
539 
540  recoj[isou] = ircflp*( dpvf[0]*djjpfv[0]
541  + dpvf[1]*djjpfv[1]
542  + dpvf[2]*djjpfv[2]);
543 
544  pip[isou] = pi[isou] + recoi[isou];
545 
546  pjp[isou] = pj[isou] + recoj[isou];
547 
548  }
549 }
550 
551 /*----------------------------------------------------------------------------*/
567 /*----------------------------------------------------------------------------*/
568 
569 inline static void
570 cs_i_relax_c_val(const double relaxp,
571  const cs_real_t pia,
572  const cs_real_t pja,
573  const cs_real_t recoi,
574  const cs_real_t recoj,
575  const cs_real_t pi,
576  const cs_real_t pj,
577  cs_real_t *pir,
578  cs_real_t *pjr,
579  cs_real_t *pipr,
580  cs_real_t *pjpr)
581 {
582  *pir = pi/relaxp - (1.-relaxp)/relaxp * pia;
583  *pjr = pj/relaxp - (1.-relaxp)/relaxp * pja;
584 
585  *pipr = *pir + recoi;
586  *pjpr = *pjr + recoj;
587 }
588 
589 /*----------------------------------------------------------------------------*/
605 /*----------------------------------------------------------------------------*/
606 
607 inline static void
608 cs_i_relax_c_val_vector(const double relaxp,
609  const cs_real_3_t pia,
610  const cs_real_3_t pja,
611  const cs_real_3_t recoi,
612  const cs_real_3_t recoj,
613  const cs_real_3_t pi,
614  const cs_real_3_t pj,
615  cs_real_t pir[3],
616  cs_real_t pjr[3],
617  cs_real_t pipr[3],
618  cs_real_t pjpr[3])
619 {
620  for (int isou = 0; isou < 3; isou++) {
621  pir[isou] = pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
622  pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
623 
624  pipr[isou] = pir[isou] + recoi[isou];
625  pjpr[isou] = pjr[isou] + recoj[isou];
626  }
627 }
628 
629 /*----------------------------------------------------------------------------*/
645 /*----------------------------------------------------------------------------*/
646 
647 inline static void
648 cs_i_relax_c_val_tensor(const double relaxp,
649  const cs_real_6_t pia,
650  const cs_real_6_t pja,
651  const cs_real_6_t recoi,
652  const cs_real_6_t recoj,
653  const cs_real_6_t pi,
654  const cs_real_6_t pj,
655  cs_real_t pir[6],
656  cs_real_t pjr[6],
657  cs_real_t pipr[6],
658  cs_real_t pjpr[6])
659 {
660  for (int isou = 0; isou < 6; isou++) {
661  pir[isou] = pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
662  pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
663 
664  pipr[isou] = pir[isou] + recoi[isou];
665  pjpr[isou] = pjr[isou] + recoj[isou];
666  }
667 }
668 
669 /*----------------------------------------------------------------------------*/
676 /*----------------------------------------------------------------------------*/
677 
678 inline static void
680  cs_real_t *pf)
681 {
682  *pf = p;
683 }
684 
685 /*----------------------------------------------------------------------------*/
692 /*----------------------------------------------------------------------------*/
693 
694 inline static void
696  cs_real_t pf[3])
697 {
698  for (int isou = 0; isou < 3; isou++)
699  pf[isou] = p[isou];
700 }
701 
702 /*----------------------------------------------------------------------------*/
709 /*----------------------------------------------------------------------------*/
710 
711 inline static void
713  cs_real_t pf[6])
714 {
715  for (int isou = 0; isou < 6; isou++)
716  pf[isou] = p[isou];
717 }
718 
719 /*----------------------------------------------------------------------------*/
728 /*----------------------------------------------------------------------------*/
729 
730 inline static void
731 cs_centered_f_val(const double pnd,
732  const cs_real_t pip,
733  const cs_real_t pjp,
734  cs_real_t *pf)
735 {
736  *pf = pnd*pip + (1.-pnd)*pjp;
737 }
738 
739 /*----------------------------------------------------------------------------*/
754 /*----------------------------------------------------------------------------*/
755 
756 inline static void
757 cs_centered_f_val_limiter(const double pnd,
758  cs_real_t phi,
759  const cs_real_t p,
760  const cs_real_t pip,
761  const cs_real_t pjp,
762  cs_real_t *pf)
763 {
764  *pf = p + phi * (pnd * pip + (1.-pnd) * pjp - p);
765 }
766 
767 /*----------------------------------------------------------------------------*/
776 /*----------------------------------------------------------------------------*/
777 
778 inline static void
779 cs_centered_f_val_vector(const double pnd,
780  const cs_real_3_t pip,
781  const cs_real_3_t pjp,
782  cs_real_t pf[3])
783 {
784  for (int isou = 0; isou < 3; isou++)
785  pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
786 }
787 
788 /*----------------------------------------------------------------------------*/
797 /*----------------------------------------------------------------------------*/
798 
799 inline static void
800 cs_centered_f_val_tensor(const double pnd,
801  const cs_real_6_t pip,
802  const cs_real_6_t pjp,
803  cs_real_t pf[6])
804 {
805  for (int isou = 0; isou < 6; isou++)
806  pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
807 }
808 
809 /*----------------------------------------------------------------------------*/
819 /*----------------------------------------------------------------------------*/
820 
821 inline static void
822 cs_solu_f_val(const cs_real_3_t cell_cen,
823  const cs_real_3_t i_face_cog,
824  const cs_real_3_t grad,
825  const cs_real_t p,
826  cs_real_t *pf)
827 {
828  cs_real_3_t df;
829 
830  df[0] = i_face_cog[0] - cell_cen[0];
831  df[1] = i_face_cog[1] - cell_cen[1];
832  df[2] = i_face_cog[2] - cell_cen[2];
833 
834  *pf = p + _CS_DOT_PRODUCT(df, grad);
835 }
836 
837 /*----------------------------------------------------------------------------*/
852 /*----------------------------------------------------------------------------*/
853 
854 inline static void
856  const cs_real_3_t i_face_cog,
857  const cs_real_3_t grad,
858  const cs_real_t phi,
859  const cs_real_t p,
860  cs_real_t *pf)
861 {
862  cs_real_3_t df;
863 
864  df[0] = i_face_cog[0] - cell_cen[0];
865  df[1] = i_face_cog[1] - cell_cen[1];
866  df[2] = i_face_cog[2] - cell_cen[2];
867 
868  // FIXME not coherent with center.
869 
870  *pf = p + phi*_CS_DOT_PRODUCT(df, grad);
871 }
872 
873 /*----------------------------------------------------------------------------*/
883 /*----------------------------------------------------------------------------*/
884 
885 inline static void
887  const cs_real_3_t i_face_cog,
888  const cs_real_33_t grad,
889  const cs_real_3_t p,
890  cs_real_t pf[3])
891 {
892  cs_real_3_t df;
893 
894  for (int jsou = 0; jsou < 3; jsou++)
895  df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
896 
897  for (int isou = 0; isou < 3; isou++) {
898  pf[isou] = p[isou] + df[0]*grad[isou][0]
899  + df[1]*grad[isou][1]
900  + df[2]*grad[isou][2];
901 
902  }
903 }
904 
905 /*----------------------------------------------------------------------------*/
915 /*----------------------------------------------------------------------------*/
916 
917 inline static void
919  const cs_real_3_t i_face_cog,
920  const cs_real_63_t grad,
921  const cs_real_6_t p,
922  cs_real_t pf[6])
923 {
924  cs_real_3_t df;
925 
926  for (int jsou = 0; jsou < 3; jsou++)
927  df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
928 
929  for (int isou = 0; isou < 6; isou++) {
930  pf[isou] = p[isou] + df[0]*grad[isou][0]
931  + df[1]*grad[isou][1]
932  + df[2]*grad[isou][2];
933  }
934 }
935 
936 /*----------------------------------------------------------------------------*/
946 /*----------------------------------------------------------------------------*/
947 
948 inline static void
949 cs_blend_f_val(const double blencp,
950  const cs_real_t p,
951  cs_real_t *pf)
952 {
953  *pf = blencp * (*pf) + (1. - blencp) * p;
954 }
955 
956 /*----------------------------------------------------------------------------*/
966 /*----------------------------------------------------------------------------*/
967 
968 inline static void
969 cs_blend_f_val_vector(const double blencp,
970  const cs_real_3_t p,
971  cs_real_t pf[3])
972 {
973  for (int isou = 0; isou < 3; isou++)
974  pf[isou] = blencp*(pf[isou])+(1.-blencp)*p[isou];
975 }
976 
977 /*----------------------------------------------------------------------------*/
987 /*----------------------------------------------------------------------------*/
988 
989 inline static void
990 cs_blend_f_val_tensor(const double blencp,
991  const cs_real_6_t p,
992  cs_real_t pf[6])
993 {
994  for (int isou = 0; isou < 6; isou++)
995  pf[isou] = blencp*(pf[isou])+(1.-blencp)*p[isou];
996 }
997 
998 /*----------------------------------------------------------------------------*/
1019 /*----------------------------------------------------------------------------*/
1020 
1021 inline static void
1022 cs_i_conv_flux(const int iconvp,
1023  const cs_real_t thetap,
1024  const int imasac,
1025  const cs_real_t pi,
1026  const cs_real_t pj,
1027  const cs_real_t pifri,
1028  const cs_real_t pifrj,
1029  const cs_real_t pjfri,
1030  const cs_real_t pjfrj,
1031  const cs_real_t i_massflux,
1032  const cs_real_t xcppi,
1033  const cs_real_t xcppj,
1034  cs_real_2_t fluxij)
1035 {
1036  cs_real_t flui, fluj;
1037 
1038  flui = 0.5*(i_massflux + fabs(i_massflux));
1039  fluj = 0.5*(i_massflux - fabs(i_massflux));
1040 
1041  fluxij[0] += iconvp*xcppi*(thetap*(flui*pifri + fluj*pjfri) - imasac*i_massflux*pi);
1042  fluxij[1] += iconvp*xcppj*(thetap*(flui*pifrj + fluj*pjfrj) - imasac*i_massflux*pj);
1043 }
1044 
1045 /*----------------------------------------------------------------------------*/
1063 /*----------------------------------------------------------------------------*/
1064 
1065 inline static void
1066 cs_i_conv_flux_vector(const int iconvp,
1067  const cs_real_t thetap,
1068  const int imasac,
1069  const cs_real_3_t pi,
1070  const cs_real_3_t pj,
1071  const cs_real_3_t pifri,
1072  const cs_real_3_t pifrj,
1073  const cs_real_3_t pjfri,
1074  const cs_real_3_t pjfrj,
1075  const cs_real_t i_massflux,
1076  cs_real_t fluxi[3],
1077  cs_real_t fluxj[3])
1078 {
1079  cs_real_t flui, fluj;
1080 
1081  flui = 0.5*(i_massflux + fabs(i_massflux));
1082  fluj = 0.5*(i_massflux - fabs(i_massflux));
1083 
1084  for (int isou = 0; isou < 3; isou++) {
1085 
1086  fluxi[isou] += iconvp*( thetap*(flui*pifri[isou] + fluj*pjfri[isou])
1087  - imasac*i_massflux*pi[isou]);
1088  fluxj[isou] += iconvp*( thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
1089  - imasac*i_massflux*pj[isou]);
1090  }
1091 }
1092 
1093 /*----------------------------------------------------------------------------*/
1111 /*----------------------------------------------------------------------------*/
1112 
1113 inline static void
1114 cs_i_conv_flux_tensor(const int iconvp,
1115  const cs_real_t thetap,
1116  const int imasac,
1117  const cs_real_6_t pi,
1118  const cs_real_6_t pj,
1119  const cs_real_6_t pifri,
1120  const cs_real_6_t pifrj,
1121  const cs_real_6_t pjfri,
1122  const cs_real_6_t pjfrj,
1123  const cs_real_t i_massflux,
1124  cs_real_t fluxi[6],
1125  cs_real_t fluxj[6])
1126 {
1127  cs_real_t flui, fluj;
1128 
1129  flui = 0.5*(i_massflux + fabs(i_massflux));
1130  fluj = 0.5*(i_massflux - fabs(i_massflux));
1131 
1132  for (int isou = 0; isou < 6; isou++) {
1133  fluxi[isou] += iconvp*( thetap*(flui*pifri[isou] + fluj*pjfri[isou])
1134  - imasac*i_massflux*pi[isou]);
1135  fluxj[isou] += iconvp*( thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
1136  - imasac*i_massflux*pj[isou]);
1137  }
1138 }
1139 
1140 /*----------------------------------------------------------------------------*/
1153 /*----------------------------------------------------------------------------*/
1154 
1155 inline static void
1156 cs_i_diff_flux(const int idiffp,
1157  const cs_real_t thetap,
1158  const cs_real_t pip,
1159  const cs_real_t pjp,
1160  const cs_real_t pipr,
1161  const cs_real_t pjpr,
1162  const cs_real_t i_visc,
1163  cs_real_2_t fluxij)
1164 {
1165  fluxij[0] += idiffp*thetap*i_visc*(pipr -pjp);
1166  fluxij[1] += idiffp*thetap*i_visc*(pip -pjpr);
1167 }
1168 
1169 /*----------------------------------------------------------------------------*/
1183 /*----------------------------------------------------------------------------*/
1184 
1185 inline static void
1186 cs_i_diff_flux_vector(const int idiffp,
1187  const cs_real_t thetap,
1188  const cs_real_3_t pip,
1189  const cs_real_3_t pjp,
1190  const cs_real_3_t pipr,
1191  const cs_real_3_t pjpr,
1192  const cs_real_t i_visc,
1193  cs_real_t fluxi[3],
1194  cs_real_t fluxj[3])
1195 {
1196  for (int isou = 0; isou < 3; isou++) {
1197  fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
1198  fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
1199  }
1200 }
1201 
1202 /*----------------------------------------------------------------------------*/
1216 /*----------------------------------------------------------------------------*/
1217 
1218 inline static void
1219 cs_i_diff_flux_tensor(const int idiffp,
1220  const cs_real_t thetap,
1221  const cs_real_6_t pip,
1222  const cs_real_6_t pjp,
1223  const cs_real_6_t pipr,
1224  const cs_real_6_t pjpr,
1225  const cs_real_t i_visc,
1226  cs_real_t fluxi[6],
1227  cs_real_t fluxj[6])
1228 {
1229  for (int isou = 0; isou < 6; isou++) {
1230  fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
1231  fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
1232  }
1233 }
1234 
1235 /*----------------------------------------------------------------------------*/
1262 /*----------------------------------------------------------------------------*/
1263 
1264 inline static void
1265 cs_i_cd_steady_upwind(const int ircflp,
1266  const cs_real_t relaxp,
1267  const cs_real_t weight,
1268  const cs_real_3_t cell_ceni,
1269  const cs_real_3_t cell_cenj,
1270  const cs_real_3_t i_face_cog,
1271  const cs_real_3_t dijpf,
1272  const cs_real_3_t gradi,
1273  const cs_real_3_t gradj,
1274  const cs_real_t pi,
1275  const cs_real_t pj,
1276  const cs_real_t pia,
1277  const cs_real_t pja,
1278  cs_real_t *pifri,
1279  cs_real_t *pifrj,
1280  cs_real_t *pjfri,
1281  cs_real_t *pjfrj,
1282  cs_real_t *pip,
1283  cs_real_t *pjp,
1284  cs_real_t *pipr,
1285  cs_real_t *pjpr)
1286 {
1287  cs_real_t pir, pjr;
1288  cs_real_t recoi, recoj;
1289 
1290  cs_i_compute_quantities(ircflp,
1291  weight,
1292  cell_ceni,
1293  cell_cenj,
1294  i_face_cog,
1295  dijpf,
1296  gradi,
1297  gradj,
1298  pi,
1299  pj,
1300  &recoi,
1301  &recoj,
1302  pip,
1303  pjp);
1304 
1305  cs_i_relax_c_val(relaxp,
1306  pia,
1307  pja,
1308  recoi,
1309  recoj,
1310  pi,
1311  pj,
1312  &pir,
1313  &pjr,
1314  pipr,
1315  pjpr);
1316 
1317  cs_upwind_f_val(pi,
1318  pifrj);
1319  cs_upwind_f_val(pir,
1320  pifri);
1321  cs_upwind_f_val(pj,
1322  pjfri);
1323  cs_upwind_f_val(pjr,
1324  pjfrj);
1325 }
1326 
1327 /*----------------------------------------------------------------------------*/
1354 /*----------------------------------------------------------------------------*/
1355 
1356 inline static void
1358  const cs_real_t relaxp,
1359  const cs_real_t weight,
1360  const cs_real_3_t cell_ceni,
1361  const cs_real_3_t cell_cenj,
1362  const cs_real_3_t i_face_cog,
1363  const cs_real_3_t dijpf,
1364  const cs_real_33_t gradi,
1365  const cs_real_33_t gradj,
1366  const cs_real_3_t pi,
1367  const cs_real_3_t pj,
1368  const cs_real_3_t pia,
1369  const cs_real_3_t pja,
1370  cs_real_t pifri[3],
1371  cs_real_t pifrj[3],
1372  cs_real_t pjfri[3],
1373  cs_real_t pjfrj[3],
1374  cs_real_t pip[3],
1375  cs_real_t pjp[3],
1376  cs_real_t pipr[3],
1377  cs_real_t pjpr[3])
1378 {
1379  cs_real_3_t pir, pjr;
1380  cs_real_3_t recoi, recoj;
1381 
1383  weight,
1384  cell_ceni,
1385  cell_cenj,
1386  i_face_cog,
1387  dijpf,
1388  gradi,
1389  gradj,
1390  pi,
1391  pj,
1392  recoi,
1393  recoj,
1394  pip,
1395  pjp);
1396 
1397  cs_i_relax_c_val_vector(relaxp,
1398  pia,
1399  pja,
1400  recoi,
1401  recoj,
1402  pi,
1403  pj,
1404  pir,
1405  pjr,
1406  pipr,
1407  pjpr);
1408 
1410  pifrj);
1412  pifri);
1414  pjfri);
1416  pjfrj);
1417 
1418 }
1419 
1420 /*----------------------------------------------------------------------------*/
1447 /*----------------------------------------------------------------------------*/
1448 
1449 inline static void
1451  const cs_real_t relaxp,
1452  const cs_real_t weight,
1453  const cs_real_3_t cell_ceni,
1454  const cs_real_3_t cell_cenj,
1455  const cs_real_3_t i_face_cog,
1456  const cs_real_3_t dijpf,
1457  const cs_real_63_t gradi,
1458  const cs_real_63_t gradj,
1459  const cs_real_6_t pi,
1460  const cs_real_6_t pj,
1461  const cs_real_6_t pia,
1462  const cs_real_6_t pja,
1463  cs_real_t pifri[6],
1464  cs_real_t pifrj[6],
1465  cs_real_t pjfri[6],
1466  cs_real_t pjfrj[6],
1467  cs_real_t pip[6],
1468  cs_real_t pjp[6],
1469  cs_real_t pipr[6],
1470  cs_real_t pjpr[6])
1471 {
1472  cs_real_6_t pir, pjr;
1473  cs_real_6_t recoi, recoj;
1474 
1476  weight,
1477  cell_ceni,
1478  cell_cenj,
1479  i_face_cog,
1480  dijpf,
1481  gradi,
1482  gradj,
1483  pi,
1484  pj,
1485  recoi,
1486  recoj,
1487  pip,
1488  pjp);
1489 
1490  cs_i_relax_c_val_tensor(relaxp,
1491  pia,
1492  pja,
1493  recoi,
1494  recoj,
1495  pi,
1496  pj,
1497  pir,
1498  pjr,
1499  pipr,
1500  pjpr);
1501 
1503  pifrj);
1505  pifri);
1507  pjfri);
1509  pjfrj);
1510 }
1511 
1512 /*----------------------------------------------------------------------------*/
1532 /*----------------------------------------------------------------------------*/
1533 
1534 inline static void
1535 cs_i_cd_unsteady_upwind(const int ircflp,
1536  const cs_real_t weight,
1537  const cs_real_3_t cell_ceni,
1538  const cs_real_3_t cell_cenj,
1539  const cs_real_3_t i_face_cog,
1540  const cs_real_3_t dijpf,
1541  const cs_real_3_t gradi,
1542  const cs_real_3_t gradj,
1543  const cs_real_t pi,
1544  const cs_real_t pj,
1545  cs_real_t *pif,
1546  cs_real_t *pjf,
1547  cs_real_t *pip,
1548  cs_real_t *pjp)
1549 {
1550  cs_real_t recoi, recoj;
1551 
1552  cs_i_compute_quantities(ircflp,
1553  weight,
1554  cell_ceni,
1555  cell_cenj,
1556  i_face_cog,
1557  dijpf,
1558  gradi,
1559  gradj,
1560  pi,
1561  pj,
1562  &recoi,
1563  &recoj,
1564  pip,
1565  pjp);
1566 
1567  cs_upwind_f_val(pi, pif);
1568  cs_upwind_f_val(pj, pjf);
1569 }
1570 
1571 /*----------------------------------------------------------------------------*/
1591 /*----------------------------------------------------------------------------*/
1592 
1593 inline static void
1595  const cs_real_t weight,
1596  const cs_real_3_t cell_ceni,
1597  const cs_real_3_t cell_cenj,
1598  const cs_real_3_t i_face_cog,
1599  const cs_real_3_t dijpf,
1600  const cs_real_33_t gradi,
1601  const cs_real_33_t gradj,
1602  const cs_real_3_t pi,
1603  const cs_real_3_t pj,
1604  cs_real_t pif[3],
1605  cs_real_t pjf[3],
1606  cs_real_t pip[3],
1607  cs_real_t pjp[3])
1608 {
1609  cs_real_3_t recoi, recoj;
1610 
1612  weight,
1613  cell_ceni,
1614  cell_cenj,
1615  i_face_cog,
1616  dijpf,
1617  gradi,
1618  gradj,
1619  pi,
1620  pj,
1621  recoi,
1622  recoj,
1623  pip,
1624  pjp);
1625 
1626  cs_upwind_f_val_vector(pi, pif);
1627  cs_upwind_f_val_vector(pj, pjf);
1628 
1629 }
1630 
1631 /*----------------------------------------------------------------------------*/
1651 /*----------------------------------------------------------------------------*/
1652 
1653 inline static void
1655  const cs_real_t weight,
1656  const cs_real_3_t cell_ceni,
1657  const cs_real_3_t cell_cenj,
1658  const cs_real_3_t i_face_cog,
1659  const cs_real_3_t dijpf,
1660  const cs_real_63_t gradi,
1661  const cs_real_63_t gradj,
1662  const cs_real_6_t pi,
1663  const cs_real_6_t pj,
1664  cs_real_t pif[6],
1665  cs_real_t pjf[6],
1666  cs_real_t pip[6],
1667  cs_real_t pjp[6])
1668 {
1669  cs_real_6_t recoi, recoj;
1670 
1672  weight,
1673  cell_ceni,
1674  cell_cenj,
1675  i_face_cog,
1676  dijpf,
1677  gradi,
1678  gradj,
1679  pi,
1680  pj,
1681  recoi,
1682  recoj,
1683  pip,
1684  pjp);
1685 
1686  cs_upwind_f_val_tensor(pi, pif);
1687  cs_upwind_f_val_tensor(pj, pjf);
1688 
1689 }
1690 
1691 /*----------------------------------------------------------------------------*/
1723 /*----------------------------------------------------------------------------*/
1724 
1725 inline static void
1726 cs_i_cd_steady(const int ircflp,
1727  const int ischcp,
1728  const double relaxp,
1729  const double blencp,
1730  const cs_real_t weight,
1731  const cs_real_3_t cell_ceni,
1732  const cs_real_3_t cell_cenj,
1733  const cs_real_3_t i_face_cog,
1734  const cs_real_3_t dijpf,
1735  const cs_real_3_t gradi,
1736  const cs_real_3_t gradj,
1737  const cs_real_3_t gradupi,
1738  const cs_real_3_t gradupj,
1739  const cs_real_t pi,
1740  const cs_real_t pj,
1741  const cs_real_t pia,
1742  const cs_real_t pja,
1743  cs_real_t *pifri,
1744  cs_real_t *pifrj,
1745  cs_real_t *pjfri,
1746  cs_real_t *pjfrj,
1747  cs_real_t *pip,
1748  cs_real_t *pjp,
1749  cs_real_t *pipr,
1750  cs_real_t *pjpr)
1751 {
1752  cs_real_t pir, pjr;
1753  cs_real_t recoi, recoj;
1754 
1755  cs_i_compute_quantities(ircflp,
1756  weight,
1757  cell_ceni,
1758  cell_cenj,
1759  i_face_cog,
1760  dijpf,
1761  gradi,
1762  gradj,
1763  pi,
1764  pj,
1765  &recoi,
1766  &recoj,
1767  pip,
1768  pjp);
1769 
1770  cs_i_relax_c_val(relaxp,
1771  pia,
1772  pja,
1773  recoi,
1774  recoj,
1775  pi,
1776  pj,
1777  &pir,
1778  &pjr,
1779  pipr,
1780  pjpr);
1781 
1782  if (ischcp == 1) {
1783 
1784  /* Centered
1785  --------*/
1786 
1787  cs_centered_f_val(weight,
1788  *pip,
1789  *pjpr,
1790  pifrj);
1791  cs_centered_f_val(weight,
1792  *pipr,
1793  *pjp,
1794  pifri);
1795  cs_centered_f_val(weight,
1796  *pipr,
1797  *pjp,
1798  pjfri);
1799  cs_centered_f_val(weight,
1800  *pip,
1801  *pjpr,
1802  pjfrj);
1803 
1804  } else if (ischcp == 0) {
1805 
1806  /* Original SOLU
1807  --------------*/
1808 
1809  cs_solu_f_val(cell_ceni,
1810  i_face_cog,
1811  gradi,
1812  pi,
1813  pifrj);
1814  cs_solu_f_val(cell_ceni,
1815  i_face_cog,
1816  gradi,
1817  pir,
1818  pifri);
1819  cs_solu_f_val(cell_cenj,
1820  i_face_cog,
1821  gradj,
1822  pj,
1823  pjfri);
1824  cs_solu_f_val(cell_cenj,
1825  i_face_cog,
1826  gradj,
1827  pjr,
1828  pjfrj);
1829 
1830  } else {
1831 
1832  /* SOLU
1833  ----*/
1834 
1835  cs_solu_f_val(cell_ceni,
1836  i_face_cog,
1837  gradupi,
1838  pi,
1839  pifrj);
1840  cs_solu_f_val(cell_ceni,
1841  i_face_cog,
1842  gradupi,
1843  pir,
1844  pifri);
1845  cs_solu_f_val(cell_cenj,
1846  i_face_cog,
1847  gradupj,
1848  pj,
1849  pjfri);
1850  cs_solu_f_val(cell_cenj,
1851  i_face_cog,
1852  gradupj,
1853  pjr,
1854  pjfrj);
1855 
1856  }
1857 
1858  /* Blending
1859  --------*/
1860 
1861  cs_blend_f_val(blencp,
1862  pi,
1863  pifrj);
1864  cs_blend_f_val(blencp,
1865  pir,
1866  pifri);
1867  cs_blend_f_val(blencp,
1868  pj,
1869  pjfri);
1870  cs_blend_f_val(blencp,
1871  pjr,
1872  pjfrj);
1873 }
1874 
1875 /*----------------------------------------------------------------------------*/
1905 /*----------------------------------------------------------------------------*/
1906 
1907 inline static void
1908 cs_i_cd_steady_vector(const int ircflp,
1909  const int ischcp,
1910  const double relaxp,
1911  const double blencp,
1912  const cs_real_t weight,
1913  const cs_real_3_t cell_ceni,
1914  const cs_real_3_t cell_cenj,
1915  const cs_real_3_t i_face_cog,
1916  const cs_real_3_t dijpf,
1917  const cs_real_33_t gradi,
1918  const cs_real_33_t gradj,
1919  const cs_real_3_t pi,
1920  const cs_real_3_t pj,
1921  const cs_real_3_t pia,
1922  const cs_real_3_t pja,
1923  cs_real_t pifri[3],
1924  cs_real_t pifrj[3],
1925  cs_real_t pjfri[3],
1926  cs_real_t pjfrj[3],
1927  cs_real_t pip[3],
1928  cs_real_t pjp[3],
1929  cs_real_t pipr[3],
1930  cs_real_t pjpr[3])
1931 {
1932  cs_real_3_t pir, pjr;
1933  cs_real_3_t recoi, recoj;
1934 
1936  weight,
1937  cell_ceni,
1938  cell_cenj,
1939  i_face_cog,
1940  dijpf,
1941  gradi,
1942  gradj,
1943  pi,
1944  pj,
1945  recoi,
1946  recoj,
1947  pip,
1948  pjp);
1949 
1950  cs_i_relax_c_val_vector(relaxp,
1951  pia,
1952  pja,
1953  recoi,
1954  recoj,
1955  pi,
1956  pj,
1957  pir,
1958  pjr,
1959  pipr,
1960  pjpr);
1961 
1962  if (ischcp == 1) {
1963 
1964  /* Centered
1965  --------*/
1966 
1967  cs_centered_f_val_vector(weight,
1968  pip,
1969  pjpr,
1970  pifrj);
1971  cs_centered_f_val_vector(weight,
1972  pipr,
1973  pjp,
1974  pifri);
1975  cs_centered_f_val_vector(weight,
1976  pipr,
1977  pjp,
1978  pjfri);
1979  cs_centered_f_val_vector(weight,
1980  pip,
1981  pjpr,
1982  pjfrj);
1983 
1984  } else {
1985 
1986  /* Second order
1987  ------------*/
1988 
1989  cs_solu_f_val_vector(cell_ceni,
1990  i_face_cog,
1991  gradi,
1992  pi,
1993  pifrj);
1994  cs_solu_f_val_vector(cell_ceni,
1995  i_face_cog,
1996  gradi,
1997  pir,
1998  pifri);
1999  cs_solu_f_val_vector(cell_cenj,
2000  i_face_cog,
2001  gradj,
2002  pj,
2003  pjfri);
2004  cs_solu_f_val_vector(cell_cenj,
2005  i_face_cog,
2006  gradj,
2007  pjr,
2008  pjfrj);
2009 
2010  }
2011 
2012  /* Blending
2013  --------*/
2014  cs_blend_f_val_vector(blencp,
2015  pi,
2016  pifrj);
2017  cs_blend_f_val_vector(blencp,
2018  pir,
2019  pifri);
2020  cs_blend_f_val_vector(blencp,
2021  pj,
2022  pjfri);
2023  cs_blend_f_val_vector(blencp,
2024  pjr,
2025  pjfrj);
2026 
2027 }
2028 
2029 /*----------------------------------------------------------------------------*/
2059 /*----------------------------------------------------------------------------*/
2060 
2061 inline static void
2062 cs_i_cd_steady_tensor(const int ircflp,
2063  const int ischcp,
2064  const double relaxp,
2065  const double blencp,
2066  const cs_real_t weight,
2067  const cs_real_3_t cell_ceni,
2068  const cs_real_3_t cell_cenj,
2069  const cs_real_3_t i_face_cog,
2070  const cs_real_3_t dijpf,
2071  const cs_real_63_t gradi,
2072  const cs_real_63_t gradj,
2073  const cs_real_6_t pi,
2074  const cs_real_6_t pj,
2075  const cs_real_6_t pia,
2076  const cs_real_6_t pja,
2077  cs_real_t pifri[6],
2078  cs_real_t pifrj[6],
2079  cs_real_t pjfri[6],
2080  cs_real_t pjfrj[6],
2081  cs_real_t pip[6],
2082  cs_real_t pjp[6],
2083  cs_real_t pipr[6],
2084  cs_real_t pjpr[6])
2085 
2086 {
2087  cs_real_6_t pir, pjr;
2088  cs_real_6_t recoi, recoj;
2089 
2091  weight,
2092  cell_ceni,
2093  cell_cenj,
2094  i_face_cog,
2095  dijpf,
2096  gradi,
2097  gradj,
2098  pi,
2099  pj,
2100  recoi,
2101  recoj,
2102  pip,
2103  pjp);
2104 
2105  cs_i_relax_c_val_tensor(relaxp,
2106  pia,
2107  pja,
2108  recoi,
2109  recoj,
2110  pi,
2111  pj,
2112  pir,
2113  pjr,
2114  pipr,
2115  pjpr);
2116 
2117  if (ischcp == 1) {
2118 
2119  /* Centered
2120  --------*/
2121 
2122  cs_centered_f_val_tensor(weight,
2123  pip,
2124  pjpr,
2125  pifrj);
2126  cs_centered_f_val_tensor(weight,
2127  pipr,
2128  pjp,
2129  pifri);
2130  cs_centered_f_val_tensor(weight,
2131  pipr,
2132  pjp,
2133  pjfri);
2134  cs_centered_f_val_tensor(weight,
2135  pip,
2136  pjpr,
2137  pjfrj);
2138 
2139  } else {
2140 
2141  /* Second order
2142  ------------*/
2143 
2144  cs_solu_f_val_tensor(cell_ceni,
2145  i_face_cog,
2146  gradi,
2147  pi,
2148  pifrj);
2149  cs_solu_f_val_tensor(cell_ceni,
2150  i_face_cog,
2151  gradi,
2152  pir,
2153  pifri);
2154  cs_solu_f_val_tensor(cell_cenj,
2155  i_face_cog,
2156  gradj,
2157  pj,
2158  pjfri);
2159  cs_solu_f_val_tensor(cell_cenj,
2160  i_face_cog,
2161  gradj,
2162  pjr,
2163  pjfrj);
2164 
2165  }
2166 
2167  /* Blending
2168  --------*/
2169 
2170  cs_blend_f_val_tensor(blencp,
2171  pi,
2172  pifrj);
2173  cs_blend_f_val_tensor(blencp,
2174  pir,
2175  pifri);
2176  cs_blend_f_val_tensor(blencp,
2177  pj,
2178  pjfri);
2179  cs_blend_f_val_tensor(blencp,
2180  pjr,
2181  pjfrj);
2182 
2183 }
2184 
2185 /*----------------------------------------------------------------------------*/
2212 /*----------------------------------------------------------------------------*/
2213 
2214 inline static void
2215 cs_i_cd_unsteady(const int ircflp,
2216  const int ischcp,
2217  const double blencp,
2218  const cs_real_t weight,
2219  const cs_real_3_t cell_ceni,
2220  const cs_real_3_t cell_cenj,
2221  const cs_real_3_t i_face_cog,
2222  const cs_real_3_t dijpf,
2223  const cs_real_3_t gradi,
2224  const cs_real_3_t gradj,
2225  const cs_real_3_t gradupi,
2226  const cs_real_3_t gradupj,
2227  const cs_real_t pi,
2228  const cs_real_t pj,
2229  cs_real_t *pif,
2230  cs_real_t *pjf,
2231  cs_real_t *pip,
2232  cs_real_t *pjp)
2233 {
2234  cs_real_t recoi, recoj;
2235 
2236  cs_i_compute_quantities(ircflp,
2237  weight,
2238  cell_ceni,
2239  cell_cenj,
2240  i_face_cog,
2241  dijpf,
2242  gradi,
2243  gradj,
2244  pi,
2245  pj,
2246  &recoi,
2247  &recoj,
2248  pip,
2249  pjp);
2250 
2251 
2252  if (ischcp == 1) {
2253 
2254  /* Centered
2255  --------*/
2256 
2257  cs_centered_f_val(weight,
2258  *pip,
2259  *pjp,
2260  pif);
2261  cs_centered_f_val(weight,
2262  *pip,
2263  *pjp,
2264  pjf);
2265 
2266  } else if (ischcp == 0) {
2267 
2268  /* Original SOLU
2269  ------------*/
2270 
2271  cs_solu_f_val(cell_ceni,
2272  i_face_cog,
2273  gradi,
2274  pi,
2275  pif);
2276  cs_solu_f_val(cell_cenj,
2277  i_face_cog,
2278  gradj,
2279  pj,
2280  pjf);
2281 
2282  } else {
2283 
2284  /* SOLU
2285  ----*/
2286 
2287  cs_solu_f_val(cell_ceni,
2288  i_face_cog,
2289  gradupi,
2290  pi,
2291  pif);
2292  cs_solu_f_val(cell_cenj,
2293  i_face_cog,
2294  gradupj,
2295  pj,
2296  pjf);
2297 
2298  }
2299 
2300 
2301  /* Blending
2302  --------*/
2303 
2304  cs_blend_f_val(blencp,
2305  pi,
2306  pif);
2307  cs_blend_f_val(blencp,
2308  pj,
2309  pjf);
2310 }
2311 
2312 /*----------------------------------------------------------------------------*/
2343 /*----------------------------------------------------------------------------*/
2344 
2345 inline static void
2346 cs_i_cd_unsteady_limiter(const int ircflp,
2347  const int ischcp,
2348  const cs_real_t weight,
2349  const cs_real_3_t cell_ceni,
2350  const cs_real_3_t cell_cenj,
2351  const cs_real_3_t i_face_cog,
2352  cs_real_t phi_rij,
2353  const cs_real_3_t dijpf,
2354  const cs_real_3_t gradi,
2355  const cs_real_3_t gradj,
2356  const cs_real_3_t gradupi,
2357  const cs_real_3_t gradupj,
2358  const cs_real_t pi,
2359  const cs_real_t pj,
2360  cs_real_t *pif,
2361  cs_real_t *pjf,
2362  cs_real_t *pip,
2363  cs_real_t *pjp)
2364 {
2365  cs_real_t recoi, recoj;
2366 
2367  cs_i_compute_quantities(ircflp,
2368  weight,
2369  cell_ceni,
2370  cell_cenj,
2371  i_face_cog,
2372  dijpf,
2373  gradi,
2374  gradj,
2375  pi,
2376  pj,
2377  &recoi,
2378  &recoj,
2379  pip,
2380  pjp);
2381 
2382  /* Only Standard SOLU or Centered scheme is allowed (not original SOLU) */
2383  assert(ischcp > 0);
2384 
2385  if (ischcp == 1) {
2386 
2387  /* Centered
2388  --------*/
2389 
2391  phi_rij,
2392  pi,
2393  *pip,
2394  *pjp,
2395  pif);
2397  phi_rij,
2398  pj,
2399  *pip,
2400  *pjp,
2401  pjf);
2402 
2403  } else {
2404 
2405  /* SOLU
2406  ----*/
2407 
2408  cs_solu_f_val_limiter(cell_ceni,
2409  i_face_cog,
2410  gradupi,
2411  phi_rij,
2412  pi,
2413  pif);
2414  cs_solu_f_val_limiter(cell_cenj,
2415  i_face_cog,
2416  gradupj,
2417  phi_rij,
2418  pj,
2419  pjf);
2420  }
2421 
2422 }
2423 
2424 /*----------------------------------------------------------------------------*/
2447 /*----------------------------------------------------------------------------*/
2448 
2449 inline static void
2450 cs_i_cd_unsteady_vector(const int ircflp,
2451  const int ischcp,
2452  const double blencp,
2453  const cs_real_t weight,
2454  const cs_real_3_t cell_ceni,
2455  const cs_real_3_t cell_cenj,
2456  const cs_real_3_t i_face_cog,
2457  const cs_real_3_t dijpf,
2458  const cs_real_33_t gradi,
2459  const cs_real_33_t gradj,
2460  const cs_real_3_t pi,
2461  const cs_real_3_t pj,
2462  cs_real_t pif[3],
2463  cs_real_t pjf[3],
2464  cs_real_t pip[3],
2465  cs_real_t pjp[3])
2466 
2467 {
2468  cs_real_3_t recoi, recoj;
2469 
2471  weight,
2472  cell_ceni,
2473  cell_cenj,
2474  i_face_cog,
2475  dijpf,
2476  gradi,
2477  gradj,
2478  pi,
2479  pj,
2480  recoi,
2481  recoj,
2482  pip,
2483  pjp);
2484 
2485  if (ischcp == 1) {
2486 
2487  /* Centered
2488  --------*/
2489 
2490  cs_centered_f_val_vector(weight,
2491  pip,
2492  pjp,
2493  pif);
2494  cs_centered_f_val_vector(weight,
2495  pip,
2496  pjp,
2497  pjf);
2498 
2499  } else {
2500 
2501  /* Second order
2502  ------------*/
2503 
2504  cs_solu_f_val_vector(cell_ceni,
2505  i_face_cog,
2506  gradi,
2507  pi,
2508  pif);
2509  cs_solu_f_val_vector(cell_cenj,
2510  i_face_cog,
2511  gradj,
2512  pj,
2513  pjf);
2514 
2515  }
2516 
2517  /* Blending
2518  --------*/
2519 
2520  cs_blend_f_val_vector(blencp,
2521  pi,
2522  pif);
2523  cs_blend_f_val_vector(blencp,
2524  pj,
2525  pjf);
2526 }
2527 
2528 /*----------------------------------------------------------------------------*/
2551 /*----------------------------------------------------------------------------*/
2552 
2553 inline static void
2554 cs_i_cd_unsteady_tensor(const int ircflp,
2555  const int ischcp,
2556  const double blencp,
2557  const cs_real_t weight,
2558  const cs_real_3_t cell_ceni,
2559  const cs_real_3_t cell_cenj,
2560  const cs_real_3_t i_face_cog,
2561  const cs_real_3_t dijpf,
2562  const cs_real_63_t gradi,
2563  const cs_real_63_t gradj,
2564  const cs_real_6_t pi,
2565  const cs_real_6_t pj,
2566  cs_real_t pif[6],
2567  cs_real_t pjf[6],
2568  cs_real_t pip[6],
2569  cs_real_t pjp[6])
2570 
2571 {
2572  cs_real_6_t recoi, recoj;
2573 
2575  weight,
2576  cell_ceni,
2577  cell_cenj,
2578  i_face_cog,
2579  dijpf,
2580  gradi,
2581  gradj,
2582  pi,
2583  pj,
2584  recoi,
2585  recoj,
2586  pip,
2587  pjp);
2588 
2589  if (ischcp == 1) {
2590 
2591  /* Centered
2592  --------*/
2593 
2594  cs_centered_f_val_tensor(weight,
2595  pip,
2596  pjp,
2597  pif);
2598  cs_centered_f_val_tensor(weight,
2599  pip,
2600  pjp,
2601  pjf);
2602 
2603  } else {
2604 
2605  /* Second order
2606  ------------*/
2607 
2608  cs_solu_f_val_tensor(cell_ceni,
2609  i_face_cog,
2610  gradi,
2611  pi,
2612  pif);
2613  cs_solu_f_val_tensor(cell_cenj,
2614  i_face_cog,
2615  gradj,
2616  pj,
2617  pjf);
2618 
2619  }
2620 
2621  /* Blending
2622  --------*/
2623 
2624  cs_blend_f_val_tensor(blencp,
2625  pi,
2626  pif);
2627  cs_blend_f_val_tensor(blencp,
2628  pj,
2629  pjf);
2630 
2631 }
2632 
2633 /*----------------------------------------------------------------------------*/
2673 /*----------------------------------------------------------------------------*/
2674 
2675 inline static void
2676 cs_i_cd_steady_slope_test(bool *upwind_switch,
2677  const int iconvp,
2678  const int ircflp,
2679  const int ischcp,
2680  const double relaxp,
2681  const double blencp,
2682  const cs_real_t weight,
2683  const cs_real_t i_dist,
2684  const cs_real_t i_face_surf,
2685  const cs_real_3_t cell_ceni,
2686  const cs_real_3_t cell_cenj,
2687  const cs_real_3_t i_face_normal,
2688  const cs_real_3_t i_face_cog,
2689  const cs_real_3_t dijpf,
2690  const cs_real_t i_massflux,
2691  const cs_real_3_t gradi,
2692  const cs_real_3_t gradj,
2693  const cs_real_3_t gradupi,
2694  const cs_real_3_t gradupj,
2695  const cs_real_3_t gradsti,
2696  const cs_real_3_t gradstj,
2697  const cs_real_t pi,
2698  const cs_real_t pj,
2699  const cs_real_t pia,
2700  const cs_real_t pja,
2701  cs_real_t *pifri,
2702  cs_real_t *pifrj,
2703  cs_real_t *pjfri,
2704  cs_real_t *pjfrj,
2705  cs_real_t *pip,
2706  cs_real_t *pjp,
2707  cs_real_t *pipr,
2708  cs_real_t *pjpr)
2709 {
2710  cs_real_t pir, pjr;
2711  cs_real_t recoi, recoj;
2712  cs_real_t distf, srfan, testij, tesqck;
2713 
2714  distf = i_dist;
2715  srfan = i_face_surf;
2716 
2717  *upwind_switch = false;
2718 
2719  cs_i_compute_quantities(ircflp,
2720  weight,
2721  cell_ceni,
2722  cell_cenj,
2723  i_face_cog,
2724  dijpf,
2725  gradi,
2726  gradj,
2727  pi,
2728  pj,
2729  &recoi,
2730  &recoj,
2731  pip,
2732  pjp);
2733 
2734  cs_i_relax_c_val(relaxp,
2735  pia,
2736  pja,
2737  recoi,
2738  recoj,
2739  pi,
2740  pj,
2741  &pir,
2742  &pjr,
2743  pipr,
2744  pjpr);
2745 
2746  /* Convection slope test is needed only when iconv >0 */
2747  if (iconvp > 0) {
2748  cs_slope_test(pi,
2749  pj,
2750  distf,
2751  srfan,
2752  i_face_normal,
2753  gradi,
2754  gradj,
2755  gradsti,
2756  gradstj,
2757  i_massflux,
2758  &testij,
2759  &tesqck);
2760 
2761  if (tesqck<=0. || testij<=0.) {
2762 
2763  /* Upwind
2764  --------*/
2765 
2766  cs_upwind_f_val(pi,
2767  pifrj);
2768  cs_upwind_f_val(pir,
2769  pifri);
2770  cs_upwind_f_val(pj,
2771  pjfri);
2772  cs_upwind_f_val(pjr,
2773  pjfrj);
2774 
2775  *upwind_switch = true;
2776 
2777  } else {
2778 
2779  if (ischcp==1) {
2780 
2781  /* Centered
2782  --------*/
2783 
2784  cs_centered_f_val(weight,
2785  *pip,
2786  *pjpr,
2787  pifrj);
2788  cs_centered_f_val(weight,
2789  *pipr,
2790  *pjp,
2791  pifri);
2792  cs_centered_f_val(weight,
2793  *pipr,
2794  *pjp,
2795  pjfri);
2796  cs_centered_f_val(weight,
2797  *pip,
2798  *pjpr,
2799  pjfrj);
2800 
2801  } else if (ischcp == 0) {
2802 
2803  /* Second order
2804  ------------*/
2805 
2806  cs_solu_f_val(cell_ceni,
2807  i_face_cog,
2808  gradi,
2809  pi,
2810  pifrj);
2811  cs_solu_f_val(cell_ceni,
2812  i_face_cog,
2813  gradi,
2814  pir,
2815  pifri);
2816  cs_solu_f_val(cell_cenj,
2817  i_face_cog,
2818  gradj,
2819  pj,
2820  pjfri);
2821  cs_solu_f_val(cell_cenj,
2822  i_face_cog,
2823  gradj,
2824  pjr,
2825  pjfrj);
2826 
2827  } else {
2828 
2829  /* SOLU
2830  -----*/
2831 
2832  cs_solu_f_val(cell_ceni,
2833  i_face_cog,
2834  gradupi,
2835  pi,
2836  pifrj);
2837  cs_solu_f_val(cell_ceni,
2838  i_face_cog,
2839  gradupi,
2840  pir,
2841  pifri);
2842  cs_solu_f_val(cell_cenj,
2843  i_face_cog,
2844  gradupj,
2845  pj,
2846  pjfri);
2847  cs_solu_f_val(cell_cenj,
2848  i_face_cog,
2849  gradupj,
2850  pjr,
2851  pjfrj);
2852  }
2853  }
2854 
2855  /* Blending
2856  --------*/
2857 
2858  cs_blend_f_val(blencp,
2859  pi,
2860  pifrj);
2861  cs_blend_f_val(blencp,
2862  pir,
2863  pifri);
2864  cs_blend_f_val(blencp,
2865  pj,
2866  pjfri);
2867  cs_blend_f_val(blencp,
2868  pjr,
2869  pjfrj);
2870 
2871  /* If iconv=0 p*fr* are useless */
2872  } else {
2873  cs_upwind_f_val(pi,
2874  pifrj);
2875  cs_upwind_f_val(pir,
2876  pifri);
2877  cs_upwind_f_val(pj,
2878  pjfri);
2879  cs_upwind_f_val(pjr,
2880  pjfrj);
2881  }
2882 
2883 }
2884 
2885 /*----------------------------------------------------------------------------*/
2923 /*----------------------------------------------------------------------------*/
2924 
2925 inline static void
2926 cs_i_cd_steady_slope_test_vector(bool upwind_switch[3],
2927  const int iconvp,
2928  const int ircflp,
2929  const int ischcp,
2930  const double relaxp,
2931  const double blencp,
2932  const cs_real_t weight,
2933  const cs_real_t i_dist,
2934  const cs_real_t i_face_surf,
2935  const cs_real_3_t cell_ceni,
2936  const cs_real_3_t cell_cenj,
2937  const cs_real_3_t i_face_normal,
2938  const cs_real_3_t i_face_cog,
2939  const cs_real_3_t dijpf,
2940  const cs_real_t i_massflux,
2941  const cs_real_33_t gradi,
2942  const cs_real_33_t gradj,
2943  const cs_real_33_t grdpai,
2944  const cs_real_33_t grdpaj,
2945  const cs_real_3_t pi,
2946  const cs_real_3_t pj,
2947  const cs_real_3_t pia,
2948  const cs_real_3_t pja,
2949  cs_real_t pifri[3],
2950  cs_real_t pifrj[3],
2951  cs_real_t pjfri[3],
2952  cs_real_t pjfrj[3],
2953  cs_real_t pip[3],
2954  cs_real_t pjp[3],
2955  cs_real_t pipr[3],
2956  cs_real_t pjpr[3])
2957 {
2958  cs_real_3_t pir, pjr;
2959  cs_real_3_t recoi, recoj;
2960  cs_real_t distf, srfan;
2961  cs_real_3_t testij, tesqck;
2962  int isou;
2963 
2964  distf = i_dist;
2965  srfan = i_face_surf;
2966 
2967  for (isou = 0; isou < 3; isou++) {
2968  upwind_switch[isou] = false;
2969  }
2970 
2972  weight,
2973  cell_ceni,
2974  cell_cenj,
2975  i_face_cog,
2976  dijpf,
2977  gradi,
2978  gradj,
2979  pi,
2980  pj,
2981  recoi,
2982  recoj,
2983  pip,
2984  pjp);
2985 
2986  cs_i_relax_c_val_vector(relaxp,
2987  pia,
2988  pja,
2989  recoi,
2990  recoj,
2991  pi,
2992  pj,
2993  pir,
2994  pjr,
2995  pipr,
2996  pjpr);
2997 
2998  /* Convection slope test is needed only when iconv >0 */
2999  if (iconvp > 0) {
3001  pj,
3002  distf,
3003  srfan,
3004  i_face_normal,
3005  gradi,
3006  gradj,
3007  grdpai,
3008  grdpaj,
3009  i_massflux,
3010  testij,
3011  tesqck);
3012 
3013  for (isou = 0; isou < 3; isou++) {
3014  if (tesqck[isou]<=0. || testij[isou]<=0.) {
3015 
3016  /* Upwind
3017  --------*/
3018 
3019  cs_upwind_f_val(pi[isou],
3020  &pifrj[isou]);
3021  cs_upwind_f_val(pir[isou],
3022  &pifri[isou]);
3023  cs_upwind_f_val(pj[isou],
3024  &pjfri[isou]);
3025  cs_upwind_f_val(pjr[isou],
3026  &pjfrj[isou]);
3027 
3028  upwind_switch[isou] = true;
3029 
3030  } else {
3031 
3032  if (ischcp==1) {
3033 
3034  /* Centered
3035  --------*/
3036 
3037  cs_centered_f_val(weight,
3038  pip[isou],
3039  pjpr[isou],
3040  &pifrj[isou]);
3041  cs_centered_f_val(weight,
3042  pipr[isou],
3043  pjp[isou],
3044  &pifri[isou]);
3045  cs_centered_f_val(weight,
3046  pipr[isou],
3047  pjp[isou],
3048  &pjfri[isou]);
3049  cs_centered_f_val(weight,
3050  pip[isou],
3051  pjpr[isou],
3052  &pjfrj[isou]);
3053 
3054  } else {
3055 
3056  /* Second order
3057  ------------*/
3058 
3059  cs_solu_f_val(cell_ceni,
3060  i_face_cog,
3061  gradi[isou],
3062  pi[isou],
3063  &pifrj[isou]);
3064  cs_solu_f_val(cell_ceni,
3065  i_face_cog,
3066  gradi[isou],
3067  pir[isou],
3068  &pifri[isou]);
3069  cs_solu_f_val(cell_cenj,
3070  i_face_cog,
3071  gradj[isou],
3072  pj[isou],
3073  &pjfri[isou]);
3074  cs_solu_f_val(cell_cenj,
3075  i_face_cog,
3076  gradj[isou],
3077  pjr[isou],
3078  &pjfrj[isou]);
3079 
3080  }
3081  }
3082  }
3083 
3084  /* Blending
3085  --------*/
3086  cs_blend_f_val_vector(blencp,
3087  pi,
3088  pifrj);
3089  cs_blend_f_val_vector(blencp,
3090  pir,
3091  pifri);
3092  cs_blend_f_val_vector(blencp,
3093  pj,
3094  pjfri);
3095  cs_blend_f_val_vector(blencp,
3096  pjr,
3097  pjfrj);
3098 
3099  /* If iconv=0 p*fr* are useless */
3100  } else {
3101  for (isou = 0; isou < 3; isou++) {
3102  cs_upwind_f_val(pi[isou],
3103  &pifrj[isou]);
3104  cs_upwind_f_val(pir[isou],
3105  &pifri[isou]);
3106  cs_upwind_f_val(pj[isou],
3107  &pjfri[isou]);
3108  cs_upwind_f_val(pjr[isou],
3109  &pjfrj[isou]);
3110  }
3111  }
3112 
3113 }
3114 
3115 /*----------------------------------------------------------------------------*/
3153 /*----------------------------------------------------------------------------*/
3154 
3155 inline static void
3156 cs_i_cd_steady_slope_test_tensor(bool upwind_switch[6],
3157  const int iconvp,
3158  const int ircflp,
3159  const int ischcp,
3160  const double relaxp,
3161  const double blencp,
3162  const cs_real_t weight,
3163  const cs_real_t i_dist,
3164  const cs_real_t i_face_surf,
3165  const cs_real_3_t cell_ceni,
3166  const cs_real_3_t cell_cenj,
3167  const cs_real_3_t i_face_normal,
3168  const cs_real_3_t i_face_cog,
3169  const cs_real_3_t dijpf,
3170  const cs_real_t i_massflux,
3171  const cs_real_63_t gradi,
3172  const cs_real_63_t gradj,
3173  const cs_real_63_t grdpai,
3174  const cs_real_63_t grdpaj,
3175  const cs_real_6_t pi,
3176  const cs_real_6_t pj,
3177  const cs_real_6_t pia,
3178  const cs_real_6_t pja,
3179  cs_real_t pifri[6],
3180  cs_real_t pifrj[6],
3181  cs_real_t pjfri[6],
3182  cs_real_t pjfrj[6],
3183  cs_real_t pip[6],
3184  cs_real_t pjp[6],
3185  cs_real_t pipr[6],
3186  cs_real_t pjpr[6])
3187 {
3188  cs_real_6_t pir, pjr;
3189  cs_real_6_t recoi, recoj;
3190  cs_real_t distf, srfan;
3191  cs_real_6_t testij, tesqck;
3192  int isou;
3193 
3194  distf = i_dist;
3195  srfan = i_face_surf;
3196 
3197  for (isou = 0; isou < 6; isou++) {
3198  upwind_switch[isou] = false;
3199  }
3200 
3202  weight,
3203  cell_ceni,
3204  cell_cenj,
3205  i_face_cog,
3206  dijpf,
3207  gradi,
3208  gradj,
3209  pi,
3210  pj,
3211  recoi,
3212  recoj,
3213  pip,
3214  pjp);
3215 
3216  cs_i_relax_c_val_tensor(relaxp,
3217  pia,
3218  pja,
3219  recoi,
3220  recoj,
3221  pi,
3222  pj,
3223  pir,
3224  pjr,
3225  pipr,
3226  pjpr);
3227 
3228  /* Convection slope test is needed only when iconv >0 */
3229  if (iconvp > 0) {
3231  pj,
3232  distf,
3233  srfan,
3234  i_face_normal,
3235  gradi,
3236  gradj,
3237  grdpai,
3238  grdpaj,
3239  i_massflux,
3240  testij,
3241  tesqck);
3242 
3243  for (isou = 0; isou < 6; isou++) {
3244  if (tesqck[isou]<=0. || testij[isou]<=0.) {
3245 
3246  /* Upwind
3247  --------*/
3248 
3249  cs_upwind_f_val(pi[isou],
3250  &pifrj[isou]);
3251  cs_upwind_f_val(pir[isou],
3252  &pifri[isou]);
3253  cs_upwind_f_val(pj[isou],
3254  &pjfri[isou]);
3255  cs_upwind_f_val(pjr[isou],
3256  &pjfrj[isou]);
3257 
3258  upwind_switch[isou] = true;
3259 
3260  } else {
3261 
3262  if (ischcp==1) {
3263 
3264  /* Centered
3265  --------*/
3266 
3267  cs_centered_f_val(weight,
3268  pip[isou],
3269  pjpr[isou],
3270  &pifrj[isou]);
3271  cs_centered_f_val(weight,
3272  pipr[isou],
3273  pjp[isou],
3274  &pifri[isou]);
3275  cs_centered_f_val(weight,
3276  pipr[isou],
3277  pjp[isou],
3278  &pjfri[isou]);
3279  cs_centered_f_val(weight,
3280  pip[isou],
3281  pjpr[isou],
3282  &pjfrj[isou]);
3283 
3284  } else {
3285 
3286  /* Second order
3287  ------------*/
3288 
3289  cs_solu_f_val(cell_ceni,
3290  i_face_cog,
3291  gradi[isou],
3292  pi[isou],
3293  &pifrj[isou]);
3294  cs_solu_f_val(cell_ceni,
3295  i_face_cog,
3296  gradi[isou],
3297  pir[isou],
3298  &pifri[isou]);
3299  cs_solu_f_val(cell_cenj,
3300  i_face_cog,
3301  gradj[isou],
3302  pj[isou],
3303  &pjfri[isou]);
3304  cs_solu_f_val(cell_cenj,
3305  i_face_cog,
3306  gradj[isou],
3307  pjr[isou],
3308  &pjfrj[isou]);
3309 
3310  }
3311  }
3312  }
3313 
3314  /* Blending
3315  --------*/
3316 
3317  cs_blend_f_val_tensor(blencp,
3318  pi,
3319  pifrj);
3320  cs_blend_f_val_tensor(blencp,
3321  pir,
3322  pifri);
3323  cs_blend_f_val_tensor(blencp,
3324  pj,
3325  pjfri);
3326  cs_blend_f_val_tensor(blencp,
3327  pjr,
3328  pjfrj);
3329 
3330  /* If iconv=0 p*fr* are useless */
3331  } else {
3332  for (isou = 0; isou < 6; isou++) {
3333  cs_upwind_f_val(pi[isou],
3334  &pifrj[isou]);
3335  cs_upwind_f_val(pir[isou],
3336  &pifri[isou]);
3337  cs_upwind_f_val(pj[isou],
3338  &pjfri[isou]);
3339  cs_upwind_f_val(pjr[isou],
3340  &pjfrj[isou]);
3341  }
3342  }
3343 
3344 }
3345 
3346 /*----------------------------------------------------------------------------*/
3379 /*----------------------------------------------------------------------------*/
3380 
3381 inline static void
3382 cs_i_cd_unsteady_slope_test(bool *upwind_switch,
3383  const int iconvp,
3384  const int ircflp,
3385  const int ischcp,
3386  const double blencp,
3387  const cs_real_t weight,
3388  const cs_real_t i_dist,
3389  const cs_real_t i_face_surf,
3390  const cs_real_3_t cell_ceni,
3391  const cs_real_3_t cell_cenj,
3392  const cs_real_3_t i_face_normal,
3393  const cs_real_3_t i_face_cog,
3394  const cs_real_3_t dijpf,
3395  const cs_real_t i_massflux,
3396  const cs_real_3_t gradi,
3397  const cs_real_3_t gradj,
3398  const cs_real_3_t gradupi,
3399  const cs_real_3_t gradupj,
3400  const cs_real_3_t gradsti,
3401  const cs_real_3_t gradstj,
3402  const cs_real_t pi,
3403  const cs_real_t pj,
3404  cs_real_t *pif,
3405  cs_real_t *pjf,
3406  cs_real_t *pip,
3407  cs_real_t *pjp)
3408 {
3409  cs_real_t recoi, recoj;
3410  cs_real_t distf, srfan, testij, tesqck;
3411 
3412  distf = i_dist;
3413  srfan = i_face_surf;
3414 
3415  *upwind_switch = false;
3416 
3417  cs_i_compute_quantities(ircflp,
3418  weight,
3419  cell_ceni,
3420  cell_cenj,
3421  i_face_cog,
3422  dijpf,
3423  gradi,
3424  gradj,
3425  pi,
3426  pj,
3427  &recoi,
3428  &recoj,
3429  pip,
3430  pjp);
3431 
3432  /* Convection slope test is needed only when iconv >0 */
3433  if (iconvp > 0) {
3434  cs_slope_test(pi,
3435  pj,
3436  distf,
3437  srfan,
3438  i_face_normal,
3439  gradi,
3440  gradj,
3441  gradsti,
3442  gradstj,
3443  i_massflux,
3444  &testij,
3445  &tesqck);
3446 
3447  if (tesqck<=0. || testij<=0.) {
3448 
3449  /* Upwind
3450  --------*/
3451 
3452  cs_upwind_f_val(pi,
3453  pif);
3454  cs_upwind_f_val(pj,
3455  pjf);
3456 
3457  *upwind_switch = true;
3458 
3459  } else {
3460 
3461  if (ischcp==1) {
3462 
3463  /* Centered
3464  --------*/
3465 
3466  cs_centered_f_val(weight,
3467  *pip,
3468  *pjp,
3469  pif);
3470  cs_centered_f_val(weight,
3471  *pip,
3472  *pjp,
3473  pjf);
3474 
3475  } else if (ischcp == 0) {
3476 
3477  /* Original SOLU
3478  --------------*/
3479 
3480  cs_solu_f_val(cell_ceni,
3481  i_face_cog,
3482  gradi,
3483  pi,
3484  pif);
3485  cs_solu_f_val(cell_cenj,
3486  i_face_cog,
3487  gradj,
3488  pj,
3489  pjf);
3490 
3491  } else {
3492 
3493  /* SOLU
3494  -----*/
3495 
3496  cs_solu_f_val(cell_ceni,
3497  i_face_cog,
3498  gradupi,
3499  pi,
3500  pif);
3501  cs_solu_f_val(cell_cenj,
3502  i_face_cog,
3503  gradupj,
3504  pj,
3505  pjf);
3506 
3507  }
3508  }
3509 
3510  /* Blending
3511  --------*/
3512 
3513  cs_blend_f_val(blencp,
3514  pi,
3515  pif);
3516  cs_blend_f_val(blencp,
3517  pj,
3518  pjf);
3519 
3520  /* If iconv=0 p*f are useless */
3521  } else {
3522  cs_upwind_f_val(pi,
3523  pif);
3524  cs_upwind_f_val(pj,
3525  pjf);
3526  }
3527 
3528 }
3529 
3530 /*----------------------------------------------------------------------------*/
3561 /*----------------------------------------------------------------------------*/
3562 
3563 inline static void
3565  const int iconvp,
3566  const int ircflp,
3567  const int ischcp,
3568  const double blencp,
3569  const cs_real_t weight,
3570  const cs_real_t i_dist,
3571  const cs_real_t i_face_surf,
3572  const cs_real_3_t cell_ceni,
3573  const cs_real_3_t cell_cenj,
3574  const cs_real_3_t i_face_normal,
3575  const cs_real_3_t i_face_cog,
3576  const cs_real_3_t dijpf,
3577  const cs_real_t i_massflux,
3578  const cs_real_33_t gradi,
3579  const cs_real_33_t gradj,
3580  const cs_real_33_t grdpai,
3581  const cs_real_33_t grdpaj,
3582  const cs_real_3_t pi,
3583  const cs_real_3_t pj,
3584  cs_real_t pif[3],
3585  cs_real_t pjf[3],
3586  cs_real_t pip[3],
3587  cs_real_t pjp[3])
3588 {
3589  cs_real_3_t recoi, recoj;
3590  cs_real_t distf, srfan;
3591  cs_real_3_t testij, tesqck;
3592  int isou;
3593 
3594  distf = i_dist;
3595  srfan = i_face_surf;
3596 
3597  for (isou = 0; isou < 3; isou++) {
3598  upwind_switch[isou] = false;
3599  }
3600 
3602  weight,
3603  cell_ceni,
3604  cell_cenj,
3605  i_face_cog,
3606  dijpf,
3607  gradi,
3608  gradj,
3609  pi,
3610  pj,
3611  recoi,
3612  recoj,
3613  pip,
3614  pjp);
3615 
3616  /* Convection slope test is needed only when iconv >0 */
3617  if (iconvp > 0) {
3619  pj,
3620  distf,
3621  srfan,
3622  i_face_normal,
3623  gradi,
3624  gradj,
3625  grdpai,
3626  grdpaj,
3627  i_massflux,
3628  testij,
3629  tesqck);
3630 
3631  /* FIXME: slope test should be done for the vector and not component by
3632  * component. This is concerved for compatibility only. */
3633  for (isou = 0; isou < 3; isou++) {
3634  if (tesqck[isou]<=0. || testij[isou]<=0.) {
3635 
3636  /* Upwind
3637  --------*/
3638 
3639  cs_upwind_f_val(pi[isou],
3640  &pif[isou]);
3641  cs_upwind_f_val(pj[isou],
3642  &pjf[isou]);
3643 
3644  upwind_switch[isou] = true;
3645 
3646  } else {
3647 
3648  if (ischcp==1) {
3649 
3650  /* Centered
3651  --------*/
3652 
3653  cs_centered_f_val(weight,
3654  pip[isou],
3655  pjp[isou],
3656  &pif[isou]);
3657  cs_centered_f_val(weight,
3658  pip[isou],
3659  pjp[isou],
3660  &pjf[isou]);
3661 
3662  } else {
3663 
3664  /* Second order
3665  ------------*/
3666 
3667  cs_solu_f_val(cell_ceni,
3668  i_face_cog,
3669  gradi[isou],
3670  pi[isou],
3671  &pif[isou]);
3672  cs_solu_f_val(cell_cenj,
3673  i_face_cog,
3674  gradj[isou],
3675  pj[isou],
3676  &pjf[isou]);
3677 
3678  }
3679  }
3680  }
3681 
3682  /* Blending
3683  --------*/
3684  cs_blend_f_val_vector(blencp,
3685  pi,
3686  pif);
3687  cs_blend_f_val_vector(blencp,
3688  pj,
3689  pjf);
3690 
3691  /* If iconv=0 p*f are useless */
3692  } else {
3693 
3694  for (isou = 0; isou < 3; isou++) {
3695  cs_upwind_f_val(pi[isou],
3696  &pif[isou]);
3697  cs_upwind_f_val(pj[isou],
3698  &pjf[isou]);
3699 
3700  }
3701  }
3702 }
3703 
3704 /*----------------------------------------------------------------------------*/
3735 /*----------------------------------------------------------------------------*/
3736 
3737 inline static void
3739  const int iconvp,
3740  const int ircflp,
3741  const int ischcp,
3742  const double blencp,
3743  const cs_real_t weight,
3744  const cs_real_t i_dist,
3745  const cs_real_t i_face_surf,
3746  const cs_real_3_t cell_ceni,
3747  const cs_real_3_t cell_cenj,
3748  const cs_real_3_t i_face_normal,
3749  const cs_real_3_t i_face_cog,
3750  const cs_real_3_t dijpf,
3751  const cs_real_t i_massflux,
3752  const cs_real_63_t gradi,
3753  const cs_real_63_t gradj,
3754  const cs_real_63_t grdpai,
3755  const cs_real_63_t grdpaj,
3756  const cs_real_6_t pi,
3757  const cs_real_6_t pj,
3758  cs_real_t pif[6],
3759  cs_real_t pjf[6],
3760  cs_real_t pip[6],
3761  cs_real_t pjp[6])
3762 {
3763  cs_real_6_t recoi, recoj;
3764  cs_real_t distf, srfan;
3765  cs_real_6_t testij, tesqck;
3766  int isou;
3767 
3768  distf = i_dist;
3769  srfan = i_face_surf;
3770 
3771  for (isou = 0; isou < 6; isou++) {
3772  upwind_switch[isou] = false;
3773  }
3774 
3776  weight,
3777  cell_ceni,
3778  cell_cenj,
3779  i_face_cog,
3780  dijpf,
3781  gradi,
3782  gradj,
3783  pi,
3784  pj,
3785  recoi,
3786  recoj,
3787  pip,
3788  pjp);
3789 
3790  /* Convection slope test is needed only when iconv >0 */
3791  if (iconvp > 0) {
3793  pj,
3794  distf,
3795  srfan,
3796  i_face_normal,
3797  gradi,
3798  gradj,
3799  grdpai,
3800  grdpaj,
3801  i_massflux,
3802  testij,
3803  tesqck);
3804  for (isou = 0; isou < 6; isou++) {
3805  if (tesqck[isou]<=0. || testij[isou]<=0.) {
3806 
3807  /* Upwind
3808  --------*/
3809 
3810  cs_upwind_f_val(pi[isou],
3811  &pif[isou]);
3812  cs_upwind_f_val(pj[isou],
3813  &pjf[isou]);
3814 
3815  upwind_switch[isou] = true;
3816 
3817  } else {
3818 
3819  if (ischcp==1) {
3820 
3821  /* Centered
3822  --------*/
3823 
3824  cs_centered_f_val(weight,
3825  pip[isou],
3826  pjp[isou],
3827  &pif[isou]);
3828  cs_centered_f_val(weight,
3829  pip[isou],
3830  pjp[isou],
3831  &pjf[isou]);
3832 
3833  } else {
3834 
3835  /* Second order
3836  ------------*/
3837 
3838  cs_solu_f_val(cell_ceni,
3839  i_face_cog,
3840  gradi[isou],
3841  pi[isou],
3842  &pif[isou]);
3843  cs_solu_f_val(cell_cenj,
3844  i_face_cog,
3845  gradj[isou],
3846  pj[isou],
3847  &pjf[isou]);
3848  }
3849  }
3850  }
3851 
3852  /* Blending
3853  --------*/
3854 
3855  cs_blend_f_val_tensor(blencp,
3856  pi,
3857  pif);
3858  cs_blend_f_val_tensor(blencp,
3859  pj,
3860  pjf);
3861 
3862  /* If iconv=0 p*fr* are useless */
3863  } else {
3864 
3865  for (isou = 0; isou < 6; isou++) {
3866  cs_upwind_f_val(pi[isou],
3867  &pif[isou]);
3868  cs_upwind_f_val(pj[isou],
3869  &pjf[isou]);
3870  }
3871  }
3872 }
3873 
3874 /*----------------------------------------------------------------------------*/
3883 /*----------------------------------------------------------------------------*/
3884 
3885 inline static void
3887  const cs_real_3_t gradi,
3888  const int ircflp,
3889  cs_real_t *recoi)
3890 {
3891  *recoi = ircflp * ( gradi[0]*diipb[0]
3892  + gradi[1]*diipb[1]
3893  + gradi[2]*diipb[2]);
3894 }
3895 
3896 /*----------------------------------------------------------------------------*/
3905 /*----------------------------------------------------------------------------*/
3906 
3907 inline static void
3909  const cs_real_33_t gradi,
3910  const int ircflp,
3911  cs_real_t recoi[3])
3912 {
3913  for (int isou = 0; isou < 3; isou++) {
3914  recoi[isou] = ircflp * (gradi[isou][0]*diipb[0]
3915  + gradi[isou][1]*diipb[1]
3916  + gradi[isou][2]*diipb[2]);
3917  }
3918 }
3919 
3920 /*----------------------------------------------------------------------------*/
3929 /*----------------------------------------------------------------------------*/
3930 
3931 inline static void
3933  const cs_real_63_t gradi,
3934  const int ircflp,
3935  cs_real_t recoi[6])
3936 {
3937  for (int isou = 0; isou < 6; isou++) {
3938  recoi[isou] = ircflp * (gradi[isou][0]*diipb[0]
3939  + gradi[isou][1]*diipb[1]
3940  + gradi[isou][2]*diipb[2]);
3941  }
3942 }
3943 
3944 /*----------------------------------------------------------------------------*/
3955 /*----------------------------------------------------------------------------*/
3956 
3957 inline static void
3958 cs_b_relax_c_val(const double relaxp,
3959  const cs_real_t pi,
3960  const cs_real_t pia,
3961  const cs_real_t recoi,
3962  cs_real_t *pir,
3963  cs_real_t *pipr)
3964 {
3965  *pir = pi/relaxp - (1.-relaxp)/relaxp*pia;
3966  *pipr = *pir + recoi;
3967 }
3968 
3969 /*----------------------------------------------------------------------------*/
3980 /*----------------------------------------------------------------------------*/
3981 
3982 inline static void
3983 cs_b_relax_c_val_vector(const double relaxp,
3984  const cs_real_3_t pi,
3985  const cs_real_3_t pia,
3986  const cs_real_3_t recoi,
3987  cs_real_t pir[3],
3988  cs_real_t pipr[3])
3989 {
3990  for (int isou = 0; isou < 3; isou++) {
3991  pir[isou] = pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
3992  pipr[isou] = pir[isou] + recoi[isou];
3993  }
3994 }
3995 
3996 /*----------------------------------------------------------------------------*/
4007 /*----------------------------------------------------------------------------*/
4008 
4009 inline static void
4010 cs_b_relax_c_val_tensor(const double relaxp,
4011  const cs_real_6_t pi,
4012  const cs_real_6_t pia,
4013  const cs_real_6_t recoi,
4014  cs_real_t pir[6],
4015  cs_real_t pipr[6])
4016 {
4017  for (int isou = 0; isou < 6; isou++) {
4018  pir[isou] = pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
4019  pipr[isou] = pir[isou] + recoi[isou];
4020  }
4021 }
4022 
4023 /*----------------------------------------------------------------------------*/
4047 /*----------------------------------------------------------------------------*/
4048 
4049 inline static void
4051  cs_real_t thetap,
4052  int imasac,
4053  int inc,
4054  cs_int_t bc_type,
4055  int icvfli,
4056  cs_real_t pi,
4057  cs_real_t pir,
4058  cs_real_t pipr,
4059  cs_real_t coefap,
4060  cs_real_t coefbp,
4061  cs_real_t coface,
4062  cs_real_t cofbce,
4063  cs_real_t b_massflux,
4064  cs_real_t xcpp,
4065  cs_real_t *flux)
4066 {
4067  cs_real_t flui, fluj, pfac;
4068 
4069  /* Computed convective flux */
4070 
4071  if (icvfli == 0) {
4072 
4073  /* Remove decentering for coupled faces */
4074  if (bc_type == CS_COUPLED_FD) {
4075  flui = 0.0;
4076  fluj = b_massflux;
4077  } else {
4078  flui = 0.5*(b_massflux +fabs(b_massflux));
4079  fluj = 0.5*(b_massflux -fabs(b_massflux));
4080  }
4081 
4082  pfac = inc*coefap + coefbp*pipr;
4083  *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*pi));
4084 
4085  /* Imposed convective flux */
4086 
4087  } else {
4088 
4089  pfac = inc*coface + cofbce*pipr;
4090  *flux += iconvp*xcpp*(-imasac*(b_massflux*pi) + thetap*(pfac));
4091 
4092  }
4093 }
4094 
4095 /*----------------------------------------------------------------------------*/
4117 /*----------------------------------------------------------------------------*/
4118 
4119 inline static void
4121  cs_real_t thetap,
4122  int imasac,
4123  int inc,
4124  cs_int_t bc_type,
4125  int icvfli,
4126  const cs_real_t pi[restrict 3],
4127  const cs_real_t pir[restrict 3],
4128  const cs_real_t pipr[restrict 3],
4129  const cs_real_t coefap[restrict 3],
4130  const cs_real_t coefbp[restrict 3][3],
4131  const cs_real_t coface[restrict 3],
4132  const cs_real_t cofbce[restrict 3][3],
4133  cs_real_t b_massflux,
4134  cs_real_t flux[restrict 3])
4135 {
4136  cs_real_t flui, fluj, pfac;
4137 
4138  /* Computed convective flux */
4139 
4140  if (icvfli == 0) {
4141 
4142  /* Remove decentering for coupled faces */
4143  if (bc_type == CS_COUPLED_FD) {
4144  flui = 0.0;
4145  fluj = b_massflux;
4146  } else {
4147  flui = 0.5*(b_massflux +fabs(b_massflux));
4148  fluj = 0.5*(b_massflux -fabs(b_massflux));
4149  }
4150  for (int isou = 0; isou < 3; isou++) {
4151  pfac = inc*coefap[isou];
4152  for (int jsou = 0; jsou < 3; jsou++) {
4153  pfac += coefbp[isou][jsou]*pipr[jsou];
4154  }
4155  flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4156  - imasac*b_massflux*pi[isou]);
4157  }
4158 
4159  /* Imposed convective flux */
4160 
4161  } else {
4162 
4163  for (int isou = 0; isou < 3; isou++) {
4164  pfac = inc*coface[isou];
4165  for (int jsou = 0; jsou < 3; jsou++) {
4166  pfac += cofbce[isou][jsou]*pipr[jsou];
4167  }
4168  flux[isou] += iconvp*( thetap*pfac
4169  - imasac*b_massflux*pi[isou]);
4170  }
4171 
4172  }
4173 }
4174 
4175 /*----------------------------------------------------------------------------*/
4195 /*----------------------------------------------------------------------------*/
4196 
4197 inline static void
4198 cs_b_upwind_flux(const int iconvp,
4199  const cs_real_t thetap,
4200  const int imasac,
4201  const int inc,
4202  const int bc_type,
4203  const cs_real_t pi,
4204  const cs_real_t pir,
4205  const cs_real_t pipr,
4206  const cs_real_t coefap,
4207  const cs_real_t coefbp,
4208  const cs_real_t b_massflux,
4209  const cs_real_t xcpp,
4210  cs_real_t *flux)
4211 {
4212  cs_real_t flui, fluj, pfac;
4213 
4214  /* Remove decentering for coupled faces */
4215  if (bc_type == CS_COUPLED_FD) {
4216  flui = 0.0;
4217  fluj = b_massflux;
4218  } else {
4219  flui = 0.5*(b_massflux +fabs(b_massflux));
4220  fluj = 0.5*(b_massflux -fabs(b_massflux));
4221  }
4222 
4223  pfac = inc*coefap + coefbp*pipr;
4224  *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*pi));
4225 }
4226 
4227 /*----------------------------------------------------------------------------*/
4245 /*----------------------------------------------------------------------------*/
4246 
4247 inline static void
4248 cs_b_upwind_flux_vector(const int iconvp,
4249  const cs_real_t thetap,
4250  const int imasac,
4251  const int inc,
4252  const int bc_type,
4253  const cs_real_3_t pi,
4254  const cs_real_3_t pir,
4255  const cs_real_3_t pipr,
4256  const cs_real_3_t coefa,
4257  const cs_real_33_t coefb,
4258  const cs_real_t b_massflux,
4259  cs_real_t flux[3])
4260 {
4261  cs_real_t flui, fluj, pfac;
4262 
4263  /* Remove decentering for coupled faces */
4264  if (bc_type == CS_COUPLED_FD) {
4265  flui = 0.0;
4266  fluj = b_massflux;
4267  } else {
4268  flui = 0.5*(b_massflux +fabs(b_massflux));
4269  fluj = 0.5*(b_massflux -fabs(b_massflux));
4270  }
4271  for (int isou = 0; isou < 3; isou++) {
4272  pfac = inc*coefa[isou];
4273  for (int jsou = 0; jsou < 3; jsou++) {
4274  pfac += coefb[isou][jsou]*pipr[jsou];
4275  }
4276  flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4277  - imasac*b_massflux*pi[isou]);
4278  }
4279 }
4280 
4281 /*----------------------------------------------------------------------------*/
4299 /*----------------------------------------------------------------------------*/
4300 
4301 inline static void
4302 cs_b_upwind_flux_tensor(const int iconvp,
4303  const cs_real_t thetap,
4304  const int imasac,
4305  const int inc,
4306  const int bc_type,
4307  const cs_real_6_t pi,
4308  const cs_real_6_t pir,
4309  const cs_real_6_t pipr,
4310  const cs_real_6_t coefa,
4311  const cs_real_66_t coefb,
4312  const cs_real_t b_massflux,
4313  cs_real_t flux[6])
4314 {
4315  cs_real_t flui, fluj, pfac;
4316 
4317  /* Remove decentering for coupled faces */
4318  if (bc_type == CS_COUPLED_FD) {
4319  flui = 0.0;
4320  fluj = b_massflux;
4321  } else {
4322  flui = 0.5*(b_massflux +fabs(b_massflux));
4323  fluj = 0.5*(b_massflux -fabs(b_massflux));
4324  }
4325  for (int isou = 0; isou < 6; isou++) {
4326  pfac = inc*coefa[isou];
4327  for (int jsou = 0; jsou < 6; jsou++) {
4328  pfac += coefb[isou][jsou]*pipr[jsou];
4329  }
4330  flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4331  - imasac*b_massflux*pi[isou]);
4332  }
4333 }
4334 
4335 /*----------------------------------------------------------------------------*/
4348 /*----------------------------------------------------------------------------*/
4349 
4350 inline static void
4351 cs_b_diff_flux(const int idiffp,
4352  const cs_real_t thetap,
4353  const int inc,
4354  const cs_real_t pipr,
4355  const cs_real_t cofafp,
4356  const cs_real_t cofbfp,
4357  const cs_real_t b_visc,
4358  cs_real_t *flux)
4359 {
4360  cs_real_t pfacd = inc*cofafp + cofbfp*pipr;
4361  *flux += idiffp*thetap*b_visc*pfacd;
4362 }
4363 
4364 /*----------------------------------------------------------------------------*/
4377 /*----------------------------------------------------------------------------*/
4378 
4379 inline static void
4380 cs_b_diff_flux_vector(const int idiffp,
4381  const cs_real_t thetap,
4382  const int inc,
4383  const cs_real_3_t pipr,
4384  const cs_real_3_t cofaf,
4385  const cs_real_33_t cofbf,
4386  const cs_real_t b_visc,
4387  cs_real_t flux[3])
4388 {
4389  cs_real_t pfacd ;
4390  for (int isou = 0; isou < 3; isou++) {
4391  pfacd = inc*cofaf[isou];
4392  for (int jsou = 0; jsou < 3; jsou++) {
4393  pfacd += cofbf[isou][jsou]*pipr[jsou];
4394  }
4395  flux[isou] += idiffp*thetap*b_visc*pfacd;
4396  }
4397 }
4398 
4399 /*----------------------------------------------------------------------------*/
4412 /*----------------------------------------------------------------------------*/
4413 
4414 inline static void
4415 cs_b_diff_flux_tensor(const int idiffp,
4416  const cs_real_t thetap,
4417  const int inc,
4418  const cs_real_6_t pipr,
4419  const cs_real_6_t cofaf,
4420  const cs_real_66_t cofbf,
4421  const cs_real_t b_visc,
4422  cs_real_t flux[6])
4423 {
4424  cs_real_t pfacd ;
4425  for (int isou = 0; isou < 6; isou++) {
4426  pfacd = inc*cofaf[isou];
4427  for (int jsou = 0; jsou < 6; jsou++) {
4428  pfacd += cofbf[isou][jsou]*pipr[jsou];
4429  }
4430  flux[isou] += idiffp*thetap*b_visc*pfacd;
4431  }
4432 }
4433 
4434 /*----------------------------------------------------------------------------*/
4448 /*----------------------------------------------------------------------------*/
4449 
4450 inline static void
4451 cs_b_cd_steady(const int ircflp,
4452  const double relaxp,
4453  const cs_real_3_t diipb,
4454  const cs_real_3_t gradi,
4455  const cs_real_t pi,
4456  const cs_real_t pia,
4457  cs_real_t *pir,
4458  cs_real_t *pipr)
4459 {
4460  cs_real_t recoi;
4461 
4463  gradi,
4464  ircflp,
4465  &recoi);
4466 
4467  cs_b_relax_c_val(relaxp,
4468  pi,
4469  pia,
4470  recoi,
4471  pir,
4472  pipr);
4473 }
4474 
4475 /*----------------------------------------------------------------------------*/
4489 /*----------------------------------------------------------------------------*/
4490 
4491 inline static void
4492 cs_b_cd_steady_vector(const int ircflp,
4493  const double relaxp,
4494  const cs_real_3_t diipb,
4495  const cs_real_33_t gradi,
4496  const cs_real_3_t pi,
4497  const cs_real_3_t pia,
4498  cs_real_t pir[3],
4499  cs_real_t pipr[3])
4500 {
4501  cs_real_3_t recoi;
4502 
4504  gradi,
4505  ircflp,
4506  recoi);
4507 
4508  cs_b_relax_c_val_vector(relaxp,
4509  pi,
4510  pia,
4511  recoi,
4512  pir,
4513  pipr);
4514 }
4515 
4516 /*----------------------------------------------------------------------------*/
4530 /*----------------------------------------------------------------------------*/
4531 
4532 inline static void
4533 cs_b_cd_steady_tensor(const int ircflp,
4534  const double relaxp,
4535  const cs_real_3_t diipb,
4536  const cs_real_63_t gradi,
4537  const cs_real_6_t pi,
4538  const cs_real_6_t pia,
4539  cs_real_t pir[6],
4540  cs_real_t pipr[6])
4541 {
4542  cs_real_6_t recoi;
4543 
4545  gradi,
4546  ircflp,
4547  recoi);
4548 
4549  cs_b_relax_c_val_tensor(relaxp,
4550  pi,
4551  pia,
4552  recoi,
4553  pir,
4554  pipr);
4555 }
4556 
4557 /*----------------------------------------------------------------------------*/
4568 /*----------------------------------------------------------------------------*/
4569 
4570 inline static void
4571 cs_b_cd_unsteady(const int ircflp,
4572  const cs_real_3_t diipb,
4573  const cs_real_3_t gradi,
4574  const cs_real_t pi,
4575  cs_real_t *pip)
4576 {
4577  cs_real_t recoi;
4578 
4580  gradi,
4581  ircflp,
4582  &recoi);
4583 
4584  *pip = pi + recoi;
4585 }
4586 
4587 /*----------------------------------------------------------------------------*/
4598 /*----------------------------------------------------------------------------*/
4599 
4600 inline static void
4601 cs_b_cd_unsteady_vector(const int ircflp,
4602  const cs_real_3_t diipb,
4603  const cs_real_33_t gradi,
4604  const cs_real_3_t pi,
4605  cs_real_t pip[3])
4606 {
4607  cs_real_3_t recoi;
4608 
4610  gradi,
4611  ircflp,
4612  recoi);
4613 
4614  for(int isou = 0; isou< 3; isou++)
4615  pip[isou] = pi[isou] + recoi[isou];
4616 }
4617 
4618 /*----------------------------------------------------------------------------*/
4629 /*----------------------------------------------------------------------------*/
4630 
4631 inline static void
4632 cs_b_cd_unsteady_tensor(const int ircflp,
4633  const cs_real_3_t diipb,
4634  const cs_real_63_t gradi,
4635  const cs_real_6_t pi,
4636  cs_real_t pip[6])
4637 {
4638  cs_real_6_t recoi;
4639 
4641  gradi,
4642  ircflp,
4643  recoi);
4644 
4645  for(int isou = 0; isou< 6; isou++)
4646  pip[isou] = pi[isou] + recoi[isou];
4647 }
4648 
4649 /*============================================================================
4650  * Public function prototypes for Fortran API
4651  *============================================================================*/
4652 
4653 /*----------------------------------------------------------------------------
4654  * Wrapper to cs_face_diffusion_potential
4655  *----------------------------------------------------------------------------*/
4656 
4657 void CS_PROCF (itrmas, ITRMAS)
4658 (
4659  const cs_int_t *const f_id,
4660  const cs_int_t *const init,
4661  const cs_int_t *const inc,
4662  const cs_int_t *const imrgra,
4663  const cs_int_t *const iccocg,
4664  const cs_int_t *const nswrgp,
4665  const cs_int_t *const imligp,
4666  const cs_int_t *const iphydp,
4667  const cs_int_t *const iwarnp,
4668  const cs_real_t *const epsrgp,
4669  const cs_real_t *const climgp,
4670  const cs_real_t *const extrap,
4671  cs_real_3_t frcxt[],
4672  cs_real_t pvar[],
4673  const cs_real_t coefap[],
4674  const cs_real_t coefbp[],
4675  const cs_real_t cofafp[],
4676  const cs_real_t cofbfp[],
4677  const cs_real_t i_visc[],
4678  const cs_real_t b_visc[],
4679  cs_real_t viselx[],
4680  const cs_real_t visely[],
4681  const cs_real_t viselz[],
4682  cs_real_t i_massflux[],
4683  cs_real_t b_massflux[]
4684 );
4685 
4686 /*----------------------------------------------------------------------------
4687  * Wrapper to cs_face_anisotropic_diffusion_potential
4688  *----------------------------------------------------------------------------*/
4689 
4690 void CS_PROCF (itrmav, ITRMAV)
4691 (
4692  const cs_int_t *const f_id,
4693  const cs_int_t *const init,
4694  const cs_int_t *const inc,
4695  const cs_int_t *const imrgra,
4696  const cs_int_t *const iccocg,
4697  const cs_int_t *const nswrgp,
4698  const cs_int_t *const imligp,
4699  const cs_int_t *const ircflp,
4700  const cs_int_t *const iphydp,
4701  const cs_int_t *const iwarnp,
4702  const cs_real_t *const epsrgp,
4703  const cs_real_t *const climgp,
4704  const cs_real_t *const extrap,
4705  cs_real_3_t frcxt[],
4706  cs_real_t pvar[],
4707  const cs_real_t coefap[],
4708  const cs_real_t coefbp[],
4709  const cs_real_t cofafp[],
4710  const cs_real_t cofbfp[],
4711  const cs_real_t i_visc[],
4712  const cs_real_t b_visc[],
4713  cs_real_6_t viscel[],
4714  const cs_real_2_t weighf[],
4715  const cs_real_t weighb[],
4716  cs_real_t i_massflux[],
4717  cs_real_t b_massflux[]
4718 );
4719 
4720 /*----------------------------------------------------------------------------
4721  * Wrapper to cs_diffusion_potential
4722  *----------------------------------------------------------------------------*/
4723 
4724 void CS_PROCF (itrgrp, ITRGRP)
4725 (
4726  const cs_int_t *const f_id,
4727  const cs_int_t *const init,
4728  const cs_int_t *const inc,
4729  const cs_int_t *const imrgra,
4730  const cs_int_t *const iccocg,
4731  const cs_int_t *const nswrgp,
4732  const cs_int_t *const imligp,
4733  const cs_int_t *const iphydp,
4734  const cs_int_t *const iwarnp,
4735  const cs_real_t *const epsrgp,
4736  const cs_real_t *const climgp,
4737  const cs_real_t *const extrap,
4738  cs_real_3_t frcxt[],
4739  cs_real_t pvar[],
4740  const cs_real_t coefap[],
4741  const cs_real_t coefbp[],
4742  const cs_real_t cofafp[],
4743  const cs_real_t cofbfp[],
4744  const cs_real_t i_visc[],
4745  const cs_real_t b_visc[],
4746  const cs_real_t viselx[],
4747  const cs_real_t visely[],
4748  const cs_real_t viselz[],
4749  cs_real_t diverg[]
4750 );
4751 
4752 /*----------------------------------------------------------------------------
4753  * Wrapper to cs_anisotropic_diffusion_potential
4754  *----------------------------------------------------------------------------*/
4755 
4756 void CS_PROCF (itrgrv, ITRGRV)
4757 (
4758  const cs_int_t *const f_id,
4759  const cs_int_t *const init,
4760  const cs_int_t *const inc,
4761  const cs_int_t *const imrgra,
4762  const cs_int_t *const iccocg,
4763  const cs_int_t *const nswrgp,
4764  const cs_int_t *const imligp,
4765  const cs_int_t *const ircflp,
4766  const cs_int_t *const iphydp,
4767  const cs_int_t *const iwarnp,
4768  const cs_real_t *const epsrgp,
4769  const cs_real_t *const climgp,
4770  const cs_real_t *const extrap,
4771  cs_real_3_t frcxt[],
4772  cs_real_t pvar[],
4773  const cs_real_t coefap[],
4774  const cs_real_t coefbp[],
4775  const cs_real_t cofafp[],
4776  const cs_real_t cofbfp[],
4777  const cs_real_t i_visc[],
4778  const cs_real_t b_visc[],
4779  cs_real_6_t viscel[],
4780  const cs_real_2_t weighf[],
4781  const cs_real_t weighb[],
4782  cs_real_t diverg[]
4783 );
4784 
4785 /*=============================================================================
4786  * Public function prototypes
4787  *============================================================================*/
4788 
4789 /*----------------------------------------------------------------------------*/
4805 /*----------------------------------------------------------------------------*/
4806 
4807 void
4808 cs_slope_test_gradient(const int f_id,
4809  const int inc,
4810  const cs_halo_type_t halo_type,
4811  cs_real_3_t *grad,
4812  cs_real_3_t *grdpa,
4813  cs_real_t *pvar,
4814  const cs_real_t *coefap,
4815  const cs_real_t *coefbp,
4816  const cs_real_t *i_massflux);
4817 
4818 /*----------------------------------------------------------------------------*/
4834 /*----------------------------------------------------------------------------*/
4835 
4836 void
4837 cs_upwind_gradient(const int f_id,
4838  const int inc,
4839  const cs_halo_type_t halo_type,
4840  const cs_real_t coefap[],
4841  const cs_real_t coefbp[],
4842  const cs_real_t i_massflux[],
4843  const cs_real_t b_massflux[],
4844  const cs_real_t *restrict pvar,
4845  cs_real_3_t *restrict grdpa);
4846 
4847 /*----------------------------------------------------------------------------*/
4862 /*----------------------------------------------------------------------------*/
4863 
4864 void
4865 cs_slope_test_gradient_vector(const int inc,
4866  const cs_halo_type_t halo_type,
4867  cs_real_33_t *grad,
4868  cs_real_33_t *grdpa,
4869  cs_real_3_t *pvar,
4870  const cs_real_3_t *coefa,
4871  const cs_real_33_t *coefb,
4872  const cs_real_t *i_massflux);
4873 
4874 /*----------------------------------------------------------------------------*/
4889 /*----------------------------------------------------------------------------*/
4890 
4891 void
4892 cs_slope_test_gradient_tensor(const int inc,
4893  const cs_halo_type_t halo_type,
4894  cs_real_63_t *grad,
4895  cs_real_63_t *grdpa,
4896  cs_real_6_t *pvar,
4897  const cs_real_6_t *coefa,
4898  const cs_real_66_t *coefb,
4899  const cs_real_t *i_massflux);
4900 
4901 /*----------------------------------------------------------------------------*/
4910 /*----------------------------------------------------------------------------*/
4911 
4912 void
4913 cs_max_limiter_building(int f_id,
4914  int inc,
4915  const cs_real_t rovsdt[]);
4916 
4917 /*----------------------------------------------------------------------------*/
4969 /*----------------------------------------------------------------------------*/
4970 
4971 void
4973  int f_id,
4974  const cs_var_cal_opt_t var_cal_opt,
4975  int icvflb,
4976  int inc,
4977  int iccocg,
4978  int imasac,
4979  cs_real_t *restrict pvar,
4980  const cs_real_t *restrict pvara,
4981  const cs_int_t icvfli[],
4982  const cs_real_t coefap[],
4983  const cs_real_t coefbp[],
4984  const cs_real_t cofafp[],
4985  const cs_real_t cofbfp[],
4986  const cs_real_t i_massflux[],
4987  const cs_real_t b_massflux[],
4988  const cs_real_t i_visc[],
4989  const cs_real_t b_visc[],
4990  cs_real_t *restrict rhs);
4991 
4992 /*----------------------------------------------------------------------------*/
5051 /*----------------------------------------------------------------------------*/
5052 
5053 void
5055  int f_id,
5056  const cs_var_cal_opt_t var_cal_opt,
5057  int icvflb,
5058  int inc,
5059  int ivisep,
5060  int imasac,
5061  cs_real_3_t *restrict pvar,
5062  const cs_real_3_t *restrict pvara,
5063  const cs_int_t icvfli[],
5064  const cs_real_3_t coefav[],
5065  const cs_real_33_t coefbv[],
5066  const cs_real_3_t cofafv[],
5067  const cs_real_33_t cofbfv[],
5068  const cs_real_t i_massflux[],
5069  const cs_real_t b_massflux[],
5070  const cs_real_t i_visc[],
5071  const cs_real_t b_visc[],
5072  const cs_real_t secvif[],
5073  cs_real_3_t *restrict rhs);
5074 /*----------------------------------------------------------------------------*/
5119 /*----------------------------------------------------------------------------*/
5120 
5121 void
5123  int f_id,
5124  const cs_var_cal_opt_t var_cal_opt,
5125  int icvflb,
5126  int inc,
5127  int imasac,
5128  cs_real_6_t *restrict pvar,
5129  const cs_real_6_t *restrict pvara,
5130  const cs_real_6_t coefa[],
5131  const cs_real_66_t coefb[],
5132  const cs_real_6_t cofaf[],
5133  const cs_real_66_t cofbf[],
5134  const cs_real_t i_massflux[],
5135  const cs_real_t b_massflux[],
5136  const cs_real_t i_visc[],
5137  const cs_real_t b_visc[],
5138  cs_real_6_t *restrict rhs);
5139 
5140 /*----------------------------------------------------------------------------*/
5186 /*----------------------------------------------------------------------------*/
5187 
5188 void
5190  int f_id,
5191  const cs_var_cal_opt_t var_cal_opt,
5192  int inc,
5193  int iccocg,
5194  int imasac,
5195  cs_real_t *restrict pvar,
5196  const cs_real_t *restrict pvara,
5197  const cs_real_t coefap[],
5198  const cs_real_t coefbp[],
5199  const cs_real_t cofafp[],
5200  const cs_real_t cofbfp[],
5201  const cs_real_t i_massflux[],
5202  const cs_real_t b_massflux[],
5203  const cs_real_t i_visc[],
5204  const cs_real_t b_visc[],
5205  const cs_real_t xcpp[],
5206  cs_real_t *restrict rhs);
5207 
5208 /*----------------------------------------------------------------------------*/
5256 /*----------------------------------------------------------------------------*/
5257 
5258 void
5260  int f_id,
5261  const cs_var_cal_opt_t var_cal_opt,
5262  int inc,
5263  int iccocg,
5264  cs_real_t *restrict pvar,
5265  const cs_real_t *restrict pvara,
5266  const cs_real_t coefap[],
5267  const cs_real_t coefbp[],
5268  const cs_real_t cofafp[],
5269  const cs_real_t cofbfp[],
5270  const cs_real_t i_visc[],
5271  const cs_real_t b_visc[],
5272  cs_real_6_t *restrict viscel,
5273  const cs_real_2_t weighf[],
5274  const cs_real_t weighb[],
5275  cs_real_t *restrict rhs);
5276 
5277 /*-----------------------------------------------------------------------------*/
5320 /*----------------------------------------------------------------------------*/
5321 
5322 void
5324  int f_id,
5325  const cs_var_cal_opt_t var_cal_opt,
5326  int inc,
5327  int ivisep,
5328  cs_real_3_t *restrict pvar,
5329  const cs_real_3_t *restrict pvara,
5330  const cs_real_3_t coefav[],
5331  const cs_real_33_t coefbv[],
5332  const cs_real_3_t cofafv[],
5333  const cs_real_33_t cofbfv[],
5334  const cs_real_33_t i_visc[],
5335  const cs_real_t b_visc[],
5336  const cs_real_t secvif[],
5337  cs_real_3_t *restrict rhs);
5338 /*----------------------------------------------------------------------------*/
5382 /*----------------------------------------------------------------------------*/
5383 
5384 void
5386  int f_id,
5387  const cs_var_cal_opt_t var_cal_opt,
5388  int inc,
5389  cs_real_6_t *restrict pvar,
5390  const cs_real_6_t *restrict pvara,
5391  const cs_real_6_t coefa[],
5392  const cs_real_66_t coefb[],
5393  const cs_real_6_t cofaf[],
5394  const cs_real_66_t cofbf[],
5395  const cs_real_t i_visc[],
5396  const cs_real_t b_visc[],
5397  cs_real_6_t *restrict viscel,
5398  const cs_real_2_t weighf[],
5399  const cs_real_t weighb[],
5400  cs_real_6_t *restrict rhs);
5401 
5402 /*----------------------------------------------------------------------------*/
5461 /*----------------------------------------------------------------------------*/
5462 
5463 void
5464 cs_face_diffusion_potential(const int f_id,
5465  const cs_mesh_t *m,
5466  cs_mesh_quantities_t *fvq,
5467  int init,
5468  int inc,
5469  int imrgra,
5470  int iccocg,
5471  int nswrgp,
5472  int imligp,
5473  int iphydp,
5474  int iwarnp,
5475  double epsrgp,
5476  double climgp,
5477  double extrap,
5478  cs_real_3_t *restrict frcxt,
5479  cs_real_t *restrict pvar,
5480  const cs_real_t coefap[],
5481  const cs_real_t coefbp[],
5482  const cs_real_t cofafp[],
5483  const cs_real_t cofbfp[],
5484  const cs_real_t i_visc[],
5485  const cs_real_t b_visc[],
5486  cs_real_t *restrict viselx,
5487  const cs_real_t visely[],
5488  const cs_real_t viselz[],
5489  cs_real_t *restrict i_massflux,
5490  cs_real_t *restrict b_massflux);
5491 
5492 /*----------------------------------------------------------------------------*/
5560 /*----------------------------------------------------------------------------*/
5561 
5562 void
5564  const cs_mesh_t *m,
5565  cs_mesh_quantities_t *fvq,
5566  int init,
5567  int inc,
5568  int imrgra,
5569  int iccocg,
5570  int nswrgp,
5571  int imligp,
5572  int ircflp,
5573  int iphydp,
5574  int iwarnp,
5575  double epsrgp,
5576  double climgp,
5577  double extrap,
5578  cs_real_3_t *restrict frcxt,
5579  cs_real_t *restrict pvar,
5580  const cs_real_t coefap[],
5581  const cs_real_t coefbp[],
5582  const cs_real_t cofafp[],
5583  const cs_real_t cofbfp[],
5584  const cs_real_t i_visc[],
5585  const cs_real_t b_visc[],
5586  cs_real_6_t *restrict viscel,
5587  const cs_real_2_t weighf[],
5588  const cs_real_t weighb[],
5589  cs_real_t *restrict i_massflux,
5590  cs_real_t *restrict b_massflux);
5591 
5592 /*----------------------------------------------------------------------------*/
5650 /*----------------------------------------------------------------------------*/
5651 
5652 void
5653 cs_diffusion_potential(const int f_id,
5654  const cs_mesh_t *m,
5655  cs_mesh_quantities_t *fvq,
5656  int init,
5657  int inc,
5658  int imrgra,
5659  int iccocg,
5660  int nswrgp,
5661  int imligp,
5662  int iphydp,
5663  int iwarnp,
5664  double epsrgp,
5665  double climgp,
5666  double extrap,
5667  cs_real_3_t *restrict frcxt,
5668  cs_real_t *restrict pvar,
5669  const cs_real_t coefap[],
5670  const cs_real_t coefbp[],
5671  const cs_real_t cofafp[],
5672  const cs_real_t cofbfp[],
5673  const cs_real_t i_visc[],
5674  const cs_real_t b_visc[],
5675  const cs_real_t viselx[],
5676  const cs_real_t visely[],
5677  const cs_real_t viselz[],
5678  cs_real_t *restrict diverg);
5679 
5680 /*----------------------------------------------------------------------------*/
5749 /*----------------------------------------------------------------------------*/
5750 
5751 void
5752 cs_anisotropic_diffusion_potential(const int f_id,
5753  const cs_mesh_t *m,
5754  cs_mesh_quantities_t *fvq,
5755  int init,
5756  int inc,
5757  int imrgra,
5758  int iccocg,
5759  int nswrgp,
5760  int imligp,
5761  int ircflp,
5762  int iphydp,
5763  int iwarnp,
5764  double epsrgp,
5765  double climgp,
5766  double extrap,
5767  cs_real_3_t *restrict frcxt,
5768  cs_real_t *restrict pvar,
5769  const cs_real_t coefap[],
5770  const cs_real_t coefbp[],
5771  const cs_real_t cofafp[],
5772  const cs_real_t cofbfp[],
5773  const cs_real_t i_visc[],
5774  const cs_real_t b_visc[],
5775  cs_real_6_t *restrict viscel,
5776  const cs_real_2_t weighf[],
5777  const cs_real_t weighb[],
5778  cs_real_t *restrict diverg);
5779 
5780 /*----------------------------------------------------------------------------*/
5781 /* Delete local macro definitions */
5782 
5783 #undef _CS_DOT_PRODUCT
5784 
5785 /*----------------------------------------------------------------------------*/
5786 
5788 
5789 #endif /* __CS_CONVECTION_DIFFUSION_H__ */
static void cs_b_cd_steady(const int ircflp, 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.h:4451
static void cs_i_cd_unsteady_slope_test_tensor(bool upwind_switch[6], const int iconvp, const int ircflp, const int ischcp, const double blencp, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t i_face_surf, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_normal, const cs_real_3_t i_face_cog, const cs_real_3_t dijpf, const cs_real_t i_massflux, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_63_t grdpai, const cs_real_63_t grdpaj, const cs_real_6_t pi, const cs_real_6_t pj, cs_real_t pif[6], cs_real_t pjf[6], cs_real_t pip[6], cs_real_t pjp[6])
Handle preparation of internal face values for the fluxes computation in case of a unsteady algorithm...
Definition: cs_convection_diffusion.h:3738
static void cs_upwind_f_val_vector(const cs_real_3_t p, cs_real_t pf[3])
Prepare value at face ij by using an upwind scheme.
Definition: cs_convection_diffusion.h:695
double precision, dimension(:,:), pointer diipb
Definition: mesh.f90:216
#define restrict
Definition: cs_defs.h:122
static void cs_b_imposed_conv_flux_vector(int iconvp, cs_real_t thetap, int imasac, int inc, cs_int_t bc_type, int icvfli, const cs_real_t pi[restrict 3], const cs_real_t pir[restrict 3], const cs_real_t pipr[restrict 3], const cs_real_t coefap[restrict 3], const cs_real_t coefbp[restrict 3][3], const cs_real_t coface[restrict 3], const cs_real_t cofbce[restrict 3][3], cs_real_t b_massflux, cs_real_t flux[restrict 3])
Add convective flux (substracting the mass accumulation from it) to flux at boundary face...
Definition: cs_convection_diffusion.h:4120
static void cs_b_diff_flux_tensor(const int idiffp, const cs_real_t thetap, const int inc, const cs_real_6_t pipr, const cs_real_6_t cofaf, const cs_real_66_t cofbf, const cs_real_t b_visc, cs_real_t flux[6])
Add diffusive flux to flux at boundary face.
Definition: cs_convection_diffusion.h:4415
cs_real_t cs_real_2_t[2]
vector of 2 floating-point values
Definition: cs_defs.h:307
cs_real_t cs_real_6_t[6]
vector of 6 floating-point values
Definition: cs_defs.h:310
static void cs_i_cd_unsteady(const int ircflp, 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_3_t dijpf, 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.h:2215
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:7031
static void cs_centered_f_val_tensor(const double pnd, const cs_real_6_t pip, const cs_real_6_t pjp, cs_real_t pf[6])
Prepare value at face ij by using a centered scheme.
Definition: cs_convection_diffusion.h:800
static void cs_solu_f_val_limiter(const cs_real_3_t cell_cen, const cs_real_3_t i_face_cog, const cs_real_3_t grad, const cs_real_t phi, const cs_real_t p, cs_real_t *pf)
Prepare LIMITED value at face ij by using a Second Order Linear Upwind scheme.
Definition: cs_convection_diffusion.h:855
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:5936
integer, dimension(:), allocatable icvfli
Definition: cfpoin.f90:48
static void cs_b_cd_steady_vector(const int ircflp, const double relaxp, const cs_real_3_t diipb, const cs_real_33_t gradi, const cs_real_3_t pi, const cs_real_3_t pia, cs_real_t pir[3], cs_real_t pipr[3])
Handle preparation of boundary face values for the flux computation in case of a steady algorithm...
Definition: cs_convection_diffusion.h:4492
Definition: cs_convection_diffusion.h:47
#define CS_ABS(a)
Definition: cs_defs.h:411
static void cs_upwind_f_val_tensor(const cs_real_6_t p, cs_real_t pf[6])
Prepare value at face ij by using an upwind scheme.
Definition: cs_convection_diffusion.h:712
static void cs_b_cd_unsteady(const int ircflp, 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.h:4571
static void cs_i_cd_steady_upwind_vector(const int ircflp, const cs_real_t relaxp, 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_3_t dijpf, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_3_t pi, const cs_real_3_t pj, const cs_real_3_t pia, const cs_real_3_t pja, cs_real_t pifri[3], cs_real_t pifrj[3], cs_real_t pjfri[3], cs_real_t pjfrj[3], cs_real_t pip[3], cs_real_t pjp[3], cs_real_t pipr[3], cs_real_t pjpr[3])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:1357
cs_real_t cs_real_66_t[6][6]
6x6 matrix of floating-point values
Definition: cs_defs.h:315
static void cs_b_imposed_conv_flux(int iconvp, cs_real_t thetap, int imasac, int inc, cs_int_t 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.h:4050
double precision pi
value with 16 digits
Definition: cstnum.f90:48
#define BEGIN_C_DECLS
Definition: cs_defs.h:448
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
Definition: cs_field_pointer.h:78
static void cs_i_cd_steady_tensor(const int ircflp, const int ischcp, const double relaxp, 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_3_t dijpf, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_6_t pi, const cs_real_6_t pj, const cs_real_6_t pia, const cs_real_6_t pja, cs_real_t pifri[6], cs_real_t pifrj[6], cs_real_t pjfri[6], cs_real_t pjfrj[6], cs_real_t pip[6], cs_real_t pjp[6], cs_real_t pipr[6], cs_real_t pjpr[6])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:2062
static void cs_i_relax_c_val_tensor(const double relaxp, const cs_real_6_t pia, const cs_real_6_t pja, const cs_real_6_t recoi, const cs_real_6_t recoj, const cs_real_6_t pi, const cs_real_6_t pj, cs_real_t pir[6], cs_real_t pjr[6], cs_real_t pipr[6], cs_real_t pjpr[6])
Compute relaxed values at cell i and j.
Definition: cs_convection_diffusion.h:648
static 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.h:570
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 iwarnp, double epsrgp, double climgp, double extrap, 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 viselx, const cs_real_t visely[], const cs_real_t viselz[], 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:7608
static void cs_centered_f_val(const double pnd, const cs_real_t pip, const cs_real_t pjp, cs_real_t *pf)
Prepare value at face ij by using a centered scheme.
Definition: cs_convection_diffusion.h:731
integer(c_int), pointer, save idtvar
option for a variable time step
Definition: optcal.f90:431
static void cs_i_cd_steady_slope_test_vector(bool upwind_switch[3], const int iconvp, const int ircflp, const int ischcp, const double relaxp, const double blencp, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t i_face_surf, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_normal, const cs_real_3_t i_face_cog, const cs_real_3_t dijpf, const cs_real_t i_massflux, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_33_t grdpai, const cs_real_33_t grdpaj, const cs_real_3_t pi, const cs_real_3_t pj, const cs_real_3_t pia, const cs_real_3_t pja, cs_real_t pifri[3], cs_real_t pifrj[3], cs_real_t pjfri[3], cs_real_t pjfrj[3], cs_real_t pip[3], cs_real_t pjp[3], cs_real_t pipr[3], cs_real_t pjpr[3])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:2926
static void cs_i_cd_steady_vector(const int ircflp, const int ischcp, const double relaxp, 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_3_t dijpf, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_3_t pi, const cs_real_3_t pj, const cs_real_3_t pia, const cs_real_3_t pja, cs_real_t pifri[3], cs_real_t pifrj[3], cs_real_t pjfri[3], cs_real_t pjfrj[3], cs_real_t pip[3], cs_real_t pjp[3], cs_real_t pipr[3], cs_real_t pjpr[3])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:1908
Definition: cs_field_pointer.h:66
static void cs_b_compute_quantities_vector(const cs_real_3_t diipb, const cs_real_33_t gradi, const int ircflp, cs_real_t recoi[3])
Reconstruct values in I&#39; at boundary cell i.
Definition: cs_convection_diffusion.h:3908
static void cs_blend_f_val_vector(const double blencp, const cs_real_3_t p, cs_real_t pf[3])
Blend face values for a centered or SOLU scheme with face values for an upwind scheme.
Definition: cs_convection_diffusion.h:969
static void cs_i_conv_flux_lax_wendroff(const int iconvp, const cs_real_t thetap, const int imasac, const int limiter, const cs_real_t lambdaij, const cs_real_t rij, 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, cs_real_2_t fluxij)
Add convective fluxes using limiter function found in the Roe-Sweby theory for the Lax Wendroff schem...
Definition: cs_convection_diffusion.h:101
static void cs_i_compute_quantities_vector(const int ircflp, const double pnd, 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_3_t dijpf, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_3_t pi, const cs_real_3_t pj, cs_real_t recoi[3], cs_real_t recoj[3], cs_real_t pip[3], cs_real_t pjp[3])
Reconstruct values in I&#39; and J&#39;.
Definition: cs_convection_diffusion.h:418
double cs_real_t
Floating-point value.
Definition: cs_defs.h:296
static void cs_solu_f_val_tensor(const cs_real_3_t cell_cen, const cs_real_3_t i_face_cog, const cs_real_63_t grad, const cs_real_6_t p, cs_real_t pf[6])
Prepare value at face ij by using a Second Order Linear Upwind scheme.
Definition: cs_convection_diffusion.h:918
static void cs_centered_f_val_limiter(const double pnd, cs_real_t phi, const cs_real_t p, const cs_real_t pip, const cs_real_t pjp, cs_real_t *pf)
Prepare value at face ij by using a centered limited scheme. following the Roe-Sweby theory...
Definition: cs_convection_diffusion.h:757
static void cs_i_cd_unsteady_limiter(const int ircflp, const int ischcp, 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, cs_real_t phi_rij, const cs_real_3_t dijpf, 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 LIMITED unsteady a...
Definition: cs_convection_diffusion.h:2346
static void cs_slope_test_vector(const cs_real_3_t pi, const cs_real_3_t pj, const cs_real_t distf, const cs_real_t srfan, const cs_real_3_t i_face_normal, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_33_t grdpai, const cs_real_33_t grdpaj, const cs_real_t i_massflux, cs_real_t testij[3], cs_real_t tesqck[3])
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion.h:223
static void cs_solu_f_val_vector(const cs_real_3_t cell_cen, const cs_real_3_t i_face_cog, const cs_real_33_t grad, const cs_real_3_t p, cs_real_t pf[3])
Prepare value at face ij by using a Second Order Linear Upwind scheme.
Definition: cs_convection_diffusion.h:886
static void cs_b_upwind_flux_vector(const int iconvp, const cs_real_t thetap, const int imasac, const int inc, const int bc_type, const cs_real_3_t pi, const cs_real_3_t pir, const cs_real_3_t pipr, const cs_real_3_t coefa, const cs_real_33_t coefb, const cs_real_t b_massflux, cs_real_t flux[3])
Add convective flux (substracting the mass accumulation from it) to flux at boundary face...
Definition: cs_convection_diffusion.h:4248
Definition: cs_mesh.h:62
static 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_2_t fluxij)
Add diffusive fluxes to fluxes at face ij.
Definition: cs_convection_diffusion.h:1156
static void cs_i_cd_steady_slope_test(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double relaxp, const double blencp, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t i_face_surf, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_normal, const cs_real_3_t i_face_cog, const cs_real_3_t dijpf, 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, 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.h:2676
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 cs_int_t 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 secvif[], 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:2863
static void cs_i_compute_quantities_tensor(const int ircflp, const double pnd, 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_3_t dijpf, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_6_t pi, const cs_real_6_t pj, cs_real_t recoi[6], cs_real_t recoj[6], cs_real_t pip[6], cs_real_t pjp[6])
Reconstruct values in I&#39; and J&#39;.
Definition: cs_convection_diffusion.h:495
static void cs_b_diff_flux_vector(const int idiffp, const cs_real_t thetap, const int inc, const cs_real_3_t pipr, const cs_real_3_t cofaf, const cs_real_33_t cofbf, const cs_real_t b_visc, cs_real_t flux[3])
Add diffusive flux to flux at boundary face.
Definition: cs_convection_diffusion.h:4380
static void cs_i_relax_c_val_vector(const double relaxp, const cs_real_3_t pia, const cs_real_3_t pja, const cs_real_3_t recoi, const cs_real_3_t recoj, const cs_real_3_t pi, const cs_real_3_t pj, cs_real_t pir[3], cs_real_t pjr[3], cs_real_t pipr[3], cs_real_t pjpr[3])
Compute relaxed values at cell i and j.
Definition: cs_convection_diffusion.h:608
static void cs_i_diff_flux_tensor(const int idiffp, const cs_real_t thetap, const cs_real_6_t pip, const cs_real_6_t pjp, const cs_real_6_t pipr, const cs_real_6_t pjpr, const cs_real_t i_visc, cs_real_t fluxi[6], cs_real_t fluxj[6])
Add diffusive fluxes to fluxes at face ij.
Definition: cs_convection_diffusion.h:1219
Definition: cs_convection_diffusion.h:47
static void cs_b_relax_c_val_tensor(const double relaxp, const cs_real_6_t pi, const cs_real_6_t pia, const cs_real_6_t recoi, cs_real_t pir[6], cs_real_t pipr[6])
Compute relaxed values at boundary cell i.
Definition: cs_convection_diffusion.h:4010
static void cs_i_cd_unsteady_tensor(const int ircflp, 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_3_t dijpf, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_6_t pi, const cs_real_6_t pj, cs_real_t pif[6], cs_real_t pjf[6], cs_real_t pip[6], cs_real_t pjp[6])
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion.h:2554
static 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.h:3958
static void cs_i_cd_steady_upwind_tensor(const int ircflp, const cs_real_t relaxp, 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_3_t dijpf, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_6_t pi, const cs_real_6_t pj, const cs_real_6_t pia, const cs_real_6_t pja, cs_real_t pifri[6], cs_real_t pifrj[6], cs_real_t pjfri[6], cs_real_t pjfrj[6], cs_real_t pip[6], cs_real_t pjp[6], cs_real_t pipr[6], cs_real_t pjpr[6])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:1450
void cs_anisotropic_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 secvif[], cs_real_3_t *restrict rhs)
Add the explicit part of the diffusion terms with a symmetric tensorial diffusivity for a transport e...
Definition: cs_convection_diffusion.c:6504
cs_real_t cs_limiter_function(const int limiter, cs_real_t r)
Compute different types of "limiter function" according to the method proposed by Roe-Sweby (Second O...
Definition: cs_convection_diffusion.c:605
static void cs_solu_f_val(const cs_real_3_t cell_cen, const cs_real_3_t i_face_cog, const cs_real_3_t grad, 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.h:822
Definition: cs_mesh_quantities.h:51
cs_halo_type_t
Definition: cs_halo.h:49
Definition: cs_convection_diffusion.h:47
static 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.h:4198
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 iwarnp, double epsrgp, double climgp, double extrap, 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:8836
static void cs_slope_test(const cs_real_t pi, const cs_real_t pj, const cs_real_t distf, const cs_real_t srfan, const cs_real_3_t i_face_normal, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t grdpai, const cs_real_3_t grdpaj, const cs_real_t i_massflux, double *testij, double *tesqck)
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion.h:158
static void cs_b_compute_quantities_tensor(const cs_real_3_t diipb, const cs_real_63_t gradi, const int ircflp, cs_real_t recoi[6])
Reconstruct values in I&#39; at boundary cell i.
Definition: cs_convection_diffusion.h:3932
static void cs_i_cd_unsteady_upwind_vector(const int ircflp, 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_3_t dijpf, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_3_t pi, const cs_real_3_t pj, cs_real_t pif[3], cs_real_t pjf[3], cs_real_t pip[3], cs_real_t pjp[3])
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion.h:1594
static void cs_slope_test_tensor(const cs_real_6_t pi, const cs_real_6_t pj, const cs_real_t distf, const cs_real_t srfan, const cs_real_3_t i_face_normal, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_63_t grdpai, const cs_real_63_t grdpaj, const cs_real_t i_massflux, cs_real_t testij[6], cs_real_t tesqck[6])
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion.h:289
static 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.h:1022
static void cs_centered_f_val_vector(const double pnd, const cs_real_3_t pip, const cs_real_3_t pjp, cs_real_t pf[3])
Prepare value at face ij by using a centered scheme.
Definition: cs_convection_diffusion.h:779
static void cs_b_cd_unsteady_tensor(const int ircflp, const cs_real_3_t diipb, const cs_real_63_t gradi, const cs_real_6_t pi, cs_real_t pip[6])
Handle preparation of boundary face values for the flux computation in case of a steady algorithm...
Definition: cs_convection_diffusion.h:4632
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:308
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 iwarnp, double epsrgp, double climgp, double extrap, 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[], const cs_real_t viselx[], const cs_real_t visely[], const cs_real_t viselz[], 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:8432
static void cs_b_upwind_flux_tensor(const int iconvp, const cs_real_t thetap, const int imasac, const int inc, const int bc_type, const cs_real_6_t pi, const cs_real_6_t pir, const cs_real_6_t pipr, const cs_real_6_t coefa, const cs_real_66_t coefb, const cs_real_t b_massflux, cs_real_t flux[6])
Add convective flux (substracting the mass accumulation from it) to flux at boundary face...
Definition: cs_convection_diffusion.h:4302
void cs_slope_test_gradient(const int f_id, const int inc, const cs_halo_type_t halo_type, cs_real_3_t *grad, cs_real_3_t *grdpa, 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:949
static void cs_i_cd_unsteady_slope_test_vector(bool upwind_switch[3], const int iconvp, const int ircflp, const int ischcp, const double blencp, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t i_face_surf, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_normal, const cs_real_3_t i_face_cog, const cs_real_3_t dijpf, const cs_real_t i_massflux, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_33_t grdpai, const cs_real_33_t grdpaj, const cs_real_3_t pi, const cs_real_3_t pj, cs_real_t pif[3], cs_real_t pjf[3], cs_real_t pip[3], cs_real_t pjp[3])
Handle preparation of internal face values for the fluxes computation in case of a unsteady algorithm...
Definition: cs_convection_diffusion.h:3564
void itrmav(const cs_int_t *const f_id, const cs_int_t *const init, const cs_int_t *const inc, const cs_int_t *const imrgra, const cs_int_t *const iccocg, const cs_int_t *const nswrgp, const cs_int_t *const imligp, const cs_int_t *const ircflp, const cs_int_t *const iphydp, const cs_int_t *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:736
static void cs_i_conv_flux_vector(const int iconvp, const cs_real_t thetap, const int imasac, const cs_real_3_t pi, const cs_real_3_t pj, const cs_real_3_t pifri, const cs_real_3_t pifrj, const cs_real_3_t pjfri, const cs_real_3_t pjfrj, const cs_real_t i_massflux, cs_real_t fluxi[3], cs_real_t fluxj[3])
Add convective fluxes (substracting the mass accumulation from them) to fluxes at face ij...
Definition: cs_convection_diffusion.h:1066
static void cs_i_conv_flux_tensor(const int iconvp, const cs_real_t thetap, const int imasac, const cs_real_6_t pi, const cs_real_6_t pj, const cs_real_6_t pifri, const cs_real_6_t pifrj, const cs_real_6_t pjfri, const cs_real_6_t pjfrj, const cs_real_t i_massflux, cs_real_t fluxi[6], cs_real_t fluxj[6])
Add convective fluxes (substracting the mass accumulation from them) to fluxes at face ij...
Definition: cs_convection_diffusion.h:1114
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:3986
Definition: cs_parameters.h:69
static void cs_b_compute_quantities(const cs_real_3_t diipb, const cs_real_3_t gradi, const int ircflp, cs_real_t *recoi)
Reconstruct values in I&#39; at boundary cell i.
Definition: cs_convection_diffusion.h:3886
static void cs_i_diff_flux_vector(const int idiffp, const cs_real_t thetap, const cs_real_3_t pip, const cs_real_3_t pjp, const cs_real_3_t pipr, const cs_real_3_t pjpr, const cs_real_t i_visc, cs_real_t fluxi[3], cs_real_t fluxj[3])
Add diffusive fluxes to fluxes at face ij.
Definition: cs_convection_diffusion.h:1186
static void cs_i_cd_steady(const int ircflp, const int ischcp, const double relaxp, 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_3_t dijpf, 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, 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.h:1726
void itrgrv(const cs_int_t *const f_id, const cs_int_t *const init, const cs_int_t *const inc, const cs_int_t *const imrgra, const cs_int_t *const iccocg, const cs_int_t *const nswrgp, const cs_int_t *const imligp, const cs_int_t *const ircflp, const cs_int_t *const iphydp, const cs_int_t *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:866
#define END_C_DECLS
Definition: cs_defs.h:449
static void cs_i_cd_steady_upwind(const int ircflp, const cs_real_t relaxp, 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_3_t dijpf, const cs_real_3_t gradi, const cs_real_3_t gradj, 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.h:1265
Definition: cs_field_pointer.h:80
static void cs_i_compute_quantities(const int ircflp, const double pnd, 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_3_t dijpf, 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&#39; and J&#39;.
Definition: cs_convection_diffusion.h:357
#define _CS_DOT_PRODUCT(vect1, vect2)
Definition: cs_convection_diffusion.h:48
void cs_slope_test_gradient_tensor(const int inc, const cs_halo_type_t halo_type, cs_real_63_t *grad, cs_real_63_t *grdpa, 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:1379
#define CS_PROCF(x, y)
Definition: cs_defs.h:472
Definition: cs_parameters.h:147
static void cs_i_cd_unsteady_vector(const int ircflp, 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_3_t dijpf, const cs_real_33_t gradi, const cs_real_33_t gradj, const cs_real_3_t pi, const cs_real_3_t pj, cs_real_t pif[3], cs_real_t pjf[3], cs_real_t pip[3], cs_real_t pjp[3])
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion.h:2450
static void cs_i_cd_unsteady_upwind_tensor(const int ircflp, 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_3_t dijpf, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_6_t pi, const cs_real_6_t pj, cs_real_t pif[6], cs_real_t pjf[6], cs_real_t pip[6], cs_real_t pjp[6])
Handle preparation of internal face values for the fluxes computation in case of an unsteady algorith...
Definition: cs_convection_diffusion.h:1654
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 iwarnp, double epsrgp, double climgp, double extrap, 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:7971
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:314
static void cs_i_cd_unsteady_slope_test(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double blencp, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t i_face_surf, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_normal, const cs_real_3_t i_face_cog, const cs_real_3_t dijpf, 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.h:3382
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 cs_int_t 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:1670
static void cs_blend_f_val_tensor(const double blencp, const cs_real_6_t p, cs_real_t pf[6])
Blend face values for a centered or SOLU scheme with face values for an upwind scheme.
Definition: cs_convection_diffusion.h:990
cs_real_t cs_real_63_t[6][3]
Definition: cs_defs.h:319
static void cs_b_cd_unsteady_vector(const int ircflp, const cs_real_3_t diipb, const cs_real_33_t gradi, const cs_real_3_t pi, cs_real_t pip[3])
Handle preparation of boundary face values for the flux computation in case of a steady algorithm...
Definition: cs_convection_diffusion.h:4601
void itrmas(const cs_int_t *const f_id, const cs_int_t *const init, const cs_int_t *const inc, const cs_int_t *const imrgra, const cs_int_t *const iccocg, const cs_int_t *const nswrgp, const cs_int_t *const imligp, const cs_int_t *const iphydp, const cs_int_t *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 viselx[], const cs_real_t visely[], const cs_real_t viselz[], cs_real_t i_massflux[], cs_real_t b_massflux[])
Definition: cs_convection_diffusion.c:671
void cs_slope_test_gradient_vector(const int inc, const cs_halo_type_t halo_type, cs_real_33_t *grad, cs_real_33_t *grdpa, 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:1227
static void cs_i_cd_unsteady_upwind(const int ircflp, 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_3_t dijpf, 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 *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.h:1535
double precision, dimension(:,:), pointer dijpf
Definition: mesh.f90:208
static void cs_b_cd_steady_tensor(const int ircflp, const double relaxp, const cs_real_3_t diipb, const cs_real_63_t gradi, const cs_real_6_t pi, const cs_real_6_t pia, cs_real_t pir[6], cs_real_t pipr[6])
Handle preparation of boundary face values for the flux computation in case of a steady algorithm...
Definition: cs_convection_diffusion.h:4533
void cs_max_limiter_building(int f_id, int inc, const cs_real_t rovsdt[])
Compute a coefficient for blending that ensures the positivity of the scalar.
Definition: cs_convection_diffusion.c:1525
static void cs_i_cd_steady_slope_test_tensor(bool upwind_switch[6], const int iconvp, const int ircflp, const int ischcp, const double relaxp, const double blencp, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t i_face_surf, const cs_real_3_t cell_ceni, const cs_real_3_t cell_cenj, const cs_real_3_t i_face_normal, const cs_real_3_t i_face_cog, const cs_real_3_t dijpf, const cs_real_t i_massflux, const cs_real_63_t gradi, const cs_real_63_t gradj, const cs_real_63_t grdpai, const cs_real_63_t grdpaj, const cs_real_6_t pi, const cs_real_6_t pj, const cs_real_6_t pia, const cs_real_6_t pja, cs_real_t pifri[6], cs_real_t pifrj[6], cs_real_t pjfri[6], cs_real_t pjfrj[6], cs_real_t pip[6], cs_real_t pjp[6], cs_real_t pipr[6], cs_real_t pjpr[6])
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:3156
static 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.h:679
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:4880
static 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.h:4351
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:1098
void itrgrp(const cs_int_t *const f_id, const cs_int_t *const init, const cs_int_t *const inc, const cs_int_t *const imrgra, const cs_int_t *const iccocg, const cs_int_t *const nswrgp, const cs_int_t *const imligp, const cs_int_t *const iphydp, const cs_int_t *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[], const cs_real_t viselx[], const cs_real_t visely[], const cs_real_t viselz[], cs_real_t diverg[])
Definition: cs_convection_diffusion.c:803
integer(c_int), pointer, save imrgra
type of gradient reconstruction
Definition: optcal.f90:270
static void cs_b_relax_c_val_vector(const double relaxp, const cs_real_3_t pi, const cs_real_3_t pia, const cs_real_3_t recoi, cs_real_t pir[3], cs_real_t pipr[3])
Compute relaxed values at boundary cell i.
Definition: cs_convection_diffusion.h:3983
static 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.h:949