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-2018 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 #include "cs_math.h"
39 #include "cs_mesh_quantities.h"
40 #include "cs_parameters.h"
41 
42 /*----------------------------------------------------------------------------*/
43 
44 BEGIN_C_DECLS
45 
46 /*=============================================================================
47  * Macro definitions
48  *============================================================================*/
49 
56 /*
57  * Field property type
58  */
59 
61 #define CS_ISOTROPIC_DIFFUSION (1 << 0)
62 
64 #define CS_ORTHOTROPIC_DIFFUSION (1 << 1)
65 
67 #define CS_ANISOTROPIC_LEFT_DIFFUSION (1 << 2)
68 
70 #define CS_ANISOTROPIC_RIGHT_DIFFUSION (1 << 3)
71 
73 #define CS_ANISOTROPIC_DIFFUSION ((1 << 2) + (1 << 3))
74 
77 /*============================================================================
78  * Type definition
79  *============================================================================*/
80 
81 /*----------------------------------------------------------------------------
82  * NVD/TVD Advection Scheme
83  *----------------------------------------------------------------------------*/
84 
85 typedef enum {
86 
87  CS_NVD_GAMMA = 0, /* GAMMA */
88  CS_NVD_SMART = 1, /* SMART */
89  CS_NVD_CUBISTA = 2, /* CUBISTA */
90  CS_NVD_SUPERBEE = 3, /* SUPERBEE */
91  CS_NVD_MUSCL = 4, /* MUSCL */
92  CS_NVD_MINMOD = 5, /* MINMOD */
93  CS_NVD_CLAM = 6, /* CLAM */
94  CS_NVD_STOIC = 7, /* STOIC */
95  CS_NVD_OSHER = 8, /* OSHER */
96  CS_NVD_WASEB = 9, /* WASEB */
97  CS_NVD_VOF_HRIC = 10, /* M-HRIC for VOF */
98  CS_NVD_VOF_CICSAM = 11, /* M-CICSAM for VOF */
99  CS_NVD_VOF_STACS = 12, /* STACS for VOF */
100  CS_NVD_N_TYPES = 13 /* number of NVD schemes */
101 
102 } cs_nvd_type_t;
103 
104 /*============================================================================
105  * Global variables
106  *============================================================================*/
107 
108 /*============================================================================
109  * Private function definitions
110  *============================================================================*/
111 
112 /*----------------------------------------------------------------------------*/
129 /*----------------------------------------------------------------------------*/
130 
131 inline static void
132 cs_slope_test(const cs_real_t pi,
133  const cs_real_t pj,
134  const cs_real_t distf,
135  const cs_real_t srfan,
136  const cs_real_3_t i_face_normal,
137  const cs_real_3_t gradi,
138  const cs_real_3_t gradj,
139  const cs_real_3_t grdpai,
140  const cs_real_3_t grdpaj,
141  const cs_real_t i_massflux,
142  double *testij,
143  double *tesqck)
144 {
145  double testi, testj;
146  double dcc, ddi, ddj;
147 
148  /* Slope test
149  ----------*/
150 
151  testi = grdpai[0]*i_face_normal[0]
152  + grdpai[1]*i_face_normal[1]
153  + grdpai[2]*i_face_normal[2];
154  testj = grdpaj[0]*i_face_normal[0]
155  + grdpaj[1]*i_face_normal[1]
156  + grdpaj[2]*i_face_normal[2];
157  *testij = grdpai[0]*grdpaj[0]
158  + grdpai[1]*grdpaj[1]
159  + grdpai[2]*grdpaj[2];
160 
161  if (i_massflux>0.) {
162  dcc = gradi[0]*i_face_normal[0]
163  + gradi[1]*i_face_normal[1]
164  + gradi[2]*i_face_normal[2];
165  ddi = testi;
166  ddj = (pj-pi)/distf *srfan;
167  } else {
168  dcc = gradj[0]*i_face_normal[0]
169  + gradj[1]*i_face_normal[1]
170  + gradj[2]*i_face_normal[2];
171  ddi = (pj-pi)/distf *srfan;
172  ddj = testj;
173  }
174  *tesqck = cs_math_sq(dcc) - cs_math_sq(ddi-ddj);
175 }
176 
177 /*----------------------------------------------------------------------------*/
194 /*----------------------------------------------------------------------------*/
195 
196 inline static void
197 cs_slope_test_vector(const cs_real_3_t pi,
198  const cs_real_3_t pj,
199  const cs_real_t distf,
200  const cs_real_t srfan,
201  const cs_real_3_t i_face_normal,
202  const cs_real_33_t gradi,
203  const cs_real_33_t gradj,
204  const cs_real_33_t gradsti,
205  const cs_real_33_t gradstj,
206  const cs_real_t i_massflux,
207  cs_real_t *testij,
208  cs_real_t *tesqck)
209 {
210  double testi[3], testj[3];
211  double dcc[3], ddi[3], ddj[3];
212  *testij = 0.;
213  *tesqck = 0.;
214 
215  /* Slope test
216  ----------*/
217  for (int i = 0; i < 3; i++) {
218  *testij += gradsti[i][0]*gradstj[i][0]
219  + gradsti[i][1]*gradstj[i][1]
220  + gradsti[i][2]*gradstj[i][2];
221 
222  testi[i] = gradsti[i][0]*i_face_normal[0]
223  + gradsti[i][1]*i_face_normal[1]
224  + gradsti[i][2]*i_face_normal[2];
225  testj[i] = gradstj[i][0]*i_face_normal[0]
226  + gradstj[i][1]*i_face_normal[1]
227  + gradstj[i][2]*i_face_normal[2];
228 
229  if (i_massflux > 0.) {
230  dcc[i] = gradi[i][0]*i_face_normal[0]
231  + gradi[i][1]*i_face_normal[1]
232  + gradi[i][2]*i_face_normal[2];
233  ddi[i] = testi[i];
234  ddj[i] = (pj[i]-pi[i])/distf *srfan;
235  } else {
236  dcc[i] = gradj[i][0]*i_face_normal[0]
237  + gradj[i][1]*i_face_normal[1]
238  + gradj[i][2]*i_face_normal[2];
239  ddi[i] = (pj[i]-pi[i])/distf *srfan;
240  ddj[i] = testj[i];
241  }
242  }
243 
244  *tesqck = cs_math_3_square_norm(dcc) - cs_math_3_square_distance(ddi, ddj);
245 
246 }
247 
248 /*----------------------------------------------------------------------------*/
266 /*----------------------------------------------------------------------------*/
267 
268 inline static void
269 cs_slope_test_vector_old(const cs_real_3_t pi,
270  const cs_real_3_t pj,
271  const cs_real_t distf,
272  const cs_real_t srfan,
273  const cs_real_3_t i_face_normal,
274  const cs_real_33_t gradi,
275  const cs_real_33_t gradj,
276  const cs_real_33_t grdpai,
277  const cs_real_33_t grdpaj,
278  const cs_real_t i_massflux,
279  cs_real_t testij[3],
280  cs_real_t tesqck[3])
281 {
282  double testi[3], testj[3];
283  double dcc[3], ddi[3], ddj[3];
284 
285  /* Slope test
286  ----------*/
287  for (int isou = 0; isou < 3; isou++) {
288  testi[isou] = grdpai[isou][0]*i_face_normal[0]
289  + grdpai[isou][1]*i_face_normal[1]
290  + grdpai[isou][2]*i_face_normal[2];
291  testj[isou] = grdpaj[isou][0]*i_face_normal[0]
292  + grdpaj[isou][1]*i_face_normal[1]
293  + grdpaj[isou][2]*i_face_normal[2];
294  testij[isou] = grdpai[isou][0]*grdpaj[isou][0]
295  + grdpai[isou][1]*grdpaj[isou][1]
296  + grdpai[isou][2]*grdpaj[isou][2];
297 
298  if (i_massflux>0.) {
299  dcc[isou] = gradi[isou][0]*i_face_normal[0]
300  + gradi[isou][1]*i_face_normal[1]
301  + gradi[isou][2]*i_face_normal[2];
302  ddi[isou] = testi[isou];
303  ddj[isou] = (pj[isou]-pi[isou])/distf *srfan;
304  } else {
305  dcc[isou] = gradj[isou][0]*i_face_normal[0]
306  + gradj[isou][1]*i_face_normal[1]
307  + gradj[isou][2]*i_face_normal[2];
308  ddi[isou] = (pj[isou]-pi[isou])/distf *srfan;
309  ddj[isou] = testj[isou];
310  }
311  tesqck[isou] = cs_math_sq(dcc[isou]) - cs_math_sq(ddi[isou]-ddj[isou]);
312  }
313 }
314 
315 
316 /*----------------------------------------------------------------------------*/
333 /*----------------------------------------------------------------------------*/
334 
335 inline static void
336 cs_slope_test_tensor(const cs_real_6_t pi,
337  const cs_real_6_t pj,
338  const cs_real_t distf,
339  const cs_real_t srfan,
340  const cs_real_3_t i_face_normal,
341  const cs_real_63_t gradi,
342  const cs_real_63_t gradj,
343  const cs_real_63_t gradsti,
344  const cs_real_63_t gradstj,
345  const cs_real_t i_massflux,
346  cs_real_t *testij,
347  cs_real_t *tesqck)
348 {
349  double testi[6], testj[6];
350  double dcc[6], ddi[6], ddj[6];
351  *testij = 0.;
352  *tesqck = 0.;
353 
354  /* Slope test */
355 
356  for (int ij = 0; ij < 6; ij++) {
357  *testij += gradsti[ij][0]*gradstj[ij][0]
358  + gradsti[ij][1]*gradstj[ij][1]
359  + gradsti[ij][2]*gradstj[ij][2];
360  testi[ij] = gradsti[ij][0]*i_face_normal[0]
361  + gradsti[ij][1]*i_face_normal[1]
362  + gradsti[ij][2]*i_face_normal[2];
363  testj[ij] = gradstj[ij][0]*i_face_normal[0]
364  + gradstj[ij][1]*i_face_normal[1]
365  + gradstj[ij][2]*i_face_normal[2];
366 
367  if (i_massflux > 0.) {
368  dcc[ij] = gradi[ij][0]*i_face_normal[0]
369  + gradi[ij][1]*i_face_normal[1]
370  + gradi[ij][2]*i_face_normal[2];
371  ddi[ij] = testi[ij];
372  ddj[ij] = (pj[ij]-pi[ij])/distf *srfan;
373  } else {
374  dcc[ij] = gradj[ij][0]*i_face_normal[0]
375  + gradj[ij][1]*i_face_normal[1]
376  + gradj[ij][2]*i_face_normal[2];
377  ddi[ij] = (pj[ij]-pi[ij])/distf *srfan;
378  ddj[ij] = testj[ij];
379  }
380 
381  *tesqck += cs_math_sq(dcc[ij]) - cs_math_sq(ddi[ij]-ddj[ij]);
382  }
383 }
384 
385 /*----------------------------------------------------------------------------*/
401 /*----------------------------------------------------------------------------*/
402 
403 inline static void
404 cs_i_compute_quantities(const int ircflp,
405  const cs_real_3_t diipf,
406  const cs_real_3_t djjpf,
407  const cs_real_3_t gradi,
408  const cs_real_3_t gradj,
409  const cs_real_t pi,
410  const cs_real_t pj,
411  cs_real_t *recoi,
412  cs_real_t *recoj,
413  cs_real_t *pip,
414  cs_real_t *pjp)
415 {
416  cs_real_t gradpf[3] = {
417  0.5*(gradi[0] + gradj[0]),
418  0.5*(gradi[1] + gradj[1]),
419  0.5*(gradi[2] + gradj[2])};
420 
421  /* reconstruction only if IRCFLP = 1 */
422  *recoi = ircflp*(cs_math_3_dot_product(gradpf, diipf));
423  *recoj = ircflp*(cs_math_3_dot_product(gradpf, djjpf));
424  *pip = pi + *recoi;
425  *pjp = pj + *recoj;
426 }
427 
428 /*----------------------------------------------------------------------------*/
444 /*----------------------------------------------------------------------------*/
445 
446 inline static void
447 cs_i_compute_quantities_vector(const int ircflp,
448  const cs_real_3_t diipf,
449  const cs_real_3_t djjpf,
450  const cs_real_33_t gradi,
451  const cs_real_33_t gradj,
452  const cs_real_3_t pi,
453  const cs_real_3_t pj,
454  cs_real_t recoi[3],
455  cs_real_t recoj[3],
456  cs_real_t pip[3],
457  cs_real_t pjp[3])
458 {
459  cs_real_3_t dpvf;
460 
461  /* x-y-z components, p = u, v, w */
462 
463  for (int isou = 0; isou < 3; isou++) {
464 
465  for (int jsou = 0; jsou < 3; jsou++)
466  dpvf[jsou] = 0.5*( gradi[isou][jsou]
467  + gradj[isou][jsou]);
468 
469  /* reconstruction only if IRCFLP = 1 */
470 
471  recoi[isou] = ircflp*(cs_math_3_dot_product(dpvf, diipf));
472 
473 
474  recoj[isou] = ircflp*(cs_math_3_dot_product(dpvf, djjpf));
475 
476  pip[isou] = pi[isou] + recoi[isou];
477 
478  pjp[isou] = pj[isou] + recoj[isou];
479 
480  }
481 }
482 
483 /*----------------------------------------------------------------------------*/
499 /*----------------------------------------------------------------------------*/
500 
501 inline static void
502 cs_i_compute_quantities_tensor(const int ircflp,
503  const cs_real_3_t diipf,
504  const cs_real_3_t djjpf,
505  const cs_real_63_t gradi,
506  const cs_real_63_t gradj,
507  const cs_real_6_t pi,
508  const cs_real_6_t pj,
509  cs_real_t recoi[6],
510  cs_real_t recoj[6],
511  cs_real_t pip[6],
512  cs_real_t pjp[6])
513 {
514  cs_real_3_t dpvf;
515 
516  /* x-y-z components, p = u, v, w */
517 
518  for (int isou = 0; isou < 6; isou++) {
519 
520  for (int jsou = 0; jsou < 3; jsou++)
521  dpvf[jsou] = 0.5*( gradi[isou][jsou]
522  + gradj[isou][jsou]);
523 
524  /* reconstruction only if IRCFLP = 1 */
525 
526  recoi[isou] = ircflp*(cs_math_3_dot_product(dpvf, diipf));
527 
528  recoj[isou] = ircflp*(cs_math_3_dot_product(dpvf, djjpf));
529 
530  pip[isou] = pi[isou] + recoi[isou];
531 
532  pjp[isou] = pj[isou] + recoj[isou];
533 
534  }
535 }
536 
537 /*----------------------------------------------------------------------------*/
553 /*----------------------------------------------------------------------------*/
554 
555 inline static void
556 cs_i_relax_c_val(const double relaxp,
557  const cs_real_t pia,
558  const cs_real_t pja,
559  const cs_real_t recoi,
560  const cs_real_t recoj,
561  const cs_real_t pi,
562  const cs_real_t pj,
563  cs_real_t *pir,
564  cs_real_t *pjr,
565  cs_real_t *pipr,
566  cs_real_t *pjpr)
567 {
568  *pir = pi/relaxp - (1.-relaxp)/relaxp * pia;
569  *pjr = pj/relaxp - (1.-relaxp)/relaxp * pja;
570 
571  *pipr = *pir + recoi;
572  *pjpr = *pjr + recoj;
573 }
574 
575 /*----------------------------------------------------------------------------*/
591 /*----------------------------------------------------------------------------*/
592 
593 inline static void
594 cs_i_relax_c_val_vector(const double relaxp,
595  const cs_real_3_t pia,
596  const cs_real_3_t pja,
597  const cs_real_3_t recoi,
598  const cs_real_3_t recoj,
599  const cs_real_3_t pi,
600  const cs_real_3_t pj,
601  cs_real_t pir[3],
602  cs_real_t pjr[3],
603  cs_real_t pipr[3],
604  cs_real_t pjpr[3])
605 {
606  for (int isou = 0; isou < 3; isou++) {
607  pir[isou] = pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
608  pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
609 
610  pipr[isou] = pir[isou] + recoi[isou];
611  pjpr[isou] = pjr[isou] + recoj[isou];
612  }
613 }
614 
615 /*----------------------------------------------------------------------------*/
631 /*----------------------------------------------------------------------------*/
632 
633 inline static void
634 cs_i_relax_c_val_tensor(const double relaxp,
635  const cs_real_6_t pia,
636  const cs_real_6_t pja,
637  const cs_real_6_t recoi,
638  const cs_real_6_t recoj,
639  const cs_real_6_t pi,
640  const cs_real_6_t pj,
641  cs_real_t pir[6],
642  cs_real_t pjr[6],
643  cs_real_t pipr[6],
644  cs_real_t pjpr[6])
645 {
646  for (int isou = 0; isou < 6; isou++) {
647  pir[isou] = pi[isou] /relaxp - (1.-relaxp)/relaxp * pia[isou];
648  pjr[isou] = pj[isou] /relaxp - (1.-relaxp)/relaxp * pja[isou];
649 
650  pipr[isou] = pir[isou] + recoi[isou];
651  pjpr[isou] = pjr[isou] + recoj[isou];
652  }
653 }
654 
655 /*----------------------------------------------------------------------------*/
662 /*----------------------------------------------------------------------------*/
663 
664 inline static void
665 cs_upwind_f_val(const cs_real_t p,
666  cs_real_t *pf)
667 {
668  *pf = p;
669 }
670 
671 /*----------------------------------------------------------------------------*/
678 /*----------------------------------------------------------------------------*/
679 
680 inline static void
681 cs_upwind_f_val_vector(const cs_real_3_t p,
682  cs_real_t pf[3])
683 {
684  for (int isou = 0; isou < 3; isou++)
685  pf[isou] = p[isou];
686 }
687 
688 /*----------------------------------------------------------------------------*/
695 /*----------------------------------------------------------------------------*/
696 
697 inline static void
698 cs_upwind_f_val_tensor(const cs_real_6_t p,
699  cs_real_t pf[6])
700 {
701  for (int isou = 0; isou < 6; isou++)
702  pf[isou] = p[isou];
703 }
704 
705 /*----------------------------------------------------------------------------*/
714 /*----------------------------------------------------------------------------*/
715 
716 inline static void
717 cs_centered_f_val(const double pnd,
718  const cs_real_t pip,
719  const cs_real_t pjp,
720  cs_real_t *pf)
721 {
722  *pf = pnd*pip + (1.-pnd)*pjp;
723 }
724 
725 /*----------------------------------------------------------------------------*/
734 /*----------------------------------------------------------------------------*/
735 
736 inline static void
737 cs_centered_f_val_vector(const double pnd,
738  const cs_real_3_t pip,
739  const cs_real_3_t pjp,
740  cs_real_t pf[3])
741 {
742  for (int isou = 0; isou < 3; isou++)
743  pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
744 }
745 
746 /*----------------------------------------------------------------------------*/
755 /*----------------------------------------------------------------------------*/
756 
757 inline static void
758 cs_centered_f_val_tensor(const double pnd,
759  const cs_real_6_t pip,
760  const cs_real_6_t pjp,
761  cs_real_t pf[6])
762 {
763  for (int isou = 0; isou < 6; isou++)
764  pf[isou] = pnd*pip[isou] + (1.-pnd)*pjp[isou];
765 }
766 
767 /*----------------------------------------------------------------------------*/
777 /*----------------------------------------------------------------------------*/
778 
779 inline static void
780 cs_solu_f_val(const cs_real_3_t cell_cen,
781  const cs_real_3_t i_face_cog,
782  const cs_real_3_t grad,
783  const cs_real_t p,
784  cs_real_t *pf)
785 {
786  cs_real_3_t df;
787 
788  df[0] = i_face_cog[0] - cell_cen[0];
789  df[1] = i_face_cog[1] - cell_cen[1];
790  df[2] = i_face_cog[2] - cell_cen[2];
791 
792  *pf = p + cs_math_3_dot_product(df, grad);
793 }
794 
795 /*----------------------------------------------------------------------------*/
805 /*----------------------------------------------------------------------------*/
806 
807 inline static void
808 cs_solu_f_val_vector(const cs_real_3_t cell_cen,
809  const cs_real_3_t i_face_cog,
810  const cs_real_33_t grad,
811  const cs_real_3_t p,
812  cs_real_t pf[3])
813 {
814  cs_real_3_t df;
815 
816  for (int jsou = 0; jsou < 3; jsou++)
817  df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
818 
819  for (int isou = 0; isou < 3; isou++) {
820  pf[isou] = p[isou] + df[0]*grad[isou][0]
821  + df[1]*grad[isou][1]
822  + df[2]*grad[isou][2];
823 
824  }
825 }
826 
827 /*----------------------------------------------------------------------------*/
837 /*----------------------------------------------------------------------------*/
838 
839 inline static void
840 cs_solu_f_val_tensor(const cs_real_3_t cell_cen,
841  const cs_real_3_t i_face_cog,
842  const cs_real_63_t grad,
843  const cs_real_6_t p,
844  cs_real_t pf[6])
845 {
846  cs_real_3_t df;
847 
848  for (int jsou = 0; jsou < 3; jsou++)
849  df[jsou] = i_face_cog[jsou] - cell_cen[jsou];
850 
851  for (int isou = 0; isou < 6; isou++) {
852  pf[isou] = p[isou] + df[0]*grad[isou][0]
853  + df[1]*grad[isou][1]
854  + df[2]*grad[isou][2];
855  }
856 }
857 
858 /*----------------------------------------------------------------------------*/
868 /*----------------------------------------------------------------------------*/
869 
870 inline static void
871 cs_blend_f_val(const double blencp,
872  const cs_real_t p,
873  cs_real_t *pf)
874 {
875  *pf = blencp * (*pf) + (1. - blencp) * p;
876 }
877 
878 /*----------------------------------------------------------------------------*/
888 /*----------------------------------------------------------------------------*/
889 
890 inline static void
891 cs_blend_f_val_vector(const double blencp,
892  const cs_real_3_t p,
893  cs_real_t pf[3])
894 {
895  for (int isou = 0; isou < 3; isou++)
896  pf[isou] = blencp*(pf[isou])+(1.-blencp)*p[isou];
897 }
898 
899 /*----------------------------------------------------------------------------*/
909 /*----------------------------------------------------------------------------*/
910 
911 inline static void
912 cs_blend_f_val_tensor(const double blencp,
913  const cs_real_6_t p,
914  cs_real_t pf[6])
915 {
916  for (int isou = 0; isou < 6; isou++)
917  pf[isou] = blencp*(pf[isou])+(1.-blencp)*p[isou];
918 }
919 
920 /*----------------------------------------------------------------------------*/
941 /*----------------------------------------------------------------------------*/
942 
943 inline static void
944 cs_i_conv_flux(const int iconvp,
945  const cs_real_t thetap,
946  const int imasac,
947  const cs_real_t pi,
948  const cs_real_t pj,
949  const cs_real_t pifri,
950  const cs_real_t pifrj,
951  const cs_real_t pjfri,
952  const cs_real_t pjfrj,
953  const cs_real_t i_massflux,
954  const cs_real_t xcppi,
955  const cs_real_t xcppj,
956  cs_real_2_t fluxij)
957 {
958  cs_real_t flui, fluj;
959 
960  flui = 0.5*(i_massflux + fabs(i_massflux));
961  fluj = 0.5*(i_massflux - fabs(i_massflux));
962 
963  fluxij[0] += iconvp*xcppi*(thetap*(flui*pifri + fluj*pjfri) - imasac*i_massflux*pi);
964  fluxij[1] += iconvp*xcppj*(thetap*(flui*pifrj + fluj*pjfrj) - imasac*i_massflux*pj);
965 }
966 
967 /*----------------------------------------------------------------------------*/
985 /*----------------------------------------------------------------------------*/
986 
987 inline static void
988 cs_i_conv_flux_vector(const int iconvp,
989  const cs_real_t thetap,
990  const int imasac,
991  const cs_real_3_t pi,
992  const cs_real_3_t pj,
993  const cs_real_3_t pifri,
994  const cs_real_3_t pifrj,
995  const cs_real_3_t pjfri,
996  const cs_real_3_t pjfrj,
997  const cs_real_t i_massflux,
998  cs_real_t fluxi[3],
999  cs_real_t fluxj[3])
1000 {
1001  cs_real_t flui, fluj;
1002 
1003  flui = 0.5*(i_massflux + fabs(i_massflux));
1004  fluj = 0.5*(i_massflux - fabs(i_massflux));
1005 
1006  for (int isou = 0; isou < 3; isou++) {
1007 
1008  fluxi[isou] += iconvp*( thetap*(flui*pifri[isou] + fluj*pjfri[isou])
1009  - imasac*i_massflux*pi[isou]);
1010  fluxj[isou] += iconvp*( thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
1011  - imasac*i_massflux*pj[isou]);
1012  }
1013 }
1014 
1015 /*----------------------------------------------------------------------------*/
1033 /*----------------------------------------------------------------------------*/
1034 
1035 inline static void
1036 cs_i_conv_flux_tensor(const int iconvp,
1037  const cs_real_t thetap,
1038  const int imasac,
1039  const cs_real_6_t pi,
1040  const cs_real_6_t pj,
1041  const cs_real_6_t pifri,
1042  const cs_real_6_t pifrj,
1043  const cs_real_6_t pjfri,
1044  const cs_real_6_t pjfrj,
1045  const cs_real_t i_massflux,
1046  cs_real_t fluxi[6],
1047  cs_real_t fluxj[6])
1048 {
1049  cs_real_t flui, fluj;
1050 
1051  flui = 0.5*(i_massflux + fabs(i_massflux));
1052  fluj = 0.5*(i_massflux - fabs(i_massflux));
1053 
1054  for (int isou = 0; isou < 6; isou++) {
1055  fluxi[isou] += iconvp*( thetap*(flui*pifri[isou] + fluj*pjfri[isou])
1056  - imasac*i_massflux*pi[isou]);
1057  fluxj[isou] += iconvp*( thetap*(flui*pifrj[isou] + fluj*pjfrj[isou])
1058  - imasac*i_massflux*pj[isou]);
1059  }
1060 }
1061 
1062 /*----------------------------------------------------------------------------*/
1075 /*----------------------------------------------------------------------------*/
1076 
1077 inline static void
1078 cs_i_diff_flux(const int idiffp,
1079  const cs_real_t thetap,
1080  const cs_real_t pip,
1081  const cs_real_t pjp,
1082  const cs_real_t pipr,
1083  const cs_real_t pjpr,
1084  const cs_real_t i_visc,
1085  cs_real_2_t fluxij)
1086 {
1087  fluxij[0] += idiffp*thetap*i_visc*(pipr -pjp);
1088  fluxij[1] += idiffp*thetap*i_visc*(pip -pjpr);
1089 }
1090 
1091 /*----------------------------------------------------------------------------*/
1105 /*----------------------------------------------------------------------------*/
1106 
1107 inline static void
1108 cs_i_diff_flux_vector(const int idiffp,
1109  const cs_real_t thetap,
1110  const cs_real_3_t pip,
1111  const cs_real_3_t pjp,
1112  const cs_real_3_t pipr,
1113  const cs_real_3_t pjpr,
1114  const cs_real_t i_visc,
1115  cs_real_t fluxi[3],
1116  cs_real_t fluxj[3])
1117 {
1118  for (int isou = 0; isou < 3; isou++) {
1119  fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
1120  fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
1121  }
1122 }
1123 
1124 /*----------------------------------------------------------------------------*/
1138 /*----------------------------------------------------------------------------*/
1139 
1140 inline static void
1141 cs_i_diff_flux_tensor(const int idiffp,
1142  const cs_real_t thetap,
1143  const cs_real_6_t pip,
1144  const cs_real_6_t pjp,
1145  const cs_real_6_t pipr,
1146  const cs_real_6_t pjpr,
1147  const cs_real_t i_visc,
1148  cs_real_t fluxi[6],
1149  cs_real_t fluxj[6])
1150 {
1151  for (int isou = 0; isou < 6; isou++) {
1152  fluxi[isou] += idiffp*thetap*i_visc*(pipr[isou] -pjp[isou]);
1153  fluxj[isou] += idiffp*thetap*i_visc*(pip[isou] -pjpr[isou]);
1154  }
1155 }
1156 
1157 /*----------------------------------------------------------------------------*/
1181 /*----------------------------------------------------------------------------*/
1182 
1183 inline static void
1184 cs_i_cd_steady_upwind(const int ircflp,
1185  const cs_real_t relaxp,
1186  const cs_real_3_t diipf,
1187  const cs_real_3_t djjpf,
1188  const cs_real_3_t gradi,
1189  const cs_real_3_t gradj,
1190  const cs_real_t pi,
1191  const cs_real_t pj,
1192  const cs_real_t pia,
1193  const cs_real_t pja,
1194  cs_real_t *pifri,
1195  cs_real_t *pifrj,
1196  cs_real_t *pjfri,
1197  cs_real_t *pjfrj,
1198  cs_real_t *pip,
1199  cs_real_t *pjp,
1200  cs_real_t *pipr,
1201  cs_real_t *pjpr)
1202 {
1203  cs_real_t pir, pjr;
1204  cs_real_t recoi, recoj;
1205 
1206  cs_i_compute_quantities(ircflp,
1207  diipf,
1208  djjpf,
1209  gradi,
1210  gradj,
1211  pi,
1212  pj,
1213  &recoi,
1214  &recoj,
1215  pip,
1216  pjp);
1217 
1218  cs_i_relax_c_val(relaxp,
1219  pia,
1220  pja,
1221  recoi,
1222  recoj,
1223  pi,
1224  pj,
1225  &pir,
1226  &pjr,
1227  pipr,
1228  pjpr);
1229 
1230  cs_upwind_f_val(pi,
1231  pifrj);
1232  cs_upwind_f_val(pir,
1233  pifri);
1234  cs_upwind_f_val(pj,
1235  pjfri);
1236  cs_upwind_f_val(pjr,
1237  pjfrj);
1238 }
1239 
1240 /*----------------------------------------------------------------------------*/
1264 /*----------------------------------------------------------------------------*/
1265 
1266 inline static void
1267 cs_i_cd_steady_upwind_vector(const int ircflp,
1268  const cs_real_t relaxp,
1269  const cs_real_3_t diipf,
1270  const cs_real_3_t djjpf,
1271  const cs_real_33_t gradi,
1272  const cs_real_33_t gradj,
1273  const cs_real_3_t pi,
1274  const cs_real_3_t pj,
1275  const cs_real_3_t pia,
1276  const cs_real_3_t pja,
1277  cs_real_t pifri[3],
1278  cs_real_t pifrj[3],
1279  cs_real_t pjfri[3],
1280  cs_real_t pjfrj[3],
1281  cs_real_t pip[3],
1282  cs_real_t pjp[3],
1283  cs_real_t pipr[3],
1284  cs_real_t pjpr[3])
1285 {
1286  cs_real_3_t pir, pjr;
1287  cs_real_3_t recoi, recoj;
1288 
1289  cs_i_compute_quantities_vector(ircflp,
1290  diipf,
1291  djjpf,
1292  gradi,
1293  gradj,
1294  pi,
1295  pj,
1296  recoi,
1297  recoj,
1298  pip,
1299  pjp);
1300 
1301  cs_i_relax_c_val_vector(relaxp,
1302  pia,
1303  pja,
1304  recoi,
1305  recoj,
1306  pi,
1307  pj,
1308  pir,
1309  pjr,
1310  pipr,
1311  pjpr);
1312 
1313  cs_upwind_f_val_vector(pi,
1314  pifrj);
1315  cs_upwind_f_val_vector(pir,
1316  pifri);
1317  cs_upwind_f_val_vector(pj,
1318  pjfri);
1319  cs_upwind_f_val_vector(pjr,
1320  pjfrj);
1321 
1322 }
1323 
1324 /*----------------------------------------------------------------------------*/
1348 /*----------------------------------------------------------------------------*/
1349 
1350 inline static void
1351 cs_i_cd_steady_upwind_tensor(const int ircflp,
1352  const cs_real_t relaxp,
1353  const cs_real_3_t diipf,
1354  const cs_real_3_t djjpf,
1355  const cs_real_63_t gradi,
1356  const cs_real_63_t gradj,
1357  const cs_real_6_t pi,
1358  const cs_real_6_t pj,
1359  const cs_real_6_t pia,
1360  const cs_real_6_t pja,
1361  cs_real_t pifri[6],
1362  cs_real_t pifrj[6],
1363  cs_real_t pjfri[6],
1364  cs_real_t pjfrj[6],
1365  cs_real_t pip[6],
1366  cs_real_t pjp[6],
1367  cs_real_t pipr[6],
1368  cs_real_t pjpr[6])
1369 {
1370  cs_real_6_t pir, pjr;
1371  cs_real_6_t recoi, recoj;
1372 
1373  cs_i_compute_quantities_tensor(ircflp,
1374  diipf,
1375  djjpf,
1376  gradi,
1377  gradj,
1378  pi,
1379  pj,
1380  recoi,
1381  recoj,
1382  pip,
1383  pjp);
1384 
1385  cs_i_relax_c_val_tensor(relaxp,
1386  pia,
1387  pja,
1388  recoi,
1389  recoj,
1390  pi,
1391  pj,
1392  pir,
1393  pjr,
1394  pipr,
1395  pjpr);
1396 
1397  cs_upwind_f_val_tensor(pi,
1398  pifrj);
1399  cs_upwind_f_val_tensor(pir,
1400  pifri);
1401  cs_upwind_f_val_tensor(pj,
1402  pjfri);
1403  cs_upwind_f_val_tensor(pjr,
1404  pjfrj);
1405 }
1406 
1407 /*----------------------------------------------------------------------------*/
1424 /*----------------------------------------------------------------------------*/
1425 
1426 inline static void
1427 cs_i_cd_unsteady_upwind(const int ircflp,
1428  const cs_real_3_t diipf,
1429  const cs_real_3_t djjpf,
1430  const cs_real_3_t gradi,
1431  const cs_real_3_t gradj,
1432  const cs_real_t pi,
1433  const cs_real_t pj,
1434  cs_real_t *pif,
1435  cs_real_t *pjf,
1436  cs_real_t *pip,
1437  cs_real_t *pjp)
1438 {
1439  cs_real_t recoi, recoj;
1440 
1441  cs_i_compute_quantities(ircflp,
1442  diipf,
1443  djjpf,
1444  gradi,
1445  gradj,
1446  pi,
1447  pj,
1448  &recoi,
1449  &recoj,
1450  pip,
1451  pjp);
1452 
1453  cs_upwind_f_val(pi, pif);
1454  cs_upwind_f_val(pj, pjf);
1455 }
1456 
1457 /*----------------------------------------------------------------------------*/
1474 /*----------------------------------------------------------------------------*/
1475 
1476 inline static void
1477 cs_i_cd_unsteady_upwind_vector(const int ircflp,
1478  const cs_real_3_t diipf,
1479  const cs_real_3_t djjpf,
1480  const cs_real_33_t gradi,
1481  const cs_real_33_t gradj,
1482  const cs_real_3_t pi,
1483  const cs_real_3_t pj,
1484  cs_real_t pif[3],
1485  cs_real_t pjf[3],
1486  cs_real_t pip[3],
1487  cs_real_t pjp[3])
1488 {
1489  cs_real_3_t recoi, recoj;
1490 
1491  cs_i_compute_quantities_vector(ircflp,
1492  diipf,
1493  djjpf,
1494  gradi,
1495  gradj,
1496  pi,
1497  pj,
1498  recoi,
1499  recoj,
1500  pip,
1501  pjp);
1502 
1503  cs_upwind_f_val_vector(pi, pif);
1504  cs_upwind_f_val_vector(pj, pjf);
1505 
1506 }
1507 
1508 /*----------------------------------------------------------------------------*/
1525 /*----------------------------------------------------------------------------*/
1526 
1527 inline static void
1528 cs_i_cd_unsteady_upwind_tensor(const int ircflp,
1529  const cs_real_3_t diipf,
1530  const cs_real_3_t djjpf,
1531  const cs_real_63_t gradi,
1532  const cs_real_63_t gradj,
1533  const cs_real_6_t pi,
1534  const cs_real_6_t pj,
1535  cs_real_t pif[6],
1536  cs_real_t pjf[6],
1537  cs_real_t pip[6],
1538  cs_real_t pjp[6])
1539 {
1540  cs_real_6_t recoi, recoj;
1541 
1542  cs_i_compute_quantities_tensor(ircflp,
1543  diipf,
1544  djjpf,
1545  gradi,
1546  gradj,
1547  pi,
1548  pj,
1549  recoi,
1550  recoj,
1551  pip,
1552  pjp);
1553 
1554  cs_upwind_f_val_tensor(pi, pif);
1555  cs_upwind_f_val_tensor(pj, pjf);
1556 
1557 }
1558 
1559 /*----------------------------------------------------------------------------*/
1592 /*----------------------------------------------------------------------------*/
1593 
1594 inline static void
1595 cs_i_cd_steady(const int ircflp,
1596  const int ischcp,
1597  const double relaxp,
1598  const double blencp,
1599  const cs_real_t weight,
1600  const cs_real_3_t cell_ceni,
1601  const cs_real_3_t cell_cenj,
1602  const cs_real_3_t i_face_cog,
1603  const cs_real_3_t diipf,
1604  const cs_real_3_t djjpf,
1605  const cs_real_3_t gradi,
1606  const cs_real_3_t gradj,
1607  const cs_real_3_t gradupi,
1608  const cs_real_3_t gradupj,
1609  const cs_real_t pi,
1610  const cs_real_t pj,
1611  const cs_real_t pia,
1612  const cs_real_t pja,
1613  cs_real_t *pifri,
1614  cs_real_t *pifrj,
1615  cs_real_t *pjfri,
1616  cs_real_t *pjfrj,
1617  cs_real_t *pip,
1618  cs_real_t *pjp,
1619  cs_real_t *pipr,
1620  cs_real_t *pjpr)
1621 {
1622  cs_real_t pir, pjr;
1623  cs_real_t recoi, recoj;
1624 
1625  cs_i_compute_quantities(ircflp,
1626  diipf,
1627  djjpf,
1628  gradi,
1629  gradj,
1630  pi,
1631  pj,
1632  &recoi,
1633  &recoj,
1634  pip,
1635  pjp);
1636 
1637  cs_i_relax_c_val(relaxp,
1638  pia,
1639  pja,
1640  recoi,
1641  recoj,
1642  pi,
1643  pj,
1644  &pir,
1645  &pjr,
1646  pipr,
1647  pjpr);
1648 
1649  if (ischcp == 1) {
1650 
1651  /* Centered
1652  --------*/
1653 
1654  cs_centered_f_val(weight,
1655  *pip,
1656  *pjpr,
1657  pifrj);
1658  cs_centered_f_val(weight,
1659  *pipr,
1660  *pjp,
1661  pifri);
1662  cs_centered_f_val(weight,
1663  *pipr,
1664  *pjp,
1665  pjfri);
1666  cs_centered_f_val(weight,
1667  *pip,
1668  *pjpr,
1669  pjfrj);
1670 
1671  } else if (ischcp == 0) {
1672 
1673  /* Original SOLU
1674  --------------*/
1675 
1676  cs_solu_f_val(cell_ceni,
1677  i_face_cog,
1678  gradi,
1679  pi,
1680  pifrj);
1681  cs_solu_f_val(cell_ceni,
1682  i_face_cog,
1683  gradi,
1684  pir,
1685  pifri);
1686  cs_solu_f_val(cell_cenj,
1687  i_face_cog,
1688  gradj,
1689  pj,
1690  pjfri);
1691  cs_solu_f_val(cell_cenj,
1692  i_face_cog,
1693  gradj,
1694  pjr,
1695  pjfrj);
1696 
1697  } else {
1698 
1699  /* SOLU
1700  ----*/
1701 
1702  cs_solu_f_val(cell_ceni,
1703  i_face_cog,
1704  gradupi,
1705  pi,
1706  pifrj);
1707  cs_solu_f_val(cell_ceni,
1708  i_face_cog,
1709  gradupi,
1710  pir,
1711  pifri);
1712  cs_solu_f_val(cell_cenj,
1713  i_face_cog,
1714  gradupj,
1715  pj,
1716  pjfri);
1717  cs_solu_f_val(cell_cenj,
1718  i_face_cog,
1719  gradupj,
1720  pjr,
1721  pjfrj);
1722 
1723  }
1724 
1725  /* Blending
1726  --------*/
1727 
1728  cs_blend_f_val(blencp,
1729  pi,
1730  pifrj);
1731  cs_blend_f_val(blencp,
1732  pir,
1733  pifri);
1734  cs_blend_f_val(blencp,
1735  pj,
1736  pjfri);
1737  cs_blend_f_val(blencp,
1738  pjr,
1739  pjfrj);
1740 }
1741 
1742 /*----------------------------------------------------------------------------*/
1773 /*----------------------------------------------------------------------------*/
1774 
1775 inline static void
1776 cs_i_cd_steady_vector(const int ircflp,
1777  const int ischcp,
1778  const double relaxp,
1779  const double blencp,
1780  const cs_real_t weight,
1781  const cs_real_3_t cell_ceni,
1782  const cs_real_3_t cell_cenj,
1783  const cs_real_3_t i_face_cog,
1784  const cs_real_3_t diipf,
1785  const cs_real_3_t djjpf,
1786  const cs_real_33_t gradi,
1787  const cs_real_33_t gradj,
1788  const cs_real_3_t pi,
1789  const cs_real_3_t pj,
1790  const cs_real_3_t pia,
1791  const cs_real_3_t pja,
1792  cs_real_t pifri[3],
1793  cs_real_t pifrj[3],
1794  cs_real_t pjfri[3],
1795  cs_real_t pjfrj[3],
1796  cs_real_t pip[3],
1797  cs_real_t pjp[3],
1798  cs_real_t pipr[3],
1799  cs_real_t pjpr[3])
1800 {
1801  cs_real_3_t pir, pjr;
1802  cs_real_3_t recoi, recoj;
1803 
1804  cs_i_compute_quantities_vector(ircflp,
1805  diipf,
1806  djjpf,
1807  gradi,
1808  gradj,
1809  pi,
1810  pj,
1811  recoi,
1812  recoj,
1813  pip,
1814  pjp);
1815 
1816  cs_i_relax_c_val_vector(relaxp,
1817  pia,
1818  pja,
1819  recoi,
1820  recoj,
1821  pi,
1822  pj,
1823  pir,
1824  pjr,
1825  pipr,
1826  pjpr);
1827 
1828  if (ischcp == 1) {
1829 
1830  /* Centered
1831  --------*/
1832 
1833  cs_centered_f_val_vector(weight,
1834  pip,
1835  pjpr,
1836  pifrj);
1837  cs_centered_f_val_vector(weight,
1838  pipr,
1839  pjp,
1840  pifri);
1841  cs_centered_f_val_vector(weight,
1842  pipr,
1843  pjp,
1844  pjfri);
1845  cs_centered_f_val_vector(weight,
1846  pip,
1847  pjpr,
1848  pjfrj);
1849 
1850  } else {
1851 
1852  /* Second order
1853  ------------*/
1854 
1855  cs_solu_f_val_vector(cell_ceni,
1856  i_face_cog,
1857  gradi,
1858  pi,
1859  pifrj);
1860  cs_solu_f_val_vector(cell_ceni,
1861  i_face_cog,
1862  gradi,
1863  pir,
1864  pifri);
1865  cs_solu_f_val_vector(cell_cenj,
1866  i_face_cog,
1867  gradj,
1868  pj,
1869  pjfri);
1870  cs_solu_f_val_vector(cell_cenj,
1871  i_face_cog,
1872  gradj,
1873  pjr,
1874  pjfrj);
1875 
1876  }
1877 
1878  /* Blending
1879  --------*/
1880  cs_blend_f_val_vector(blencp,
1881  pi,
1882  pifrj);
1883  cs_blend_f_val_vector(blencp,
1884  pir,
1885  pifri);
1886  cs_blend_f_val_vector(blencp,
1887  pj,
1888  pjfri);
1889  cs_blend_f_val_vector(blencp,
1890  pjr,
1891  pjfrj);
1892 
1893 }
1894 
1895 /*----------------------------------------------------------------------------*/
1926 /*----------------------------------------------------------------------------*/
1927 
1928 inline static void
1929 cs_i_cd_steady_tensor(const int ircflp,
1930  const int ischcp,
1931  const double relaxp,
1932  const double blencp,
1933  const cs_real_t weight,
1934  const cs_real_3_t cell_ceni,
1935  const cs_real_3_t cell_cenj,
1936  const cs_real_3_t i_face_cog,
1937  const cs_real_3_t diipf,
1938  const cs_real_3_t djjpf,
1939  const cs_real_63_t gradi,
1940  const cs_real_63_t gradj,
1941  const cs_real_6_t pi,
1942  const cs_real_6_t pj,
1943  const cs_real_6_t pia,
1944  const cs_real_6_t pja,
1945  cs_real_t pifri[6],
1946  cs_real_t pifrj[6],
1947  cs_real_t pjfri[6],
1948  cs_real_t pjfrj[6],
1949  cs_real_t pip[6],
1950  cs_real_t pjp[6],
1951  cs_real_t pipr[6],
1952  cs_real_t pjpr[6])
1953 
1954 {
1955  cs_real_6_t pir, pjr;
1956  cs_real_6_t recoi, recoj;
1957 
1958  cs_i_compute_quantities_tensor(ircflp,
1959  diipf,
1960  djjpf,
1961  gradi,
1962  gradj,
1963  pi,
1964  pj,
1965  recoi,
1966  recoj,
1967  pip,
1968  pjp);
1969 
1970  cs_i_relax_c_val_tensor(relaxp,
1971  pia,
1972  pja,
1973  recoi,
1974  recoj,
1975  pi,
1976  pj,
1977  pir,
1978  pjr,
1979  pipr,
1980  pjpr);
1981 
1982  if (ischcp == 1) {
1983 
1984  /* Centered
1985  --------*/
1986 
1987  cs_centered_f_val_tensor(weight,
1988  pip,
1989  pjpr,
1990  pifrj);
1991  cs_centered_f_val_tensor(weight,
1992  pipr,
1993  pjp,
1994  pifri);
1995  cs_centered_f_val_tensor(weight,
1996  pipr,
1997  pjp,
1998  pjfri);
1999  cs_centered_f_val_tensor(weight,
2000  pip,
2001  pjpr,
2002  pjfrj);
2003 
2004  } else {
2005 
2006  /* Second order
2007  ------------*/
2008 
2009  cs_solu_f_val_tensor(cell_ceni,
2010  i_face_cog,
2011  gradi,
2012  pi,
2013  pifrj);
2014  cs_solu_f_val_tensor(cell_ceni,
2015  i_face_cog,
2016  gradi,
2017  pir,
2018  pifri);
2019  cs_solu_f_val_tensor(cell_cenj,
2020  i_face_cog,
2021  gradj,
2022  pj,
2023  pjfri);
2024  cs_solu_f_val_tensor(cell_cenj,
2025  i_face_cog,
2026  gradj,
2027  pjr,
2028  pjfrj);
2029 
2030  }
2031 
2032  /* Blending
2033  --------*/
2034 
2035  cs_blend_f_val_tensor(blencp,
2036  pi,
2037  pifrj);
2038  cs_blend_f_val_tensor(blencp,
2039  pir,
2040  pifri);
2041  cs_blend_f_val_tensor(blencp,
2042  pj,
2043  pjfri);
2044  cs_blend_f_val_tensor(blencp,
2045  pjr,
2046  pjfrj);
2047 
2048 }
2049 
2050 /*----------------------------------------------------------------------------*/
2080 /*----------------------------------------------------------------------------*/
2081 
2082 inline static void
2083 cs_i_cd_unsteady(const int ircflp,
2084  const int ischcp,
2085  const double blencp,
2086  const cs_real_t weight,
2087  const cs_real_3_t cell_ceni,
2088  const cs_real_3_t cell_cenj,
2089  const cs_real_3_t i_face_cog,
2090  const cs_real_t hybrid_blend_i,
2091  const cs_real_t hybrid_blend_j,
2092  const cs_real_3_t diipf,
2093  const cs_real_3_t djjpf,
2094  const cs_real_3_t gradi,
2095  const cs_real_3_t gradj,
2096  const cs_real_3_t gradupi,
2097  const cs_real_3_t gradupj,
2098  const cs_real_t pi,
2099  const cs_real_t pj,
2100  cs_real_t *pif,
2101  cs_real_t *pjf,
2102  cs_real_t *pip,
2103  cs_real_t *pjp)
2104 {
2105  cs_real_t recoi, recoj;
2106 
2107  cs_i_compute_quantities(ircflp,
2108  diipf,
2109  djjpf,
2110  gradi,
2111  gradj,
2112  pi,
2113  pj,
2114  &recoi,
2115  &recoj,
2116  pip,
2117  pjp);
2118 
2119 
2120  if (ischcp == 1) {
2121 
2122  /* Centered
2123  --------*/
2124 
2125  cs_centered_f_val(weight,
2126  *pip,
2127  *pjp,
2128  pif);
2129  cs_centered_f_val(weight,
2130  *pip,
2131  *pjp,
2132  pjf);
2133 
2134  } else if (ischcp == 0) {
2135 
2136  /* Legacy SOLU
2137  -----------*/
2138 
2139  cs_solu_f_val(cell_ceni,
2140  i_face_cog,
2141  gradi,
2142  pi,
2143  pif);
2144  cs_solu_f_val(cell_cenj,
2145  i_face_cog,
2146  gradj,
2147  pj,
2148  pjf);
2149 
2150  } else if (ischcp == 3) {
2151 
2152  /* Centered
2153  --------*/
2154 
2155  cs_centered_f_val(weight,
2156  *pip,
2157  *pjp,
2158  pif);
2159  cs_centered_f_val(weight,
2160  *pip,
2161  *pjp,
2162  pjf);
2163 
2164  /* Legacy SOLU
2165  -----------*/
2166  cs_real_t pif_up, pjf_up;
2167  cs_real_t hybrid_blend_interp;
2168 
2169  cs_solu_f_val(cell_ceni,
2170  i_face_cog,
2171  gradi,
2172  pi,
2173  &pif_up);
2174  cs_solu_f_val(cell_cenj,
2175  i_face_cog,
2176  gradj,
2177  pj,
2178  &pjf_up);
2179 
2180  hybrid_blend_interp = fmin(hybrid_blend_i,hybrid_blend_j);
2181  *pif = hybrid_blend_interp*(*pif) + (1. - hybrid_blend_interp)*pif_up;
2182  *pjf = hybrid_blend_interp*(*pjf) + (1. - hybrid_blend_interp)*pjf_up;
2183 
2184  } else {
2185 
2186  /* SOLU
2187  ----*/
2188 
2189  cs_solu_f_val(cell_ceni,
2190  i_face_cog,
2191  gradupi,
2192  pi,
2193  pif);
2194  cs_solu_f_val(cell_cenj,
2195  i_face_cog,
2196  gradupj,
2197  pj,
2198  pjf);
2199 
2200  }
2201 
2202 
2203  /* Blending
2204  --------*/
2205 
2206  cs_blend_f_val(blencp,
2207  pi,
2208  pif);
2209  cs_blend_f_val(blencp,
2210  pj,
2211  pjf);
2212 }
2213 
2214 /*----------------------------------------------------------------------------*/
2240 /*----------------------------------------------------------------------------*/
2241 
2242 inline static void
2243 cs_i_cd_unsteady_vector(const int ircflp,
2244  const int ischcp,
2245  const double blencp,
2246  const cs_real_t weight,
2247  const cs_real_3_t cell_ceni,
2248  const cs_real_3_t cell_cenj,
2249  const cs_real_3_t i_face_cog,
2250  const cs_real_t hybrid_blend_i,
2251  const cs_real_t hybrid_blend_j,
2252  const cs_real_3_t diipf,
2253  const cs_real_3_t djjpf,
2254  const cs_real_33_t gradi,
2255  const cs_real_33_t gradj,
2256  const cs_real_3_t pi,
2257  const cs_real_3_t pj,
2258  cs_real_t pif[3],
2259  cs_real_t pjf[3],
2260  cs_real_t pip[3],
2261  cs_real_t pjp[3])
2262 
2263 {
2264  cs_real_3_t recoi, recoj;
2265 
2266  cs_i_compute_quantities_vector(ircflp,
2267  diipf,
2268  djjpf,
2269  gradi,
2270  gradj,
2271  pi,
2272  pj,
2273  recoi,
2274  recoj,
2275  pip,
2276  pjp);
2277 
2278  if (ischcp == 1) {
2279 
2280  /* Centered
2281  --------*/
2282 
2283  cs_centered_f_val_vector(weight,
2284  pip,
2285  pjp,
2286  pif);
2287  cs_centered_f_val_vector(weight,
2288  pip,
2289  pjp,
2290  pjf);
2291  } else if (ischcp == 3) {
2292 
2293  /* Centered
2294  --------*/
2295 
2296  cs_centered_f_val_vector(weight,
2297  pip,
2298  pjp,
2299  pif);
2300  cs_centered_f_val_vector(weight,
2301  pip,
2302  pjp,
2303  pjf);
2304 
2305  /* SOLU
2306  -----*/
2307  cs_real_t pif_up[3], pjf_up[3];
2308  cs_real_t hybrid_blend_interp;
2309 
2310  cs_solu_f_val_vector(cell_ceni,
2311  i_face_cog,
2312  gradi,
2313  pi,
2314  pif_up);
2315  cs_solu_f_val_vector(cell_cenj,
2316  i_face_cog,
2317  gradj,
2318  pj,
2319  pjf_up);
2320 
2321  hybrid_blend_interp = fmin(hybrid_blend_i,hybrid_blend_j);
2322  for (int isou = 0; isou < 3; isou++) {
2323  pif[isou] = hybrid_blend_interp *pif[isou]
2324  + (1. - hybrid_blend_interp)*pif_up[isou];
2325  pjf[isou] = hybrid_blend_interp *pjf[isou]
2326  + (1. - hybrid_blend_interp)*pjf_up[isou];
2327  }
2328  } else {
2329 
2330  /* Second order
2331  ------------*/
2332 
2333  cs_solu_f_val_vector(cell_ceni,
2334  i_face_cog,
2335  gradi,
2336  pi,
2337  pif);
2338  cs_solu_f_val_vector(cell_cenj,
2339  i_face_cog,
2340  gradj,
2341  pj,
2342  pjf);
2343 
2344  }
2345 
2346  /* Blending
2347  --------*/
2348 
2349  cs_blend_f_val_vector(blencp,
2350  pi,
2351  pif);
2352  cs_blend_f_val_vector(blencp,
2353  pj,
2354  pjf);
2355 
2356 }
2357 
2358 /*----------------------------------------------------------------------------*/
2382 /*----------------------------------------------------------------------------*/
2383 
2384 inline static void
2385 cs_i_cd_unsteady_tensor(const int ircflp,
2386  const int ischcp,
2387  const double blencp,
2388  const cs_real_t weight,
2389  const cs_real_3_t cell_ceni,
2390  const cs_real_3_t cell_cenj,
2391  const cs_real_3_t i_face_cog,
2392  const cs_real_3_t diipf,
2393  const cs_real_3_t djjpf,
2394  const cs_real_63_t gradi,
2395  const cs_real_63_t gradj,
2396  const cs_real_6_t pi,
2397  const cs_real_6_t pj,
2398  cs_real_t pif[6],
2399  cs_real_t pjf[6],
2400  cs_real_t pip[6],
2401  cs_real_t pjp[6])
2402 
2403 {
2404  cs_real_6_t recoi, recoj;
2405 
2406  cs_i_compute_quantities_tensor(ircflp,
2407  diipf,
2408  djjpf,
2409  gradi,
2410  gradj,
2411  pi,
2412  pj,
2413  recoi,
2414  recoj,
2415  pip,
2416  pjp);
2417 
2418  if (ischcp == 1) {
2419 
2420  /* Centered
2421  --------*/
2422 
2423  cs_centered_f_val_tensor(weight,
2424  pip,
2425  pjp,
2426  pif);
2427  cs_centered_f_val_tensor(weight,
2428  pip,
2429  pjp,
2430  pjf);
2431 
2432  } else {
2433 
2434  /* Second order
2435  ------------*/
2436 
2437  cs_solu_f_val_tensor(cell_ceni,
2438  i_face_cog,
2439  gradi,
2440  pi,
2441  pif);
2442  cs_solu_f_val_tensor(cell_cenj,
2443  i_face_cog,
2444  gradj,
2445  pj,
2446  pjf);
2447 
2448  }
2449 
2450  /* Blending
2451  --------*/
2452 
2453  cs_blend_f_val_tensor(blencp,
2454  pi,
2455  pif);
2456  cs_blend_f_val_tensor(blencp,
2457  pj,
2458  pjf);
2459 
2460 }
2461 
2462 /*----------------------------------------------------------------------------*/
2506 /*----------------------------------------------------------------------------*/
2507 
2508 inline static void
2509 cs_i_cd_steady_slope_test(bool *upwind_switch,
2510  const int iconvp,
2511  const int ircflp,
2512  const int ischcp,
2513  const double relaxp,
2514  const double blencp,
2515  const double blend_st,
2516  const cs_real_t weight,
2517  const cs_real_t i_dist,
2518  const cs_real_t i_face_surf,
2519  const cs_real_3_t cell_ceni,
2520  const cs_real_3_t cell_cenj,
2521  const cs_real_3_t i_face_normal,
2522  const cs_real_3_t i_face_cog,
2523  const cs_real_3_t diipf,
2524  const cs_real_3_t djjpf,
2525  const cs_real_t i_massflux,
2526  const cs_real_3_t gradi,
2527  const cs_real_3_t gradj,
2528  const cs_real_3_t gradupi,
2529  const cs_real_3_t gradupj,
2530  const cs_real_3_t gradsti,
2531  const cs_real_3_t gradstj,
2532  const cs_real_t pi,
2533  const cs_real_t pj,
2534  const cs_real_t pia,
2535  const cs_real_t pja,
2536  cs_real_t *pifri,
2537  cs_real_t *pifrj,
2538  cs_real_t *pjfri,
2539  cs_real_t *pjfrj,
2540  cs_real_t *pip,
2541  cs_real_t *pjp,
2542  cs_real_t *pipr,
2543  cs_real_t *pjpr)
2544 {
2545  cs_real_t pir, pjr;
2546  cs_real_t recoi, recoj;
2547  cs_real_t testij, tesqck;
2548 
2549  *upwind_switch = false;
2550 
2551  cs_i_compute_quantities(ircflp,
2552  diipf,
2553  djjpf,
2554  gradi,
2555  gradj,
2556  pi,
2557  pj,
2558  &recoi,
2559  &recoj,
2560  pip,
2561  pjp);
2562 
2563  cs_i_relax_c_val(relaxp,
2564  pia,
2565  pja,
2566  recoi,
2567  recoj,
2568  pi,
2569  pj,
2570  &pir,
2571  &pjr,
2572  pipr,
2573  pjpr);
2574 
2575  /* Convection slope test is needed only when iconv >0 */
2576  if (iconvp > 0) {
2577  cs_slope_test(pi,
2578  pj,
2579  i_dist,
2580  i_face_surf,
2581  i_face_normal,
2582  gradi,
2583  gradj,
2584  gradsti,
2585  gradstj,
2586  i_massflux,
2587  &testij,
2588  &tesqck);
2589 
2590  if (ischcp==1) {
2591 
2592  /* Centered
2593  --------*/
2594 
2595  cs_centered_f_val(weight,
2596  *pip,
2597  *pjpr,
2598  pifrj);
2599  cs_centered_f_val(weight,
2600  *pipr,
2601  *pjp,
2602  pifri);
2603  cs_centered_f_val(weight,
2604  *pipr,
2605  *pjp,
2606  pjfri);
2607  cs_centered_f_val(weight,
2608  *pip,
2609  *pjpr,
2610  pjfrj);
2611 
2612  } else if (ischcp == 0) {
2613 
2614  /* Second order
2615  ------------*/
2616 
2617  cs_solu_f_val(cell_ceni,
2618  i_face_cog,
2619  gradi,
2620  pi,
2621  pifrj);
2622  cs_solu_f_val(cell_ceni,
2623  i_face_cog,
2624  gradi,
2625  pir,
2626  pifri);
2627  cs_solu_f_val(cell_cenj,
2628  i_face_cog,
2629  gradj,
2630  pj,
2631  pjfri);
2632  cs_solu_f_val(cell_cenj,
2633  i_face_cog,
2634  gradj,
2635  pjr,
2636  pjfrj);
2637 
2638  } else {
2639 
2640  /* SOLU
2641  -----*/
2642 
2643  cs_solu_f_val(cell_ceni,
2644  i_face_cog,
2645  gradupi,
2646  pi,
2647  pifrj);
2648  cs_solu_f_val(cell_ceni,
2649  i_face_cog,
2650  gradupi,
2651  pir,
2652  pifri);
2653  cs_solu_f_val(cell_cenj,
2654  i_face_cog,
2655  gradupj,
2656  pj,
2657  pjfri);
2658  cs_solu_f_val(cell_cenj,
2659  i_face_cog,
2660  gradupj,
2661  pjr,
2662  pjfrj);
2663  }
2664 
2665 
2666  /* Slope test: Pourcentage of upwind
2667  ----------------------------------*/
2668 
2669  if (tesqck <= 0. || testij <= 0.) {
2670 
2671  cs_blend_f_val(blend_st,
2672  pi,
2673  pifrj);
2674  cs_blend_f_val(blend_st,
2675  pir,
2676  pifri);
2677  cs_blend_f_val(blend_st,
2678  pj,
2679  pjfri);
2680  cs_blend_f_val(blend_st,
2681  pjr,
2682  pjfrj);
2683 
2684  *upwind_switch = true;
2685 
2686  }
2687 
2688 
2689  /* Blending
2690  --------*/
2691 
2692  cs_blend_f_val(blencp,
2693  pi,
2694  pifrj);
2695  cs_blend_f_val(blencp,
2696  pir,
2697  pifri);
2698  cs_blend_f_val(blencp,
2699  pj,
2700  pjfri);
2701  cs_blend_f_val(blencp,
2702  pjr,
2703  pjfrj);
2704 
2705  /* If iconv=0 p*fr* are useless */
2706  } else {
2707  cs_upwind_f_val(pi,
2708  pifrj);
2709  cs_upwind_f_val(pir,
2710  pifri);
2711  cs_upwind_f_val(pj,
2712  pjfri);
2713  cs_upwind_f_val(pjr,
2714  pjfrj);
2715  }
2716 
2717 }
2718 
2719 /*----------------------------------------------------------------------------*/
2758 /*----------------------------------------------------------------------------*/
2759 
2760 inline static void
2761 cs_i_cd_steady_slope_test_vector_old(bool *upwind_switch,
2762  const int iconvp,
2763  const int ircflp,
2764  const int ischcp,
2765  const double relaxp,
2766  const double blencp,
2767  const cs_real_t weight,
2768  const cs_real_t i_dist,
2769  const cs_real_t i_face_surf,
2770  const cs_real_3_t cell_ceni,
2771  const cs_real_3_t cell_cenj,
2772  const cs_real_3_t i_face_normal,
2773  const cs_real_3_t i_face_cog,
2774  const cs_real_3_t diipf,
2775  const cs_real_3_t djjpf,
2776  const cs_real_t i_massflux,
2777  const cs_real_33_t gradi,
2778  const cs_real_33_t gradj,
2779  const cs_real_33_t grdpai,
2780  const cs_real_33_t grdpaj,
2781  const cs_real_3_t pi,
2782  const cs_real_3_t pj,
2783  const cs_real_3_t pia,
2784  const cs_real_3_t pja,
2785  cs_real_t pifri[3],
2786  cs_real_t pifrj[3],
2787  cs_real_t pjfri[3],
2788  cs_real_t pjfrj[3],
2789  cs_real_t pip[3],
2790  cs_real_t pjp[3],
2791  cs_real_t pipr[3],
2792  cs_real_t pjpr[3])
2793 {
2794  cs_real_3_t pir, pjr;
2795  cs_real_3_t recoi, recoj;
2796  cs_real_t distf, srfan;
2797  cs_real_3_t testij, tesqck;
2798  int isou;
2799 
2800  distf = i_dist;
2801  srfan = i_face_surf;
2802 
2803  cs_i_compute_quantities_vector(ircflp,
2804  diipf,
2805  djjpf,
2806  gradi,
2807  gradj,
2808  pi,
2809  pj,
2810  recoi,
2811  recoj,
2812  pip,
2813  pjp);
2814 
2815  cs_i_relax_c_val_vector(relaxp,
2816  pia,
2817  pja,
2818  recoi,
2819  recoj,
2820  pi,
2821  pj,
2822  pir,
2823  pjr,
2824  pipr,
2825  pjpr);
2826 
2827  /* Convection slope test is needed only when iconv >0 */
2828  if (iconvp > 0) {
2829  cs_slope_test_vector_old(pi,
2830  pj,
2831  distf,
2832  srfan,
2833  i_face_normal,
2834  gradi,
2835  gradj,
2836  grdpai,
2837  grdpaj,
2838  i_massflux,
2839  testij,
2840  tesqck);
2841 
2842  for (isou = 0; isou < 3; isou++) {
2843  if (tesqck[isou]<=0. || testij[isou]<=0.) {
2844 
2845  /* Upwind
2846  --------*/
2847 
2848  cs_upwind_f_val(pi[isou],
2849  &pifrj[isou]);
2850  cs_upwind_f_val(pir[isou],
2851  &pifri[isou]);
2852  cs_upwind_f_val(pj[isou],
2853  &pjfri[isou]);
2854  cs_upwind_f_val(pjr[isou],
2855  &pjfrj[isou]);
2856 
2857  *upwind_switch = true;
2858 
2859  } else {
2860 
2861  if (ischcp==1) {
2862 
2863  /* Centered
2864  --------*/
2865 
2866  cs_centered_f_val(weight,
2867  pip[isou],
2868  pjpr[isou],
2869  &pifrj[isou]);
2870  cs_centered_f_val(weight,
2871  pipr[isou],
2872  pjp[isou],
2873  &pifri[isou]);
2874  cs_centered_f_val(weight,
2875  pipr[isou],
2876  pjp[isou],
2877  &pjfri[isou]);
2878  cs_centered_f_val(weight,
2879  pip[isou],
2880  pjpr[isou],
2881  &pjfrj[isou]);
2882 
2883  } else {
2884 
2885  /* Second order
2886  ------------*/
2887 
2888  cs_solu_f_val(cell_ceni,
2889  i_face_cog,
2890  gradi[isou],
2891  pi[isou],
2892  &pifrj[isou]);
2893  cs_solu_f_val(cell_ceni,
2894  i_face_cog,
2895  gradi[isou],
2896  pir[isou],
2897  &pifri[isou]);
2898  cs_solu_f_val(cell_cenj,
2899  i_face_cog,
2900  gradj[isou],
2901  pj[isou],
2902  &pjfri[isou]);
2903  cs_solu_f_val(cell_cenj,
2904  i_face_cog,
2905  gradj[isou],
2906  pjr[isou],
2907  &pjfrj[isou]);
2908 
2909  }
2910  }
2911  }
2912 
2913  /* Blending
2914  --------*/
2915  cs_blend_f_val_vector(blencp,
2916  pi,
2917  pifrj);
2918  cs_blend_f_val_vector(blencp,
2919  pir,
2920  pifri);
2921  cs_blend_f_val_vector(blencp,
2922  pj,
2923  pjfri);
2924  cs_blend_f_val_vector(blencp,
2925  pjr,
2926  pjfrj);
2927 
2928  /* If iconv=0 p*fr* are useless */
2929  } else {
2930  for (isou = 0; isou < 3; isou++) {
2931  cs_upwind_f_val(pi[isou],
2932  &pifrj[isou]);
2933  cs_upwind_f_val(pir[isou],
2934  &pifri[isou]);
2935  cs_upwind_f_val(pj[isou],
2936  &pjfri[isou]);
2937  cs_upwind_f_val(pjr[isou],
2938  &pjfrj[isou]);
2939  }
2940  }
2941 
2942 }
2943 
2944 /*----------------------------------------------------------------------------*/
2986 /*----------------------------------------------------------------------------*/
2987 
2988 inline static void
2989 cs_i_cd_steady_slope_test_vector(bool *upwind_switch,
2990  const int iconvp,
2991  const int ircflp,
2992  const int ischcp,
2993  const double relaxp,
2994  const double blencp,
2995  const double blend_st,
2996  const cs_real_t weight,
2997  const cs_real_t i_dist,
2998  const cs_real_t i_face_surf,
2999  const cs_real_3_t cell_ceni,
3000  const cs_real_3_t cell_cenj,
3001  const cs_real_3_t i_face_normal,
3002  const cs_real_3_t i_face_cog,
3003  const cs_real_3_t diipf,
3004  const cs_real_3_t djjpf,
3005  const cs_real_t i_massflux,
3006  const cs_real_33_t gradi,
3007  const cs_real_33_t gradj,
3008  const cs_real_33_t grdpai,
3009  const cs_real_33_t grdpaj,
3010  const cs_real_3_t pi,
3011  const cs_real_3_t pj,
3012  const cs_real_3_t pia,
3013  const cs_real_3_t pja,
3014  cs_real_t pifri[3],
3015  cs_real_t pifrj[3],
3016  cs_real_t pjfri[3],
3017  cs_real_t pjfrj[3],
3018  cs_real_t pip[3],
3019  cs_real_t pjp[3],
3020  cs_real_t pipr[3],
3021  cs_real_t pjpr[3])
3022 {
3023  cs_real_3_t pir, pjr;
3024  cs_real_3_t recoi, recoj;
3025  cs_real_t testij, tesqck;
3026  int isou;
3027 
3028  cs_i_compute_quantities_vector(ircflp,
3029  diipf,
3030  djjpf,
3031  gradi,
3032  gradj,
3033  pi,
3034  pj,
3035  recoi,
3036  recoj,
3037  pip,
3038  pjp);
3039 
3040  cs_i_relax_c_val_vector(relaxp,
3041  pia,
3042  pja,
3043  recoi,
3044  recoj,
3045  pi,
3046  pj,
3047  pir,
3048  pjr,
3049  pipr,
3050  pjpr);
3051 
3052  /* Convection slope test is needed only when iconv >0 */
3053  if (iconvp > 0) {
3054  cs_slope_test_vector(pi,
3055  pj,
3056  i_dist,
3057  i_face_surf,
3058  i_face_normal,
3059  gradi,
3060  gradj,
3061  grdpai,
3062  grdpaj,
3063  i_massflux,
3064  &testij,
3065  &tesqck);
3066 
3067  for (isou = 0; isou < 3; isou++) {
3068  if (ischcp==1) {
3069 
3070  /* Centered
3071  --------*/
3072 
3073  cs_centered_f_val(weight,
3074  pip[isou],
3075  pjpr[isou],
3076  &pifrj[isou]);
3077  cs_centered_f_val(weight,
3078  pipr[isou],
3079  pjp[isou],
3080  &pifri[isou]);
3081  cs_centered_f_val(weight,
3082  pipr[isou],
3083  pjp[isou],
3084  &pjfri[isou]);
3085  cs_centered_f_val(weight,
3086  pip[isou],
3087  pjpr[isou],
3088  &pjfrj[isou]);
3089 
3090  } else {
3091 
3092  /* Second order
3093  ------------*/
3094 
3095  cs_solu_f_val(cell_ceni,
3096  i_face_cog,
3097  gradi[isou],
3098  pi[isou],
3099  &pifrj[isou]);
3100  cs_solu_f_val(cell_ceni,
3101  i_face_cog,
3102  gradi[isou],
3103  pir[isou],
3104  &pifri[isou]);
3105  cs_solu_f_val(cell_cenj,
3106  i_face_cog,
3107  gradj[isou],
3108  pj[isou],
3109  &pjfri[isou]);
3110  cs_solu_f_val(cell_cenj,
3111  i_face_cog,
3112  gradj[isou],
3113  pjr[isou],
3114  &pjfrj[isou]);
3115 
3116  }
3117 
3118  }
3119 
3120  /* Slope test: Pourcentage of upwind
3121  ----------------------------------*/
3122 
3123  if (tesqck <= 0. || testij <= 0.) {
3124  cs_blend_f_val_vector(blend_st,
3125  pi,
3126  pifrj);
3127  cs_blend_f_val_vector(blend_st,
3128  pir,
3129  pifri);
3130  cs_blend_f_val_vector(blend_st,
3131  pj,
3132  pjfri);
3133  cs_blend_f_val_vector(blend_st,
3134  pjr,
3135  pjfrj);
3136 
3137  *upwind_switch = true;
3138  }
3139 
3140 
3141  /* Blending
3142  --------*/
3143  cs_blend_f_val_vector(blencp,
3144  pi,
3145  pifrj);
3146  cs_blend_f_val_vector(blencp,
3147  pir,
3148  pifri);
3149  cs_blend_f_val_vector(blencp,
3150  pj,
3151  pjfri);
3152  cs_blend_f_val_vector(blencp,
3153  pjr,
3154  pjfrj);
3155 
3156  /* If iconv=0 p*fr* are useless */
3157  } else {
3158  for (isou = 0; isou < 3; isou++) {
3159  cs_upwind_f_val(pi[isou],
3160  &pifrj[isou]);
3161  cs_upwind_f_val(pir[isou],
3162  &pifri[isou]);
3163  cs_upwind_f_val(pj[isou],
3164  &pjfri[isou]);
3165  cs_upwind_f_val(pjr[isou],
3166  &pjfrj[isou]);
3167  }
3168  }
3169 
3170 }
3171 
3172 /*----------------------------------------------------------------------------*/
3214 /*----------------------------------------------------------------------------*/
3215 
3216 inline static void
3217 cs_i_cd_steady_slope_test_tensor(bool *upwind_switch,
3218  const int iconvp,
3219  const int ircflp,
3220  const int ischcp,
3221  const double relaxp,
3222  const double blencp,
3223  const double blend_st,
3224  const cs_real_t weight,
3225  const cs_real_t i_dist,
3226  const cs_real_t i_face_surf,
3227  const cs_real_3_t cell_ceni,
3228  const cs_real_3_t cell_cenj,
3229  const cs_real_3_t i_face_normal,
3230  const cs_real_3_t i_face_cog,
3231  const cs_real_3_t diipf,
3232  const cs_real_3_t djjpf,
3233  const cs_real_t i_massflux,
3234  const cs_real_63_t gradi,
3235  const cs_real_63_t gradj,
3236  const cs_real_63_t grdpai,
3237  const cs_real_63_t grdpaj,
3238  const cs_real_6_t pi,
3239  const cs_real_6_t pj,
3240  const cs_real_6_t pia,
3241  const cs_real_6_t pja,
3242  cs_real_t pifri[6],
3243  cs_real_t pifrj[6],
3244  cs_real_t pjfri[6],
3245  cs_real_t pjfrj[6],
3246  cs_real_t pip[6],
3247  cs_real_t pjp[6],
3248  cs_real_t pipr[6],
3249  cs_real_t pjpr[6])
3250 {
3251  cs_real_6_t pir, pjr;
3252  cs_real_6_t recoi, recoj;
3253  cs_real_t testij, tesqck;
3254  int isou;
3255 
3256  cs_i_compute_quantities_tensor(ircflp,
3257  diipf,
3258  djjpf,
3259  gradi,
3260  gradj,
3261  pi,
3262  pj,
3263  recoi,
3264  recoj,
3265  pip,
3266  pjp);
3267 
3268  cs_i_relax_c_val_tensor(relaxp,
3269  pia,
3270  pja,
3271  recoi,
3272  recoj,
3273  pi,
3274  pj,
3275  pir,
3276  pjr,
3277  pipr,
3278  pjpr);
3279 
3280  /* Convection slope test is needed only when iconv >0 */
3281  if (iconvp > 0) {
3282  cs_slope_test_tensor(pi,
3283  pj,
3284  i_dist,
3285  i_face_surf,
3286  i_face_normal,
3287  gradi,
3288  gradj,
3289  grdpai,
3290  grdpaj,
3291  i_massflux,
3292  &testij,
3293  &tesqck);
3294 
3295  for (isou = 0; isou < 6; isou++) {
3296  if (ischcp==1) {
3297 
3298  /* Centered
3299  --------*/
3300 
3301  cs_centered_f_val(weight,
3302  pip[isou],
3303  pjpr[isou],
3304  &pifrj[isou]);
3305  cs_centered_f_val(weight,
3306  pipr[isou],
3307  pjp[isou],
3308  &pifri[isou]);
3309  cs_centered_f_val(weight,
3310  pipr[isou],
3311  pjp[isou],
3312  &pjfri[isou]);
3313  cs_centered_f_val(weight,
3314  pip[isou],
3315  pjpr[isou],
3316  &pjfrj[isou]);
3317 
3318  } else {
3319 
3320  /* Second order
3321  ------------*/
3322 
3323  cs_solu_f_val(cell_ceni,
3324  i_face_cog,
3325  gradi[isou],
3326  pi[isou],
3327  &pifrj[isou]);
3328  cs_solu_f_val(cell_ceni,
3329  i_face_cog,
3330  gradi[isou],
3331  pir[isou],
3332  &pifri[isou]);
3333  cs_solu_f_val(cell_cenj,
3334  i_face_cog,
3335  gradj[isou],
3336  pj[isou],
3337  &pjfri[isou]);
3338  cs_solu_f_val(cell_cenj,
3339  i_face_cog,
3340  gradj[isou],
3341  pjr[isou],
3342  &pjfrj[isou]);
3343 
3344  }
3345 
3346  }
3347 
3348  /* Slope test: Pourcentage of upwind
3349  ----------------------------------*/
3350 
3351  if (tesqck <= 0. || testij <= 0.) {
3352 
3353  cs_blend_f_val_tensor(blend_st,
3354  pi,
3355  pifrj);
3356  cs_blend_f_val_tensor(blend_st,
3357  pir,
3358  pifri);
3359  cs_blend_f_val_tensor(blend_st,
3360  pj,
3361  pjfri);
3362  cs_blend_f_val_tensor(blend_st,
3363  pjr,
3364  pjfrj);
3365 
3366  *upwind_switch = true;
3367 
3368  }
3369 
3370 
3371  /* Blending
3372  --------*/
3373 
3374  cs_blend_f_val_tensor(blencp,
3375  pi,
3376  pifrj);
3377  cs_blend_f_val_tensor(blencp,
3378  pir,
3379  pifri);
3380  cs_blend_f_val_tensor(blencp,
3381  pj,
3382  pjfri);
3383  cs_blend_f_val_tensor(blencp,
3384  pjr,
3385  pjfrj);
3386 
3387  /* If iconv=0 p*fr* are useless */
3388  } else {
3389  for (isou = 0; isou < 6; isou++) {
3390  cs_upwind_f_val(pi[isou],
3391  &pifrj[isou]);
3392  cs_upwind_f_val(pir[isou],
3393  &pifri[isou]);
3394  cs_upwind_f_val(pj[isou],
3395  &pjfri[isou]);
3396  cs_upwind_f_val(pjr[isou],
3397  &pjfrj[isou]);
3398  }
3399  }
3400 
3401 }
3402 
3403 /*----------------------------------------------------------------------------*/
3440 /*----------------------------------------------------------------------------*/
3441 
3442 inline static void
3443 cs_i_cd_unsteady_slope_test(bool *upwind_switch,
3444  const int iconvp,
3445  const int ircflp,
3446  const int ischcp,
3447  const double blencp,
3448  const double blend_st,
3449  const cs_real_t weight,
3450  const cs_real_t i_dist,
3451  const cs_real_t i_face_surf,
3452  const cs_real_3_t cell_ceni,
3453  const cs_real_3_t cell_cenj,
3454  const cs_real_3_t i_face_normal,
3455  const cs_real_3_t i_face_cog,
3456  const cs_real_3_t diipf,
3457  const cs_real_3_t djjpf,
3458  const cs_real_t i_massflux,
3459  const cs_real_3_t gradi,
3460  const cs_real_3_t gradj,
3461  const cs_real_3_t gradupi,
3462  const cs_real_3_t gradupj,
3463  const cs_real_3_t gradsti,
3464  const cs_real_3_t gradstj,
3465  const cs_real_t pi,
3466  const cs_real_t pj,
3467  cs_real_t *pif,
3468  cs_real_t *pjf,
3469  cs_real_t *pip,
3470  cs_real_t *pjp)
3471 {
3472  CS_UNUSED(blend_st);
3473 
3474  cs_real_t recoi, recoj;
3475  cs_real_t testij, tesqck;
3476 
3477  *upwind_switch = false;
3478 
3479  cs_i_compute_quantities(ircflp,
3480  diipf,
3481  djjpf,
3482  gradi,
3483  gradj,
3484  pi,
3485  pj,
3486  &recoi,
3487  &recoj,
3488  pip,
3489  pjp);
3490 
3491  /* Convection slope test is needed only when iconv >0 */
3492  if (iconvp > 0) {
3493  cs_slope_test(pi,
3494  pj,
3495  i_dist,
3496  i_face_surf,
3497  i_face_normal,
3498  gradi,
3499  gradj,
3500  gradsti,
3501  gradstj,
3502  i_massflux,
3503  &testij,
3504  &tesqck);
3505 
3506  if (ischcp==1) {
3507 
3508  /* Centered
3509  --------*/
3510 
3511  cs_centered_f_val(weight,
3512  *pip,
3513  *pjp,
3514  pif);
3515  cs_centered_f_val(weight,
3516  *pip,
3517  *pjp,
3518  pjf);
3519 
3520  } else if (ischcp == 0) {
3521 
3522  /* Original SOLU
3523  --------------*/
3524 
3525  cs_solu_f_val(cell_ceni,
3526  i_face_cog,
3527  gradi,
3528  pi,
3529  pif);
3530  cs_solu_f_val(cell_cenj,
3531  i_face_cog,
3532  gradj,
3533  pj,
3534  pjf);
3535 
3536  } else {
3537 
3538  /* SOLU
3539  -----*/
3540 
3541  cs_solu_f_val(cell_ceni,
3542  i_face_cog,
3543  gradupi,
3544  pi,
3545  pif);
3546  cs_solu_f_val(cell_cenj,
3547  i_face_cog,
3548  gradupj,
3549  pj,
3550  pjf);
3551 
3552  }
3553 
3554  /* Slope test: Pourcentage of upwind
3555  ----------------------------------*/
3556 
3557  if (tesqck<=0. || testij<=0.) {
3558 
3559  cs_blend_f_val(blend_st,
3560  pi,
3561  pif);
3562  cs_blend_f_val(blend_st,
3563  pj,
3564  pjf);
3565 
3566  *upwind_switch = true;
3567 
3568  }
3569 
3570  /* Blending
3571  --------*/
3572 
3573  cs_blend_f_val(blencp,
3574  pi,
3575  pif);
3576  cs_blend_f_val(blencp,
3577  pj,
3578  pjf);
3579 
3580  /* If iconv=0 p*f are useless */
3581  } else {
3582  cs_upwind_f_val(pi,
3583  pif);
3584  cs_upwind_f_val(pj,
3585  pjf);
3586  }
3587 
3588 }
3589 
3590 /*----------------------------------------------------------------------------*/
3622 /*----------------------------------------------------------------------------*/
3623 
3624 inline static void
3625 cs_i_cd_unsteady_slope_test_vector_old(bool *upwind_switch,
3626  const int iconvp,
3627  const int ircflp,
3628  const int ischcp,
3629  const double blencp,
3630  const cs_real_t weight,
3631  const cs_real_t i_dist,
3632  const cs_real_t i_face_surf,
3633  const cs_real_3_t cell_ceni,
3634  const cs_real_3_t cell_cenj,
3635  const cs_real_3_t i_face_normal,
3636  const cs_real_3_t i_face_cog,
3637  const cs_real_3_t diipf,
3638  const cs_real_3_t djjpf,
3639  const cs_real_t i_massflux,
3640  const cs_real_33_t gradi,
3641  const cs_real_33_t gradj,
3642  const cs_real_33_t grdpai,
3643  const cs_real_33_t grdpaj,
3644  const cs_real_3_t pi,
3645  const cs_real_3_t pj,
3646  cs_real_t pif[3],
3647  cs_real_t pjf[3],
3648  cs_real_t pip[3],
3649  cs_real_t pjp[3])
3650 {
3651  cs_real_3_t recoi, recoj;
3652  cs_real_t distf, srfan;
3653  cs_real_3_t testij, tesqck;
3654  int isou;
3655 
3656  distf = i_dist;
3657  srfan = i_face_surf;
3658 
3659  cs_i_compute_quantities_vector(ircflp,
3660  diipf,
3661  djjpf,
3662  gradi,
3663  gradj,
3664  pi,
3665  pj,
3666  recoi,
3667  recoj,
3668  pip,
3669  pjp);
3670 
3671  /* Convection slope test is needed only when iconv >0 */
3672  if (iconvp > 0) {
3673  cs_slope_test_vector_old(pi,
3674  pj,
3675  distf,
3676  srfan,
3677  i_face_normal,
3678  gradi,
3679  gradj,
3680  grdpai,
3681  grdpaj,
3682  i_massflux,
3683  testij,
3684  tesqck);
3685 
3686  /* FIXME: slope test should be done for the vector and not component by
3687  * component. This is conserved for compatibility only. */
3688  for (isou = 0; isou < 3; isou++) {
3689  if (tesqck[isou]<=0. || testij[isou]<=0.) {
3690 
3691  /* Upwind
3692  --------*/
3693 
3694  cs_upwind_f_val(pi[isou],
3695  &pif[isou]);
3696  cs_upwind_f_val(pj[isou],
3697  &pjf[isou]);
3698 
3699  *upwind_switch = true;
3700 
3701  } else {
3702 
3703  if (ischcp==1) {
3704 
3705  /* Centered
3706  --------*/
3707 
3708  cs_centered_f_val(weight,
3709  pip[isou],
3710  pjp[isou],
3711  &pif[isou]);
3712  cs_centered_f_val(weight,
3713  pip[isou],
3714  pjp[isou],
3715  &pjf[isou]);
3716 
3717  } else {
3718 
3719  /* Second order
3720  ------------*/
3721 
3722  cs_solu_f_val(cell_ceni,
3723  i_face_cog,
3724  gradi[isou],
3725  pi[isou],
3726  &pif[isou]);
3727  cs_solu_f_val(cell_cenj,
3728  i_face_cog,
3729  gradj[isou],
3730  pj[isou],
3731  &pjf[isou]);
3732 
3733  }
3734  }
3735  }
3736 
3737  /* Blending
3738  --------*/
3739  cs_blend_f_val_vector(blencp,
3740  pi,
3741  pif);
3742  cs_blend_f_val_vector(blencp,
3743  pj,
3744  pjf);
3745 
3746  /* If iconv=0 p*f are useless */
3747  } else {
3748 
3749  for (isou = 0; isou < 3; isou++) {
3750  cs_upwind_f_val(pi[isou],
3751  &pif[isou]);
3752  cs_upwind_f_val(pj[isou],
3753  &pjf[isou]);
3754 
3755  }
3756  }
3757 }
3758 
3759 
3760 /*----------------------------------------------------------------------------*/
3795 /*----------------------------------------------------------------------------*/
3796 
3797 inline static void
3798 cs_i_cd_unsteady_slope_test_vector(bool *upwind_switch,
3799  const int iconvp,
3800  const int ircflp,
3801  const int ischcp,
3802  const double blencp,
3803  const double blend_st,
3804  const cs_real_t weight,
3805  const cs_real_t i_dist,
3806  const cs_real_t i_face_surf,
3807  const cs_real_3_t cell_ceni,
3808  const cs_real_3_t cell_cenj,
3809  const cs_real_3_t i_face_normal,
3810  const cs_real_3_t i_face_cog,
3811  const cs_real_3_t diipf,
3812  const cs_real_3_t djjpf,
3813  const cs_real_t i_massflux,
3814  const cs_real_33_t gradi,
3815  const cs_real_33_t gradj,
3816  const cs_real_33_t grdpai,
3817  const cs_real_33_t grdpaj,
3818  const cs_real_3_t pi,
3819  const cs_real_3_t pj,
3820  cs_real_t pif[3],
3821  cs_real_t pjf[3],
3822  cs_real_t pip[3],
3823  cs_real_t pjp[3])
3824 {
3825  cs_real_3_t recoi, recoj;
3826  cs_real_t testij, tesqck;
3827 
3828  cs_i_compute_quantities_vector(ircflp,
3829  diipf,
3830  djjpf,
3831  gradi,
3832  gradj,
3833  pi,
3834  pj,
3835  recoi,
3836  recoj,
3837  pip,
3838  pjp);
3839 
3840  /* Convection slope test is needed only when iconv >0 */
3841  if (iconvp > 0) {
3842  cs_slope_test_vector(pi,
3843  pj,
3844  i_dist,
3845  i_face_surf,
3846  i_face_normal,
3847  gradi,
3848  gradj,
3849  grdpai,
3850  grdpaj,
3851  i_massflux,
3852  &testij,
3853  &tesqck);
3854 
3855  for (int isou = 0; isou < 3; isou++) {
3856  if (ischcp == 1) {
3857 
3858  /* Centered
3859  --------*/
3860 
3861  cs_centered_f_val(weight,
3862  pip[isou],
3863  pjp[isou],
3864  &pif[isou]);
3865  cs_centered_f_val(weight,
3866  pip[isou],
3867  pjp[isou],
3868  &pjf[isou]);
3869 
3870  } else {
3871 
3872  /* Second order
3873  ------------*/
3874 
3875  cs_solu_f_val(cell_ceni,
3876  i_face_cog,
3877  gradi[isou],
3878  pi[isou],
3879  &pif[isou]);
3880  cs_solu_f_val(cell_cenj,
3881  i_face_cog,
3882  gradj[isou],
3883  pj[isou],
3884  &pjf[isou]);
3885 
3886  }
3887 
3888  }
3889 
3890  /* Slope test: Pourcentage of upwind
3891  ----------------------------------*/
3892 
3893  if (tesqck <= 0. || testij <= 0.) {
3894 
3895  cs_blend_f_val_vector(blend_st,
3896  pi,
3897  pif);
3898  cs_blend_f_val_vector(blend_st,
3899  pj,
3900  pjf);
3901 
3902  *upwind_switch = true;
3903 
3904  }
3905 
3906 
3907  /* Blending
3908  --------*/
3909  cs_blend_f_val_vector(blencp,
3910  pi,
3911  pif);
3912  cs_blend_f_val_vector(blencp,
3913  pj,
3914  pjf);
3915 
3916  /* If iconv=0 p*f are useless */
3917  } else {
3918 
3919  for (int isou = 0; isou < 3; isou++) {
3920  cs_upwind_f_val(pi[isou],
3921  &pif[isou]);
3922  cs_upwind_f_val(pj[isou],
3923  &pjf[isou]);
3924 
3925  }
3926  }
3927 
3928 }
3929 
3930 /*----------------------------------------------------------------------------*/
3965 /*----------------------------------------------------------------------------*/
3966 
3967 inline static void
3968 cs_i_cd_unsteady_slope_test_tensor(bool *upwind_switch,
3969  const int iconvp,
3970  const int ircflp,
3971  const int ischcp,
3972  const double blencp,
3973  const double blend_st,
3974  const cs_real_t weight,
3975  const cs_real_t i_dist,
3976  const cs_real_t i_face_surf,
3977  const cs_real_3_t cell_ceni,
3978  const cs_real_3_t cell_cenj,
3979  const cs_real_3_t i_face_normal,
3980  const cs_real_3_t i_face_cog,
3981  const cs_real_3_t diipf,
3982  const cs_real_3_t djjpf,
3983  const cs_real_t i_massflux,
3984  const cs_real_63_t gradi,
3985  const cs_real_63_t gradj,
3986  const cs_real_63_t grdpai,
3987  const cs_real_63_t grdpaj,
3988  const cs_real_6_t pi,
3989  const cs_real_6_t pj,
3990  cs_real_t pif[6],
3991  cs_real_t pjf[6],
3992  cs_real_t pip[6],
3993  cs_real_t pjp[6])
3994 {
3995  cs_real_6_t recoi, recoj;
3996  cs_real_t testij, tesqck;
3997  int isou;
3998 
3999  cs_i_compute_quantities_tensor(ircflp,
4000  diipf,
4001  djjpf,
4002  gradi,
4003  gradj,
4004  pi,
4005  pj,
4006  recoi,
4007  recoj,
4008  pip,
4009  pjp);
4010 
4011  /* Convection slope test is needed only when iconv >0 */
4012  if (iconvp > 0) {
4013  cs_slope_test_tensor(pi,
4014  pj,
4015  i_dist,
4016  i_face_surf,
4017  i_face_normal,
4018  gradi,
4019  gradj,
4020  grdpai,
4021  grdpaj,
4022  i_massflux,
4023  &testij,
4024  &tesqck);
4025 
4026  for (isou = 0; isou < 6; isou++) {
4027 
4028  if (ischcp==1) {
4029 
4030  /* Centered
4031  --------*/
4032 
4033  cs_centered_f_val(weight,
4034  pip[isou],
4035  pjp[isou],
4036  &pif[isou]);
4037  cs_centered_f_val(weight,
4038  pip[isou],
4039  pjp[isou],
4040  &pjf[isou]);
4041 
4042  } else {
4043 
4044  /* Second order
4045  ------------*/
4046 
4047  cs_solu_f_val(cell_ceni,
4048  i_face_cog,
4049  gradi[isou],
4050  pi[isou],
4051  &pif[isou]);
4052  cs_solu_f_val(cell_cenj,
4053  i_face_cog,
4054  gradj[isou],
4055  pj[isou],
4056  &pjf[isou]);
4057  }
4058 
4059  }
4060 
4061  /* Slope test activated: poucentage of upwind */
4062  if (tesqck <= 0. || testij <= 0.) {
4063 
4064  /* Upwind
4065  --------*/
4066 
4067  cs_blend_f_val_tensor(blend_st,
4068  pi,
4069  pif);
4070  cs_blend_f_val_tensor(blend_st,
4071  pj,
4072  pjf);
4073 
4074  *upwind_switch = true;
4075  }
4076 
4077 
4078  /* Blending
4079  --------*/
4080 
4081  cs_blend_f_val_tensor(blencp,
4082  pi,
4083  pif);
4084  cs_blend_f_val_tensor(blencp,
4085  pj,
4086  pjf);
4087 
4088  /* If iconv=0 p*fr* are useless */
4089  } else {
4090 
4091  for (isou = 0; isou < 6; isou++) {
4092  cs_upwind_f_val(pi[isou],
4093  &pif[isou]);
4094  cs_upwind_f_val(pj[isou],
4095  &pjf[isou]);
4096  }
4097  }
4098 }
4099 
4100 /*----------------------------------------------------------------------------*/
4109 /*----------------------------------------------------------------------------*/
4110 
4111 inline static void
4112 cs_b_compute_quantities(const cs_real_3_t diipb,
4113  const cs_real_3_t gradi,
4114  const int ircflp,
4115  cs_real_t *recoi)
4116 {
4117  *recoi = ircflp * ( gradi[0]*diipb[0]
4118  + gradi[1]*diipb[1]
4119  + gradi[2]*diipb[2]);
4120 }
4121 
4122 /*----------------------------------------------------------------------------*/
4131 /*----------------------------------------------------------------------------*/
4132 
4133 inline static void
4134 cs_b_compute_quantities_vector(const cs_real_3_t diipb,
4135  const cs_real_33_t gradi,
4136  const int ircflp,
4137  cs_real_t recoi[3])
4138 {
4139  for (int isou = 0; isou < 3; isou++) {
4140  recoi[isou] = ircflp * ( gradi[isou][0]*diipb[0]
4141  + gradi[isou][1]*diipb[1]
4142  + gradi[isou][2]*diipb[2]);
4143  }
4144 }
4145 
4146 /*----------------------------------------------------------------------------*/
4155 /*----------------------------------------------------------------------------*/
4156 
4157 inline static void
4158 cs_b_compute_quantities_tensor(const cs_real_3_t diipb,
4159  const cs_real_63_t gradi,
4160  const int ircflp,
4161  cs_real_t recoi[6])
4162 {
4163  for (int isou = 0; isou < 6; isou++) {
4164  recoi[isou] = ircflp * (gradi[isou][0]*diipb[0]
4165  + gradi[isou][1]*diipb[1]
4166  + gradi[isou][2]*diipb[2]);
4167  }
4168 }
4169 
4170 /*----------------------------------------------------------------------------*/
4181 /*----------------------------------------------------------------------------*/
4182 
4183 inline static void
4184 cs_b_relax_c_val(const double relaxp,
4185  const cs_real_t pi,
4186  const cs_real_t pia,
4187  const cs_real_t recoi,
4188  cs_real_t *pir,
4189  cs_real_t *pipr)
4190 {
4191  *pir = pi/relaxp - (1.-relaxp)/relaxp*pia;
4192  *pipr = *pir + recoi;
4193 }
4194 
4195 /*----------------------------------------------------------------------------*/
4206 /*----------------------------------------------------------------------------*/
4207 
4208 inline static void
4209 cs_b_relax_c_val_vector(const double relaxp,
4210  const cs_real_3_t pi,
4211  const cs_real_3_t pia,
4212  const cs_real_3_t recoi,
4213  cs_real_t pir[3],
4214  cs_real_t pipr[3])
4215 {
4216  for (int isou = 0; isou < 3; isou++) {
4217  pir[isou] = pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
4218  pipr[isou] = pir[isou] + recoi[isou];
4219  }
4220 }
4221 
4222 /*----------------------------------------------------------------------------*/
4233 /*----------------------------------------------------------------------------*/
4234 
4235 inline static void
4236 cs_b_relax_c_val_tensor(const double relaxp,
4237  const cs_real_6_t pi,
4238  const cs_real_6_t pia,
4239  const cs_real_6_t recoi,
4240  cs_real_t pir[6],
4241  cs_real_t pipr[6])
4242 {
4243  for (int isou = 0; isou < 6; isou++) {
4244  pir[isou] = pi[isou]/relaxp - (1.-relaxp)/relaxp*pia[isou];
4245  pipr[isou] = pir[isou] + recoi[isou];
4246  }
4247 }
4248 
4249 /*----------------------------------------------------------------------------*/
4273 /*----------------------------------------------------------------------------*/
4274 
4275 inline static void
4276 cs_b_imposed_conv_flux(int iconvp,
4277  cs_real_t thetap,
4278  int imasac,
4279  int inc,
4280  cs_int_t bc_type,
4281  int icvfli,
4282  cs_real_t pi,
4283  cs_real_t pir,
4284  cs_real_t pipr,
4285  cs_real_t coefap,
4286  cs_real_t coefbp,
4287  cs_real_t coface,
4288  cs_real_t cofbce,
4289  cs_real_t b_massflux,
4290  cs_real_t xcpp,
4291  cs_real_t *flux)
4292 {
4293  cs_real_t flui, fluj, pfac;
4294 
4295  /* Computed convective flux */
4296 
4297  if (icvfli == 0) {
4298 
4299  /* Remove decentering for coupled faces */
4300  if (bc_type == CS_COUPLED_FD) {
4301  flui = 0.0;
4302  fluj = b_massflux;
4303  } else {
4304  flui = 0.5*(b_massflux +fabs(b_massflux));
4305  fluj = 0.5*(b_massflux -fabs(b_massflux));
4306  }
4307 
4308  pfac = inc*coefap + coefbp*pipr;
4309  *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*pi));
4310 
4311  /* Imposed convective flux */
4312 
4313  } else {
4314 
4315  pfac = inc*coface + cofbce*pipr;
4316  *flux += iconvp*xcpp*(-imasac*(b_massflux*pi) + thetap*(pfac));
4317 
4318  }
4319 }
4320 
4321 /*----------------------------------------------------------------------------*/
4343 /*----------------------------------------------------------------------------*/
4344 
4345 inline static void
4346 cs_b_imposed_conv_flux_vector(int iconvp,
4347  cs_real_t thetap,
4348  int imasac,
4349  int inc,
4350  cs_int_t bc_type,
4351  int icvfli,
4352  const cs_real_t pi[restrict 3],
4353  const cs_real_t pir[restrict 3],
4354  const cs_real_t pipr[restrict 3],
4355  const cs_real_t coefap[restrict 3],
4356  const cs_real_t coefbp[restrict 3][3],
4357  const cs_real_t coface[restrict 3],
4358  const cs_real_t cofbce[restrict 3][3],
4359  cs_real_t b_massflux,
4360  cs_real_t flux[restrict 3])
4361 {
4362  cs_real_t flui, fluj, pfac;
4363 
4364  /* Computed convective flux */
4365 
4366  if (icvfli == 0) {
4367 
4368  /* Remove decentering for coupled faces */
4369  if (bc_type == CS_COUPLED_FD) {
4370  flui = 0.0;
4371  fluj = b_massflux;
4372  } else {
4373  flui = 0.5*(b_massflux +fabs(b_massflux));
4374  fluj = 0.5*(b_massflux -fabs(b_massflux));
4375  }
4376  for (int isou = 0; isou < 3; isou++) {
4377  pfac = inc*coefap[isou];
4378  for (int jsou = 0; jsou < 3; jsou++) {
4379  pfac += coefbp[isou][jsou]*pipr[jsou];
4380  }
4381  flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4382  - imasac*b_massflux*pi[isou]);
4383  }
4384 
4385  /* Imposed convective flux */
4386 
4387  } else {
4388 
4389  for (int isou = 0; isou < 3; isou++) {
4390  pfac = inc*coface[isou];
4391  for (int jsou = 0; jsou < 3; jsou++) {
4392  pfac += cofbce[isou][jsou]*pipr[jsou];
4393  }
4394  flux[isou] += iconvp*( thetap*pfac
4395  - imasac*b_massflux*pi[isou]);
4396  }
4397 
4398  }
4399 }
4400 
4401 /*----------------------------------------------------------------------------*/
4421 /*----------------------------------------------------------------------------*/
4422 
4423 inline static void
4424 cs_b_upwind_flux(const int iconvp,
4425  const cs_real_t thetap,
4426  const int imasac,
4427  const int inc,
4428  const int bc_type,
4429  const cs_real_t pi,
4430  const cs_real_t pir,
4431  const cs_real_t pipr,
4432  const cs_real_t coefap,
4433  const cs_real_t coefbp,
4434  const cs_real_t b_massflux,
4435  const cs_real_t xcpp,
4436  cs_real_t *flux)
4437 {
4438  cs_real_t flui, fluj, pfac;
4439 
4440  /* Remove decentering for coupled faces */
4441  if (bc_type == CS_COUPLED_FD) {
4442  flui = 0.0;
4443  fluj = b_massflux;
4444  } else {
4445  flui = 0.5*(b_massflux +fabs(b_massflux));
4446  fluj = 0.5*(b_massflux -fabs(b_massflux));
4447  }
4448 
4449  pfac = inc*coefap + coefbp*pipr;
4450  *flux += iconvp*xcpp*(thetap*(flui*pir + fluj*pfac) -imasac*( b_massflux*pi));
4451 }
4452 
4453 /*----------------------------------------------------------------------------*/
4473 /*----------------------------------------------------------------------------*/
4474 
4475 inline static void
4476 cs_b_upwind_flux_vector(const int iconvp,
4477  const cs_real_t thetap,
4478  const int imasac,
4479  const int inc,
4480  const int bc_type,
4481  const cs_real_3_t pi,
4482  const cs_real_3_t pir,
4483  const cs_real_3_t pipr,
4484  const cs_real_3_t coefa,
4485  const cs_real_33_t coefb,
4486  const cs_real_t b_massflux,
4487  cs_real_t flux[3])
4488 {
4489  cs_real_t flui, fluj, pfac;
4490 
4491  /* Remove decentering for coupled faces */
4492  if (bc_type == CS_COUPLED_FD) {
4493  flui = 0.0;
4494  fluj = b_massflux;
4495  } else {
4496  flui = 0.5*(b_massflux +fabs(b_massflux));
4497  fluj = 0.5*(b_massflux -fabs(b_massflux));
4498  }
4499  for (int isou = 0; isou < 3; isou++) {
4500  pfac = inc*coefa[isou];
4501  for (int jsou = 0; jsou < 3; jsou++) {
4502  pfac += coefb[isou][jsou]*pipr[jsou];
4503  }
4504  flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4505  - imasac*b_massflux*pi[isou]);
4506  }
4507 }
4508 
4509 /*----------------------------------------------------------------------------*/
4529 /*----------------------------------------------------------------------------*/
4530 
4531 inline static void
4532 cs_b_upwind_flux_tensor(const int iconvp,
4533  const cs_real_t thetap,
4534  const int imasac,
4535  const int inc,
4536  const int bc_type,
4537  const cs_real_6_t pi,
4538  const cs_real_6_t pir,
4539  const cs_real_6_t pipr,
4540  const cs_real_6_t coefa,
4541  const cs_real_66_t coefb,
4542  const cs_real_t b_massflux,
4543  cs_real_t flux[6])
4544 {
4545  cs_real_t flui, fluj, pfac;
4546 
4547  /* Remove decentering for coupled faces */
4548  if (bc_type == CS_COUPLED_FD) {
4549  flui = 0.0;
4550  fluj = b_massflux;
4551  } else {
4552  flui = 0.5*(b_massflux +fabs(b_massflux));
4553  fluj = 0.5*(b_massflux -fabs(b_massflux));
4554  }
4555  for (int isou = 0; isou < 6; isou++) {
4556  pfac = inc*coefa[isou];
4557  for (int jsou = 0; jsou < 6; jsou++) {
4558  pfac += coefb[isou][jsou]*pipr[jsou];
4559  }
4560  flux[isou] += iconvp*( thetap*(flui*pir[isou] + fluj*pfac)
4561  - imasac*b_massflux*pi[isou]);
4562  }
4563 }
4564 
4565 /*----------------------------------------------------------------------------*/
4578 /*----------------------------------------------------------------------------*/
4579 
4580 inline static void
4581 cs_b_diff_flux(const int idiffp,
4582  const cs_real_t thetap,
4583  const int inc,
4584  const cs_real_t pipr,
4585  const cs_real_t cofafp,
4586  const cs_real_t cofbfp,
4587  const cs_real_t b_visc,
4588  cs_real_t *flux)
4589 {
4590  cs_real_t pfacd = inc*cofafp + cofbfp*pipr;
4591  *flux += idiffp*thetap*b_visc*pfacd;
4592 }
4593 
4594 /*----------------------------------------------------------------------------*/
4607 /*----------------------------------------------------------------------------*/
4608 
4609 inline static void
4610 cs_b_diff_flux_vector(const int idiffp,
4611  const cs_real_t thetap,
4612  const int inc,
4613  const cs_real_3_t pipr,
4614  const cs_real_3_t cofaf,
4615  const cs_real_33_t cofbf,
4616  const cs_real_t b_visc,
4617  cs_real_t flux[3])
4618 {
4619  cs_real_t pfacd ;
4620  for (int isou = 0; isou < 3; isou++) {
4621  pfacd = inc*cofaf[isou];
4622  for (int jsou = 0; jsou < 3; jsou++) {
4623  pfacd += cofbf[isou][jsou]*pipr[jsou];
4624  }
4625  flux[isou] += idiffp*thetap*b_visc*pfacd;
4626  }
4627 }
4628 
4629 /*----------------------------------------------------------------------------*/
4642 /*----------------------------------------------------------------------------*/
4643 
4644 inline static void
4645 cs_b_diff_flux_tensor(const int idiffp,
4646  const cs_real_t thetap,
4647  const int inc,
4648  const cs_real_6_t pipr,
4649  const cs_real_6_t cofaf,
4650  const cs_real_66_t cofbf,
4651  const cs_real_t b_visc,
4652  cs_real_t flux[6])
4653 {
4654  cs_real_t pfacd ;
4655  for (int isou = 0; isou < 6; isou++) {
4656  pfacd = inc*cofaf[isou];
4657  for (int jsou = 0; jsou < 6; jsou++) {
4658  pfacd += cofbf[isou][jsou]*pipr[jsou];
4659  }
4660  flux[isou] += idiffp*thetap*b_visc*pfacd;
4661  }
4662 }
4663 
4664 /*----------------------------------------------------------------------------*/
4678 /*----------------------------------------------------------------------------*/
4679 
4680 inline static void
4681 cs_b_cd_steady(const int ircflp,
4682  const double relaxp,
4683  const cs_real_3_t diipb,
4684  const cs_real_3_t gradi,
4685  const cs_real_t pi,
4686  const cs_real_t pia,
4687  cs_real_t *pir,
4688  cs_real_t *pipr)
4689 {
4690  cs_real_t recoi;
4691 
4692  cs_b_compute_quantities(diipb,
4693  gradi,
4694  ircflp,
4695  &recoi);
4696 
4697  cs_b_relax_c_val(relaxp,
4698  pi,
4699  pia,
4700  recoi,
4701  pir,
4702  pipr);
4703 }
4704 
4705 /*----------------------------------------------------------------------------*/
4719 /*----------------------------------------------------------------------------*/
4720 
4721 inline static void
4722 cs_b_cd_steady_vector(const int ircflp,
4723  const double relaxp,
4724  const cs_real_3_t diipb,
4725  const cs_real_33_t gradi,
4726  const cs_real_3_t pi,
4727  const cs_real_3_t pia,
4728  cs_real_t pir[3],
4729  cs_real_t pipr[3])
4730 {
4731  cs_real_3_t recoi;
4732 
4733  cs_b_compute_quantities_vector(diipb,
4734  gradi,
4735  ircflp,
4736  recoi);
4737 
4738  cs_b_relax_c_val_vector(relaxp,
4739  pi,
4740  pia,
4741  recoi,
4742  pir,
4743  pipr);
4744 }
4745 
4746 /*----------------------------------------------------------------------------*/
4760 /*----------------------------------------------------------------------------*/
4761 
4762 inline static void
4763 cs_b_cd_steady_tensor(const int ircflp,
4764  const double relaxp,
4765  const cs_real_3_t diipb,
4766  const cs_real_63_t gradi,
4767  const cs_real_6_t pi,
4768  const cs_real_6_t pia,
4769  cs_real_t pir[6],
4770  cs_real_t pipr[6])
4771 {
4772  cs_real_6_t recoi;
4773 
4774  cs_b_compute_quantities_tensor(diipb,
4775  gradi,
4776  ircflp,
4777  recoi);
4778 
4779  cs_b_relax_c_val_tensor(relaxp,
4780  pi,
4781  pia,
4782  recoi,
4783  pir,
4784  pipr);
4785 }
4786 
4787 /*----------------------------------------------------------------------------*/
4798 /*----------------------------------------------------------------------------*/
4799 
4800 inline static void
4801 cs_b_cd_unsteady(const int ircflp,
4802  const cs_real_3_t diipb,
4803  const cs_real_3_t gradi,
4804  const cs_real_t pi,
4805  cs_real_t *pip)
4806 {
4807  cs_real_t recoi;
4808 
4809  cs_b_compute_quantities(diipb,
4810  gradi,
4811  ircflp,
4812  &recoi);
4813 
4814  *pip = pi + recoi;
4815 }
4816 
4817 /*----------------------------------------------------------------------------*/
4828 /*----------------------------------------------------------------------------*/
4829 
4830 inline static void
4831 cs_b_cd_unsteady_vector(const int ircflp,
4832  const cs_real_3_t diipb,
4833  const cs_real_33_t gradi,
4834  const cs_real_3_t pi,
4835  cs_real_t pip[3])
4836 {
4837  cs_real_3_t recoi;
4838 
4839  cs_b_compute_quantities_vector(diipb,
4840  gradi,
4841  ircflp,
4842  recoi);
4843 
4844  for (int isou = 0; isou < 3; isou++)
4845  pip[isou] = pi[isou] + recoi[isou];
4846 }
4847 
4848 /*----------------------------------------------------------------------------*/
4859 /*----------------------------------------------------------------------------*/
4860 
4861 inline static void
4862 cs_b_cd_unsteady_tensor(const int ircflp,
4863  const cs_real_3_t diipb,
4864  const cs_real_63_t gradi,
4865  const cs_real_6_t pi,
4866  cs_real_t pip[6])
4867 {
4868  cs_real_6_t recoi;
4869 
4870  cs_b_compute_quantities_tensor(diipb,
4871  gradi,
4872  ircflp,
4873  recoi);
4874 
4875  for(int isou = 0; isou< 6; isou++)
4876  pip[isou] = pi[isou] + recoi[isou];
4877 }
4878 
4879 /*----------------------------------------------------------------------------*/
4890 /*----------------------------------------------------------------------------*/
4891 
4892 inline static void
4893 cs_b_diff_flux_coupling(int idiffp,
4894  cs_real_t pi,
4895  cs_real_t pj,
4896  cs_real_t b_visc,
4897  cs_real_t *fluxi)
4898 {
4899  *fluxi += idiffp*b_visc*(pi - pj);
4900 }
4901 
4902 /*----------------------------------------------------------------------------*/
4913 /*----------------------------------------------------------------------------*/
4914 
4915 inline static void
4916 cs_b_diff_flux_coupling_vector(int idiffp,
4917  const cs_real_t pi[3],
4918  const cs_real_t pj[3],
4919  cs_real_t b_visc,
4920  cs_real_t fluxi[3])
4921 {
4922  for (int k = 0; k < 3; k++)
4923  fluxi[k] += idiffp*b_visc*(pi[k] - pj[k]);
4924 }
4925 
4926 
4927 /*============================================================================
4928  * Public function prototypes for Fortran API
4929  *============================================================================*/
4930 
4931 /*----------------------------------------------------------------------------
4932  * Wrapper to cs_face_diffusion_potential
4933  *----------------------------------------------------------------------------*/
4934 
4935 void CS_PROCF (itrmas, ITRMAS)
4936 (
4937  const cs_int_t *const f_id,
4938  const cs_int_t *const init,
4939  const cs_int_t *const inc,
4940  const cs_int_t *const imrgra,
4941  const cs_int_t *const iccocg,
4942  const cs_int_t *const nswrgp,
4943  const cs_int_t *const imligp,
4944  const cs_int_t *const iphydp,
4945  const cs_int_t *const iwgrp,
4946  const cs_int_t *const iwarnp,
4947  const cs_real_t *const epsrgp,
4948  const cs_real_t *const climgp,
4949  const cs_real_t *const extrap,
4950  cs_real_3_t frcxt[],
4951  cs_real_t pvar[],
4952  const cs_real_t coefap[],
4953  const cs_real_t coefbp[],
4954  const cs_real_t cofafp[],
4955  const cs_real_t cofbfp[],
4956  const cs_real_t i_visc[],
4957  const cs_real_t b_visc[],
4958  cs_real_t visel[],
4959  cs_real_t i_massflux[],
4960  cs_real_t b_massflux[]
4961 );
4962 
4963 /*----------------------------------------------------------------------------
4964  * Wrapper to cs_face_anisotropic_diffusion_potential
4965  *----------------------------------------------------------------------------*/
4966 
4967 void CS_PROCF (itrmav, ITRMAV)
4968 (
4969  const cs_int_t *const f_id,
4970  const cs_int_t *const init,
4971  const cs_int_t *const inc,
4972  const cs_int_t *const imrgra,
4973  const cs_int_t *const iccocg,
4974  const cs_int_t *const nswrgp,
4975  const cs_int_t *const imligp,
4976  const cs_int_t *const ircflp,
4977  const cs_int_t *const iphydp,
4978  const cs_int_t *const iwgrp,
4979  const cs_int_t *const iwarnp,
4980  const cs_real_t *const epsrgp,
4981  const cs_real_t *const climgp,
4982  const cs_real_t *const extrap,
4983  cs_real_3_t frcxt[],
4984  cs_real_t pvar[],
4985  const cs_real_t coefap[],
4986  const cs_real_t coefbp[],
4987  const cs_real_t cofafp[],
4988  const cs_real_t cofbfp[],
4989  const cs_real_t i_visc[],
4990  const cs_real_t b_visc[],
4991  cs_real_6_t viscel[],
4992  const cs_real_2_t weighf[],
4993  const cs_real_t weighb[],
4994  cs_real_t i_massflux[],
4995  cs_real_t b_massflux[]
4996 );
4997 
4998 /*----------------------------------------------------------------------------
4999  * Wrapper to cs_diffusion_potential
5000  *----------------------------------------------------------------------------*/
5001 
5002 void CS_PROCF (itrgrp, ITRGRP)
5003 (
5004  const cs_int_t *const f_id,
5005  const cs_int_t *const init,
5006  const cs_int_t *const inc,
5007  const cs_int_t *const imrgra,
5008  const cs_int_t *const iccocg,
5009  const cs_int_t *const nswrgp,
5010  const cs_int_t *const imligp,
5011  const cs_int_t *const iphydp,
5012  const cs_int_t *const iwarnp,
5013  const cs_real_t *const epsrgp,
5014  const cs_real_t *const climgp,
5015  const cs_real_t *const extrap,
5016  cs_real_3_t frcxt[],
5017  cs_real_t pvar[],
5018  const cs_real_t coefap[],
5019  const cs_real_t coefbp[],
5020  const cs_real_t cofafp[],
5021  const cs_real_t cofbfp[],
5022  const cs_real_t i_visc[],
5023  const cs_real_t b_visc[],
5024  cs_real_t visel[],
5025  cs_real_t diverg[]
5026 );
5027 
5028 /*----------------------------------------------------------------------------
5029  * Wrapper to cs_anisotropic_diffusion_potential
5030  *----------------------------------------------------------------------------*/
5031 
5032 void CS_PROCF (itrgrv, ITRGRV)
5033 (
5034  const cs_int_t *const f_id,
5035  const cs_int_t *const init,
5036  const cs_int_t *const inc,
5037  const cs_int_t *const imrgra,
5038  const cs_int_t *const iccocg,
5039  const cs_int_t *const nswrgp,
5040  const cs_int_t *const imligp,
5041  const cs_int_t *const ircflp,
5042  const cs_int_t *const iphydp,
5043  const cs_int_t *const iwarnp,
5044  const cs_real_t *const epsrgp,
5045  const cs_real_t *const climgp,
5046  const cs_real_t *const extrap,
5047  cs_real_3_t frcxt[],
5048  cs_real_t pvar[],
5049  const cs_real_t coefap[],
5050  const cs_real_t coefbp[],
5051  const cs_real_t cofafp[],
5052  const cs_real_t cofbfp[],
5053  const cs_real_t i_visc[],
5054  const cs_real_t b_visc[],
5055  cs_real_6_t viscel[],
5056  const cs_real_2_t weighf[],
5057  const cs_real_t weighb[],
5058  cs_real_t diverg[]
5059 );
5060 
5061 /*=============================================================================
5062  * Public function prototypes
5063  *============================================================================*/
5064 
5065 /*----------------------------------------------------------------------------*/
5084 /*----------------------------------------------------------------------------*/
5085 
5086 void
5087 cs_slope_test_gradient(int f_id,
5088  int inc,
5089  cs_halo_type_t halo_type,
5090  const cs_real_3_t *grad,
5091  cs_real_3_t *grdpa,
5092  const cs_real_t *pvar,
5093  const cs_real_t *coefap,
5094  const cs_real_t *coefbp,
5095  const cs_real_t *i_massflux);
5096 
5097 /*----------------------------------------------------------------------------*/
5113 /*----------------------------------------------------------------------------*/
5114 
5115 void
5116 cs_upwind_gradient(const int f_id,
5117  const int inc,
5118  const cs_halo_type_t halo_type,
5119  const cs_real_t coefap[],
5120  const cs_real_t coefbp[],
5121  const cs_real_t i_massflux[],
5122  const cs_real_t b_massflux[],
5123  const cs_real_t *restrict pvar,
5124  cs_real_3_t *restrict grdpa);
5125 
5126 /*----------------------------------------------------------------------------*/
5144 /*----------------------------------------------------------------------------*/
5145 
5146 void
5147 cs_slope_test_gradient_vector(const int inc,
5148  const cs_halo_type_t halo_type,
5149  const cs_real_33_t *grad,
5150  cs_real_33_t *grdpa,
5151  const cs_real_3_t *pvar,
5152  const cs_real_3_t *coefa,
5153  const cs_real_33_t *coefb,
5154  const cs_real_t *i_massflux);
5155 
5156 /*----------------------------------------------------------------------------*/
5174 /*----------------------------------------------------------------------------*/
5175 
5176 void
5177 cs_slope_test_gradient_tensor(const int inc,
5178  const cs_halo_type_t halo_type,
5179  const cs_real_63_t *grad,
5180  cs_real_63_t *grdpa,
5181  const cs_real_6_t *pvar,
5182  const cs_real_6_t *coefa,
5183  const cs_real_66_t *coefb,
5184  const cs_real_t *i_massflux);
5185 
5186 /*----------------------------------------------------------------------------*/
5195 /*----------------------------------------------------------------------------*/
5196 
5197 void
5198 cs_max_limiter_building(int f_id,
5199  int inc,
5200  const cs_real_t rovsdt[]);
5201 
5202 /*----------------------------------------------------------------------------*/
5254 /*----------------------------------------------------------------------------*/
5255 
5256 void
5257 cs_convection_diffusion_scalar(int idtvar,
5258  int f_id,
5259  const cs_var_cal_opt_t var_cal_opt,
5260  int icvflb,
5261  int inc,
5262  int iccocg,
5263  int imasac,
5264  cs_real_t *restrict pvar,
5265  const cs_real_t *restrict pvara,
5266  const cs_int_t icvfli[],
5267  const cs_real_t coefap[],
5268  const cs_real_t coefbp[],
5269  const cs_real_t cofafp[],
5270  const cs_real_t cofbfp[],
5271  const cs_real_t i_massflux[],
5272  const cs_real_t b_massflux[],
5273  const cs_real_t i_visc[],
5274  const cs_real_t b_visc[],
5275  cs_real_t *restrict rhs);
5276 
5277 /*----------------------------------------------------------------------------*/
5337 /*----------------------------------------------------------------------------*/
5338 
5339 void
5340 cs_convection_diffusion_vector(int idtvar,
5341  int f_id,
5342  const cs_var_cal_opt_t var_cal_opt,
5343  int icvflb,
5344  int inc,
5345  int ivisep,
5346  int imasac,
5347  cs_real_3_t *restrict pvar,
5348  const cs_real_3_t *restrict pvara,
5349  const cs_int_t icvfli[],
5350  const cs_real_3_t coefav[],
5351  const cs_real_33_t coefbv[],
5352  const cs_real_3_t cofafv[],
5353  const cs_real_33_t cofbfv[],
5354  const cs_real_t i_massflux[],
5355  const cs_real_t b_massflux[],
5356  const cs_real_t i_visc[],
5357  const cs_real_t b_visc[],
5358  const cs_real_t secvif[],
5359  const cs_real_t secvib[],
5360  cs_real_3_t *restrict rhs);
5361 
5362 /*----------------------------------------------------------------------------*/
5407 /*----------------------------------------------------------------------------*/
5408 
5409 void
5410 cs_convection_diffusion_tensor(int idtvar,
5411  int f_id,
5412  const cs_var_cal_opt_t var_cal_opt,
5413  int icvflb,
5414  int inc,
5415  int imasac,
5416  cs_real_6_t *restrict pvar,
5417  const cs_real_6_t *restrict pvara,
5418  const cs_real_6_t coefa[],
5419  const cs_real_66_t coefb[],
5420  const cs_real_6_t cofaf[],
5421  const cs_real_66_t cofbf[],
5422  const cs_real_t i_massflux[],
5423  const cs_real_t b_massflux[],
5424  const cs_real_t i_visc[],
5425  const cs_real_t b_visc[],
5426  cs_real_6_t *restrict rhs);
5427 
5428 /*----------------------------------------------------------------------------*/
5474 /*----------------------------------------------------------------------------*/
5475 
5476 void
5477 cs_convection_diffusion_thermal(int idtvar,
5478  int f_id,
5479  const cs_var_cal_opt_t var_cal_opt,
5480  int inc,
5481  int iccocg,
5482  int imasac,
5483  cs_real_t *restrict pvar,
5484  const cs_real_t *restrict pvara,
5485  const cs_real_t coefap[],
5486  const cs_real_t coefbp[],
5487  const cs_real_t cofafp[],
5488  const cs_real_t cofbfp[],
5489  const cs_real_t i_massflux[],
5490  const cs_real_t b_massflux[],
5491  const cs_real_t i_visc[],
5492  const cs_real_t b_visc[],
5493  const cs_real_t xcpp[],
5494  cs_real_t *restrict rhs);
5495 
5496 /*----------------------------------------------------------------------------*/
5544 /*----------------------------------------------------------------------------*/
5545 
5546 void
5547 cs_anisotropic_diffusion_scalar(int idtvar,
5548  int f_id,
5549  const cs_var_cal_opt_t var_cal_opt,
5550  int inc,
5551  int iccocg,
5552  cs_real_t *restrict pvar,
5553  const cs_real_t *restrict pvara,
5554  const cs_real_t coefap[],
5555  const cs_real_t coefbp[],
5556  const cs_real_t cofafp[],
5557  const cs_real_t cofbfp[],
5558  const cs_real_t i_visc[],
5559  const cs_real_t b_visc[],
5560  cs_real_6_t *restrict viscel,
5561  const cs_real_2_t weighf[],
5562  const cs_real_t weighb[],
5563  cs_real_t *restrict rhs);
5564 
5565 /*-----------------------------------------------------------------------------*/
5615 /*----------------------------------------------------------------------------*/
5616 
5617 void
5618 cs_anisotropic_left_diffusion_vector(int idtvar,
5619  int f_id,
5620  const cs_var_cal_opt_t var_cal_opt,
5621  int inc,
5622  int ivisep,
5623  cs_real_3_t *restrict pvar,
5624  const cs_real_3_t *restrict pvara,
5625  const cs_real_3_t coefav[],
5626  const cs_real_33_t coefbv[],
5627  const cs_real_3_t cofafv[],
5628  const cs_real_33_t cofbfv[],
5629  const cs_real_33_t i_visc[],
5630  const cs_real_t b_visc[],
5631  const cs_real_t secvif[],
5632  cs_real_3_t *restrict rhs);
5633 
5634 /*-----------------------------------------------------------------------------*/
5680 /*----------------------------------------------------------------------------*/
5681 
5682 void
5683 cs_anisotropic_right_diffusion_vector(int idtvar,
5684  int f_id,
5685  const cs_var_cal_opt_t var_cal_opt,
5686  int inc,
5687  cs_real_3_t *restrict pvar,
5688  const cs_real_3_t *restrict pvara,
5689  const cs_real_3_t coefav[],
5690  const cs_real_33_t coefbv[],
5691  const cs_real_3_t cofafv[],
5692  const cs_real_33_t cofbfv[],
5693  const cs_real_t i_visc[],
5694  const cs_real_t b_visc[],
5695  const cs_real_t secvif[],
5696  cs_real_6_t *restrict viscel,
5697  const cs_real_2_t weighf[],
5698  const cs_real_t weighb[],
5699  cs_real_3_t *restrict rhs);
5700 
5701 /*----------------------------------------------------------------------------*/
5745 /*----------------------------------------------------------------------------*/
5746 
5747 void
5748 cs_anisotropic_diffusion_tensor(int idtvar,
5749  int f_id,
5750  const cs_var_cal_opt_t var_cal_opt,
5751  int inc,
5752  cs_real_6_t *restrict pvar,
5753  const cs_real_6_t *restrict pvara,
5754  const cs_real_6_t coefa[],
5755  const cs_real_66_t coefb[],
5756  const cs_real_6_t cofaf[],
5757  const cs_real_66_t cofbf[],
5758  const cs_real_t i_visc[],
5759  const cs_real_t b_visc[],
5760  cs_real_6_t *restrict viscel,
5761  const cs_real_2_t weighf[],
5762  const cs_real_t weighb[],
5763  cs_real_6_t *restrict rhs);
5764 
5765 /*----------------------------------------------------------------------------*/
5825 /*----------------------------------------------------------------------------*/
5826 
5827 void
5828 cs_face_diffusion_potential(const int f_id,
5829  const cs_mesh_t *m,
5830  cs_mesh_quantities_t *fvq,
5831  int init,
5832  int inc,
5833  int imrgra,
5834  int iccocg,
5835  int nswrgp,
5836  int imligp,
5837  int iphydp,
5838  int iwgrp,
5839  int iwarnp,
5840  double epsrgp,
5841  double climgp,
5842  double extrap,
5843  cs_real_3_t *restrict frcxt,
5844  cs_real_t *restrict pvar,
5845  const cs_real_t coefap[],
5846  const cs_real_t coefbp[],
5847  const cs_real_t cofafp[],
5848  const cs_real_t cofbfp[],
5849  const cs_real_t i_visc[],
5850  const cs_real_t b_visc[],
5851  cs_real_t *restrict visel,
5852  cs_real_t *restrict i_massflux,
5853  cs_real_t *restrict b_massflux);
5854 
5855 /*----------------------------------------------------------------------------*/
5926 /*----------------------------------------------------------------------------*/
5927 
5928 void
5929 cs_face_anisotropic_diffusion_potential(const int f_id,
5930  const cs_mesh_t *m,
5931  cs_mesh_quantities_t *fvq,
5932  int init,
5933  int inc,
5934  int imrgra,
5935  int iccocg,
5936  int nswrgp,
5937  int imligp,
5938  int ircflp,
5939  int iphydp,
5940  int iwgrp,
5941  int iwarnp,
5942  double epsrgp,
5943  double climgp,
5944  double extrap,
5945  cs_real_3_t *restrict frcxt,
5946  cs_real_t *restrict pvar,
5947  const cs_real_t coefap[],
5948  const cs_real_t coefbp[],
5949  const cs_real_t cofafp[],
5950  const cs_real_t cofbfp[],
5951  const cs_real_t i_visc[],
5952  const cs_real_t b_visc[],
5953  cs_real_6_t *restrict viscel,
5954  const cs_real_2_t weighf[],
5955  const cs_real_t weighb[],
5956  cs_real_t *restrict i_massflux,
5957  cs_real_t *restrict b_massflux);
5958 
5959 /*----------------------------------------------------------------------------*/
6015 /*----------------------------------------------------------------------------*/
6016 
6017 void
6018 cs_diffusion_potential(const int f_id,
6019  const cs_mesh_t *m,
6020  cs_mesh_quantities_t *fvq,
6021  int init,
6022  int inc,
6023  int imrgra,
6024  int iccocg,
6025  int nswrgp,
6026  int imligp,
6027  int iphydp,
6028  int iwarnp,
6029  double epsrgp,
6030  double climgp,
6031  double extrap,
6032  cs_real_3_t *restrict frcxt,
6033  cs_real_t *restrict pvar,
6034  const cs_real_t coefap[],
6035  const cs_real_t coefbp[],
6036  const cs_real_t cofafp[],
6037  const cs_real_t cofbfp[],
6038  const cs_real_t i_visc[],
6039  const cs_real_t b_visc[],
6040  cs_real_t visel[],
6041  cs_real_t *restrict diverg);
6042 
6043 /*----------------------------------------------------------------------------*/
6112 /*----------------------------------------------------------------------------*/
6113 
6114 void
6115 cs_anisotropic_diffusion_potential(const int f_id,
6116  const cs_mesh_t *m,
6117  cs_mesh_quantities_t *fvq,
6118  int init,
6119  int inc,
6120  int imrgra,
6121  int iccocg,
6122  int nswrgp,
6123  int imligp,
6124  int ircflp,
6125  int iphydp,
6126  int iwarnp,
6127  double epsrgp,
6128  double climgp,
6129  double extrap,
6130  cs_real_3_t *restrict frcxt,
6131  cs_real_t *restrict pvar,
6132  const cs_real_t coefap[],
6133  const cs_real_t coefbp[],
6134  const cs_real_t cofafp[],
6135  const cs_real_t cofbfp[],
6136  const cs_real_t i_visc[],
6137  const cs_real_t b_visc[],
6138  cs_real_6_t *restrict viscel,
6139  const cs_real_2_t weighf[],
6140  const cs_real_t weighb[],
6141  cs_real_t *restrict diverg);
6142 
6143 /*----------------------------------------------------------------------------*/
6144 
6145 END_C_DECLS
6146 
6147 #endif /* __CS_CONVECTION_DIFFUSION_H__ */
cs_b_cd_steady
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:4681
k
Definition: cs_field_pointer.h:70
cs_upwind_f_val_vector
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:681
mesh::diipb
double precision, dimension(:,:), pointer diipb
Definition: mesh.f90:212
restrict
#define restrict
Definition: cs_defs.h:122
cs_math_3_dot_product
static cs_real_t cs_math_3_dot_product(const cs_real_t u[3], const cs_real_t v[3])
Compute the dot product of two vectors of 3 real values.
Definition: cs_math.h:254
cs_slope_test_vector_old
static void cs_slope_test_vector_old(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])
DEPRECATED Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion.h:269
cs_b_imposed_conv_flux_vector
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:4346
cs_b_diff_flux_tensor
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:4645
cs_real_2_t
cs_real_t cs_real_2_t[2]
vector of 2 floating-point values
Definition: cs_defs.h:309
cs_base.h
cs_real_6_t
cs_real_t cs_real_6_t[6]
vector of 6 floating-point values
Definition: cs_defs.h:312
cs_i_cd_steady_vector
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 diipf, const cs_real_3_t djjpf, 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:1776
cs_anisotropic_diffusion_tensor
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:8959
cs_i_cd_steady
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 diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t gradupi, const cs_real_3_t gradupj, const cs_real_t pi, const cs_real_t pj, 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:1595
cs_i_cd_steady_upwind_tensor
static void cs_i_cd_steady_upwind_tensor(const int ircflp, const cs_real_t relaxp, const cs_real_3_t diipf, const cs_real_3_t djjpf, 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:1351
cs_centered_f_val_tensor
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:758
cs_nvd_type_t
cs_nvd_type_t
Definition: cs_convection_diffusion.h:85
cs_anisotropic_diffusion_scalar
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:7016
cfpoin::icvfli
integer, dimension(:), allocatable icvfli
Definition: cfpoin.f90:48
cs_b_cd_steady_vector
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:4722
cs_i_cd_unsteady_slope_test_vector_old
static void cs_i_cd_unsteady_slope_test_vector_old(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 diipf, const cs_real_3_t djjpf, 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])
DEPRECATED Handle preparation of internal face values for the fluxes computation in case of a unstead...
Definition: cs_convection_diffusion.h:3625
cs_i_cd_unsteady_upwind
static void cs_i_cd_unsteady_upwind(const int ircflp, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_t pi, const cs_real_t pj, cs_real_t *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:1427
cs_upwind_f_val_tensor
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:698
cs_b_cd_unsteady
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:4801
cs_real_66_t
cs_real_t cs_real_66_t[6][6]
6x6 matrix of floating-point values
Definition: cs_defs.h:317
cs_i_compute_quantities_vector
static void cs_i_compute_quantities_vector(const int ircflp, const cs_real_3_t diipf, const cs_real_3_t djjpf, 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:447
CS_NVD_STOIC
Definition: cs_convection_diffusion.h:94
cs_slope_test_gradient_tensor
void cs_slope_test_gradient_tensor(const int inc, const cs_halo_type_t halo_type, const cs_real_63_t *grad, cs_real_63_t *grdpa, const cs_real_6_t *pvar, const cs_real_6_t *coefa, const cs_real_66_t *coefb, const cs_real_t *i_massflux)
Compute the upwind gradient used in the slope tests.
Definition: cs_convection_diffusion.c:1677
cs_b_imposed_conv_flux
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:4276
cstnum::pi
double precision pi
value with 16 digits
Definition: cstnum.f90:48
cs_defs.h
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:462
cs_int_t
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:296
CS_UNUSED
#define CS_UNUSED(x)
Definition: cs_defs.h:448
CS_COUPLED_FD
Definition: cs_parameters.h:143
cs_i_relax_c_val_tensor
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:634
cs_i_relax_c_val
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:556
cs_slope_test_gradient_vector
void cs_slope_test_gradient_vector(const int inc, const cs_halo_type_t halo_type, const cs_real_33_t *grad, cs_real_33_t *grdpa, const cs_real_3_t *pvar, const cs_real_3_t *coefa, const cs_real_33_t *coefb, const cs_real_t *i_massflux)
Compute the upwind gradient used in the slope tests.
Definition: cs_convection_diffusion.c:1522
cs_centered_f_val
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:717
optcal::idtvar
integer(c_int), pointer, save idtvar
option for a variable time step
Definition: optcal.f90:467
cs_i_cd_steady_slope_test_vector
static void cs_i_cd_steady_slope_test_vector(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double relaxp, const double blencp, const double blend_st, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t 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 diipf, const cs_real_3_t djjpf, 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:2989
p
Definition: cs_field_pointer.h:67
cs_b_compute_quantities_vector
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:4134
CS_NVD_CUBISTA
Definition: cs_convection_diffusion.h:89
cs_i_cd_unsteady_vector
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_t hybrid_blend_i, const cs_real_t hybrid_blend_j, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_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:2243
itrgrp
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[], cs_real_t visel[], cs_real_t diverg[])
Definition: cs_convection_diffusion.c:1101
cs_parameters.h
cs_i_cd_steady_slope_test
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 double blend_st, 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 diipf, const cs_real_3_t djjpf, const cs_real_t i_massflux, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t gradupi, const cs_real_3_t gradupj, const cs_real_3_t gradsti, const cs_real_3_t gradstj, const cs_real_t pi, const cs_real_t pj, 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:2509
CS_NVD_MINMOD
Definition: cs_convection_diffusion.h:92
cs_blend_f_val_vector
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:891
cs_i_cd_steady_slope_test_vector_old
static void cs_i_cd_steady_slope_test_vector_old(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 diipf, const cs_real_3_t djjpf, 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:2761
cs_i_cd_unsteady_upwind_vector
static void cs_i_cd_unsteady_upwind_vector(const int ircflp, const cs_real_3_t diipf, const cs_real_3_t djjpf, 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:1477
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:297
cs_solu_f_val_tensor
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:840
cs_math_3_square_norm
static cs_real_t cs_math_3_square_norm(const cs_real_t v[3])
Compute the square norm of a vector of 3 real values.
Definition: cs_math.h:316
cs_solu_f_val_vector
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:808
cs_b_upwind_flux_vector
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:4476
cs_math_sq
static cs_real_t cs_math_sq(cs_real_t x)
Compute the square of a real value.
Definition: cs_math.h:121
cs_mesh_t
Definition: cs_mesh.h:63
cs_i_diff_flux
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:1078
cs_b_diff_flux_coupling
static void cs_b_diff_flux_coupling(int idiffp, cs_real_t pi, cs_real_t pj, cs_real_t b_visc, cs_real_t *fluxi)
Add diffusive flux to flux at an internal coupling face.
Definition: cs_convection_diffusion.h:4893
cs_i_cd_steady_upwind
static void cs_i_cd_steady_upwind(const int ircflp, const cs_real_t relaxp, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_t pi, const cs_real_t pj, 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:1184
cs_b_diff_flux_vector
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:4610
cs_mesh_quantities.h
cs_i_relax_c_val_vector
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:594
cs_i_diff_flux_tensor
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:1141
cs_i_cd_unsteady
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_t hybrid_blend_i, const cs_real_t hybrid_blend_j, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t gradupi, const cs_real_3_t gradupj, const cs_real_t pi, const cs_real_t pj, cs_real_t *pif, cs_real_t *pjf, cs_real_t *pip, cs_real_t *pjp)
Handle preparation of internal face values for the fluxes computation in case of a unsteady algorithm...
Definition: cs_convection_diffusion.h:2083
CS_NVD_MUSCL
Definition: cs_convection_diffusion.h:91
cs_b_relax_c_val_tensor
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:4236
cs_b_relax_c_val
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:4184
cs_b_diff_flux_coupling_vector
static void cs_b_diff_flux_coupling_vector(int idiffp, const cs_real_t pi[3], const cs_real_t pj[3], cs_real_t b_visc, cs_real_t fluxi[3])
Add diffusive flux to flux at an internal coupling face for a vector.
Definition: cs_convection_diffusion.h:4916
cs_convection_diffusion_vector
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[], const cs_real_t secvib[], 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:3344
cs_solu_f_val
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:780
cs_mesh_quantities_t
Definition: cs_mesh_quantities.h:90
cs_halo_type_t
cs_halo_type_t
Definition: cs_halo.h:50
cs_face_anisotropic_diffusion_potential
void cs_face_anisotropic_diffusion_potential(const int f_id, const cs_mesh_t *m, cs_mesh_quantities_t *fvq, int init, int inc, int imrgra, int iccocg, int nswrgp, int imligp, int ircflp, int iphydp, int iwgrp, int iwarnp, double epsrgp, double climgp, 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:9916
cs_halo.h
cs_i_cd_unsteady_tensor
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 diipf, const cs_real_3_t djjpf, 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:2385
cs_b_upwind_flux
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:4424
cs_anisotropic_diffusion_potential
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:10762
cs_slope_test
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:132
CS_NVD_SMART
Definition: cs_convection_diffusion.h:88
cs_b_compute_quantities_tensor
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:4158
cs_slope_test_tensor
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 gradsti, const cs_real_63_t gradstj, const cs_real_t i_massflux, cs_real_t *testij, cs_real_t *tesqck)
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion.h:336
cs_slope_test_vector
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 gradsti, const cs_real_33_t gradstj, const cs_real_t i_massflux, cs_real_t *testij, cs_real_t *tesqck)
Compute slope test criteria at internal face between cell i and j.
Definition: cs_convection_diffusion.h:197
cs_i_conv_flux
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:944
cs_centered_f_val_vector
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:737
cs_b_cd_unsteady_tensor
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:4862
cs_face_diffusion_potential
void cs_face_diffusion_potential(const int f_id, const cs_mesh_t *m, cs_mesh_quantities_t *fvq, int init, int inc, int imrgra, int iccocg, int nswrgp, int imligp, int iphydp, int iwgrp, int iwarnp, double epsrgp, double climgp, 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 visel, cs_real_t *restrict i_massflux, cs_real_t *restrict b_massflux)
Update the face mass flux with the face pressure (or pressure increment, or pressure double increment...
Definition: cs_convection_diffusion.c:9560
cs_real_3_t
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:310
cs_b_upwind_flux_tensor
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:4532
cs_i_cd_unsteady_upwind_tensor
static void cs_i_cd_unsteady_upwind_tensor(const int ircflp, const cs_real_3_t diipf, const cs_real_3_t djjpf, 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:1528
CS_NVD_N_TYPES
Definition: cs_convection_diffusion.h:100
cs_slope_test_gradient
void cs_slope_test_gradient(int f_id, int inc, cs_halo_type_t halo_type, const cs_real_3_t *grad, cs_real_3_t *grdpa, const cs_real_t *pvar, const cs_real_t *coefap, const cs_real_t *coefbp, const cs_real_t *i_massflux)
Compute the upwind gradient used in the slope tests.
Definition: cs_convection_diffusion.c:1246
cs_i_conv_flux_vector
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:988
cs_i_conv_flux_tensor
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:1036
cs_convection_diffusion_tensor
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:4891
coincl::fmin
double precision, save fmin
Definition: coincl.f90:133
cs_var_cal_opt_t
structure containing the variable calculation options.
Definition: cs_parameters.h:60
cs_i_cd_unsteady_slope_test_vector
static void cs_i_cd_unsteady_slope_test_vector(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double blencp, const double blend_st, 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 diipf, const cs_real_3_t djjpf, 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:3798
cs_b_compute_quantities
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:4112
cs_i_diff_flux_vector
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:1108
itrgrv
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:1160
CS_NVD_WASEB
Definition: cs_convection_diffusion.h:96
cs_math_3_square_distance
static cs_real_t cs_math_3_square_distance(const cs_real_t xa[3], const cs_real_t xb[3])
Compute the squared distance between two points xa and xb in a cartesian coordinate system of dimensi...
Definition: cs_math.h:232
cs_i_cd_unsteady_slope_test
static void cs_i_cd_unsteady_slope_test(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double blencp, const double blend_st, 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 diipf, const cs_real_3_t djjpf, const cs_real_t i_massflux, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_3_t gradupi, const cs_real_3_t gradupj, const cs_real_3_t gradsti, const cs_real_3_t gradstj, const cs_real_t pi, const cs_real_t pj, cs_real_t *pif, cs_real_t *pjf, cs_real_t *pip, cs_real_t *pjp)
Handle preparation of internal face values for the fluxes computation in case of a steady algorithm a...
Definition: cs_convection_diffusion.h:3443
itrmas
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 iwgrp, 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 visel[], cs_real_t i_massflux[], cs_real_t b_massflux[])
Definition: cs_convection_diffusion.c:969
cs_math.h
cs_diffusion_potential
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[], cs_real_t visel[], cs_real_t *restrict diverg)
Update the cell mass flux divergence with the face pressure (or pressure increment, or pressure double increment) gradient.
Definition: cs_convection_diffusion.c:10384
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:463
CS_NVD_CLAM
Definition: cs_convection_diffusion.h:93
CS_NVD_VOF_CICSAM
Definition: cs_convection_diffusion.h:98
cs_i_compute_quantities_tensor
static void cs_i_compute_quantities_tensor(const int ircflp, const cs_real_3_t diipf, const cs_real_3_t djjpf, 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:502
CS_PROCF
#define CS_PROCF(x, y)
Definition: cs_defs.h:476
cs_real_33_t
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:316
cs_i_compute_quantities
static void cs_i_compute_quantities(const int ircflp, const cs_real_3_t diipf, const cs_real_3_t djjpf, const cs_real_3_t gradi, const cs_real_3_t gradj, const cs_real_t pi, const cs_real_t pj, cs_real_t *recoi, cs_real_t *recoj, cs_real_t *pip, cs_real_t *pjp)
Reconstruct values in I&#39; and J&#39;.
Definition: cs_convection_diffusion.h:404
CS_NVD_VOF_HRIC
Definition: cs_convection_diffusion.h:97
CS_NVD_GAMMA
Definition: cs_convection_diffusion.h:87
CS_NVD_SUPERBEE
Definition: cs_convection_diffusion.h:90
cs_convection_diffusion_scalar
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:1974
cs_blend_f_val_tensor
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:912
cs_real_63_t
cs_real_t cs_real_63_t[6][3]
Definition: cs_defs.h:322
cs_b_cd_unsteady_vector
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:4831
cs_i_cd_steady_tensor
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 diipf, const cs_real_3_t djjpf, 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:1929
cs_b_cd_steady_tensor
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:4763
cs_max_limiter_building
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:1823
cs_upwind_f_val
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:665
cs_convection_diffusion_thermal
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:5806
cs_b_diff_flux
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:4581
cs_upwind_gradient
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:1390
cs_anisotropic_right_diffusion_vector
void cs_anisotropic_right_diffusion_vector(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, cs_real_3_t *restrict pvar, const cs_real_3_t *restrict pvara, const cs_real_3_t coefav[], const cs_real_33_t coefbv[], const cs_real_3_t cofafv[], const cs_real_33_t cofbfv[], const cs_real_t i_visc[], const cs_real_t b_visc[], const cs_real_t secvif[], cs_real_6_t *restrict viscel, const cs_real_2_t weighf[], const cs_real_t weighb[], cs_real_3_t *restrict rhs)
Add explicit part of the terms of diffusion by a right-multiplying symmetric tensorial diffusivity fo...
Definition: cs_convection_diffusion.c:8274
cs_i_cd_steady_slope_test_tensor
static void cs_i_cd_steady_slope_test_tensor(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double relaxp, const double blencp, const double blend_st, const cs_real_t weight, const cs_real_t i_dist, const cs_real_t 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 diipf, const cs_real_3_t djjpf, 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:3217
CS_NVD_OSHER
Definition: cs_convection_diffusion.h:95
optcal::imrgra
integer(c_int), pointer, save imrgra
type of gradient reconstruction
Definition: optcal.f90:286
itrmav
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 iwgrp, 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:1032
cs_i_cd_unsteady_slope_test_tensor
static void cs_i_cd_unsteady_slope_test_tensor(bool *upwind_switch, const int iconvp, const int ircflp, const int ischcp, const double blencp, const double blend_st, 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 diipf, const cs_real_3_t djjpf, 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:3968
cs_b_relax_c_val_vector
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:4209
cs_blend_f_val
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:871
cs_i_cd_steady_upwind_vector
static void cs_i_cd_steady_upwind_vector(const int ircflp, const cs_real_t relaxp, const cs_real_3_t diipf, const cs_real_3_t djjpf, 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:1267
CS_NVD_VOF_STACS
Definition: cs_convection_diffusion.h:99
cs_anisotropic_left_diffusion_vector
void cs_anisotropic_left_diffusion_vector(int idtvar, int f_id, const cs_var_cal_opt_t var_cal_opt, int inc, int ivisep, cs_real_3_t *restrict pvar, const cs_real_3_t *restrict pvara, const cs_real_3_t coefav[], const cs_real_33_t coefbv[], const cs_real_3_t cofafv[], const cs_real_33_t cofbfv[], const cs_real_33_t i_visc[], const cs_real_t b_visc[], const cs_real_t secvif[], cs_real_3_t *restrict rhs)
Add explicit part of the terms of diffusion by a left-multiplying symmetric tensorial diffusivity for...
Definition: cs_convection_diffusion.c:7739
Generated on Sat Feb 2 2019 15:43:25 by   doxygen 1.8.13