programmer's documentation
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cs_gui.h
Go to the documentation of this file.
1 #ifndef __CS_GUI_H__
2 #define __CS_GUI_H__
3 
4 /*============================================================================
5  * Management of the GUI parameters file: main parameters
6  *============================================================================*/
7 
8 /*
9  This file is part of Code_Saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2014 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 /*----------------------------------------------------------------------------
31  * Local headers
32  *----------------------------------------------------------------------------*/
33 
34 #include "cs_base.h"
35 
36 /*----------------------------------------------------------------------------*/
37 
39 
40 /*============================================================================
41  * Type definitions
42  *============================================================================*/
43 
44 /*============================================================================
45  * Public function prototypes for Fortran API
46  *============================================================================*/
47 
48 /*----------------------------------------------------------------------------
49  * Initialise the global 'vars' structure.
50  *
51  * Fortran Interface:
52  *
53  * subroutine uiinit
54  * *****************
55  *----------------------------------------------------------------------------*/
56 
57 void CS_PROCF (uiinit, UIINIT) (void);
58 
59 /*----------------------------------------------------------------------------
60  * Thermal model.
61  *
62  * Fortran Interface:
63  *
64  * SUBROUTINE CSTHER (ITHERM)
65  * *****************
66  *
67  * INTEGER ITHERM --> thermal model
68  * integer itpscl --> temperature scale if itherm = 1
69  *----------------------------------------------------------------------------*/
70 
71 
72 void CS_PROCF (csther, CSTHER) (int *itherm,
73  int *itpscl);
74 
75 /*----------------------------------------------------------------------------
76  * Turbulence model.
77  *
78  * Fortran Interface:
79  *
80  * SUBROUTINE CSTURB
81  * *****************
82  *
83  * INTEGER ITURB --> turbulence model
84  * INTEGER IDEUCH --> wall law treatment
85  * INTEGER IGRAKE --> k-eps gravity effects
86  * INTEGER IGRAKI --> Rij-eps gravity effects
87  * DOUBLE PRECISION XLOMLG --> mixing_length_scale
88  *----------------------------------------------------------------------------*/
89 
90 void CS_PROCF (csturb, CSTURB) (int *const iturb,
91  int *const ideuch,
92  int *const igrake,
93  int *const igrari,
94  double *const xlomlg);
95 
96 /*----------------------------------------------------------------------------
97  * Specific heat variable or constant indicator.
98  *
99  * Fortran Interface:
100  *
101  * SUBROUTINE CSCPVA
102  * *****************
103  *
104  * INTEGER ICP --> Specific heat variable or constant indicator
105  *----------------------------------------------------------------------------*/
106 
107 void CS_PROCF (cscpva, CSCPVA) (int *const icp);
108 
109 /*----------------------------------------------------------------------------
110  * Volumic viscosity variable or constant indicator.
111  *
112  * Fortran Interface:
113  *
114  * SUBROUTINE CSCVVVA (ICP)
115  * *****************
116  *
117  * INTEGER IVISCV --> specific heat variable or constant indicator
118  *----------------------------------------------------------------------------*/
119 
120 void CS_PROCF (csvvva, CSVVVA) (int *const iviscv);
121 
122 /*----------------------------------------------------------------------------
123  * User scalars number.
124  *
125  * Fortran Interface:
126  *
127  * SUBROUTINE CSNSCA
128  * *****************
129  *
130  * INTEGER NSCAUS --> user scalars number
131  *----------------------------------------------------------------------------*/
132 
133 void CS_PROCF (csnsca, CSNSCA) (int *const nscaus);
134 
135 /*----------------------------------------------------------------------------
136  * User scalars labels
137  *
138  * Fortran Interface:
139  *
140  * SUBROUTINE UISCAU
141  * *****************
142  *----------------------------------------------------------------------------*/
143 
144 void CS_PROCF (uiscau, UISCAU) (void);
145 
146 /*----------------------------------------------------------------------------
147  * User thermal scalar.
148  *
149  * Fortran Interface:
150  *
151  * SUBROUTINE UITHSC
152  * *****************
153  *
154  * INTEGER ISCALT --> thermal scalars number
155  *----------------------------------------------------------------------------*/
156 
157 void CS_PROCF (uithsc, UITHSC) (int *const iscalt);
158 
159 /*----------------------------------------------------------------------------
160  * User scalars which are variance.
161  *
162  * Fortran Interface:
163  *
164  * SUBROUTINE CSISCA (ISCAVR)
165  * *****************
166  *
167  * INTEGER ISCAVR --> user scalars variance array
168  * integer itherm <-- type of thermal model
169  *----------------------------------------------------------------------------*/
170 
171 void CS_PROCF (csisca, CSISCA) (int *iscavr,
172  const int *itherm);
173 
174 /*----------------------------------------------------------------------------
175  * Constant or variable indicator for the user scalar laminar viscosity.
176  *
177  * Fortran Interface:
178  *
179  * SUBROUTINE CSIVIS
180  * *****************
181  *
182  * INTEGER ISCAVR <-> number of the related variance if any
183  * INTEGER IVISLS --> indicator for the user scalar viscosity
184  * INTEGER ISCALT <-> number of the user thermal scalar if any
185  * INTEGER ISCSTH <-> type of the user thermal scalar
186  * INTEGER ITEMPK --> rtp index for temperature (in K)
187  *----------------------------------------------------------------------------*/
188 
189 /*----------------------------------------------------------------------------
190  * Constant or variable indicator for the user scalar laminar viscosity.
191  *
192  * Fortran Interface:
193  *
194  * subroutine csivis (iscavr, ivisls, iscalt, itherm, itempk)
195  * *****************
196  *
197  * integer iscavr <--> number of the related variance if any
198  * integer ivisls <-- indicator for the user scalar viscosity
199  * integer iscalt <--> number of the user thermal scalar if any
200  * integer itherm <--> type of thermal model
201  * integer itempk --> rtp index for temperature (in K)
202  *----------------------------------------------------------------------------*/
203 
204 void CS_PROCF (csivis, CSIVIS) (int *const iscavr,
205  int *const ivisls,
206  int *const iscalt,
207  int *const itherm,
208  int *const itempk);
209 
210 /*----------------------------------------------------------------------------
211  * Time passing parameter.
212  *
213  * Fortran Interface:
214  *
215  * SUBROUTINE CSIDTV (IDTVAR)
216  * *****************
217  *
218  * INTEGER IDTVAR --> fixed or variable time step
219  *----------------------------------------------------------------------------*/
220 
221 void CS_PROCF(csidtv, CSIDTV) (int *const idtvar);
222 
223 /*----------------------------------------------------------------------------
224  * Hydrostatic pressure parameter.
225  *
226  * Fortran Interface:
227  *
228  * SUBROUTINE CSIPHY (IPHYDR)
229  * *****************
230  *
231  * INTEGER IPHYDR --> hydrostatic pressure
232  *----------------------------------------------------------------------------*/
233 
234 void CS_PROCF (csiphy, CSIPHY) (int *const iphydr);
235 
236 /*----------------------------------------------------------------------------
237  * Hydrostatic equilibrium parameter.
238  *
239  * Fortran Interface:
240  *
241  * SUBROUTINE CSCFGP (ICFGRP)
242  * *****************
243  *
244  * INTEGER ICFGRP --> hydrostatic equilibrium
245  *----------------------------------------------------------------------------*/
246 
247 void CS_PROCF (cscfgp, CSCFGP) (int *const icfgrp);
248 
249 /*----------------------------------------------------------------------------
250  * Restart parameters.
251  *
252  * Fortran Interface:
253  *
254  * SUBROUTINE CSISUI
255  * *****************
256  *
257  * INTEGER NTSUIT --> checkpoint frequency
258  * INTEGER ILEAUX --> restart with auxiliary
259  * INTEGER ICCFVG --> restart with frozen field
260  *----------------------------------------------------------------------------*/
261 
262 
263 void CS_PROCF (csisui, CSISUI) (int *const ntsuit,
264  int *const ileaux,
265  int *const iccvfg);
266 
267 /*----------------------------------------------------------------------------
268  * Time passing parameters.
269  *
270  * Fortran Interface:
271  *
272  * SUBROUTINE CSTIME
273  * *****************
274  *
275  * INTEGER INPDT0 --> zero tim step
276  * INTEGER IPTLTO --> thermal time step control
277  * INTEGER NTMABS --> iterations numbers
278  * INTEGER IDTVAR --> time step's options
279  * DOUBLE PRECISION DTREF --> time step
280  * DOUBLE PRECISION DTMIN --> minimal time step
281  * DOUBLE PRECISION DTMAX --> maximal time step
282  * DOUBLE PRECISION COUMAX --> maximal courant number
283  * DOUBLE PRECISION FOUMAX --> maximal fournier number
284  * DOUBLE PRECISION VARRDT --> max time step variation between 2 iterations
285  * DOUBLE PRECISION RELXST --> relaxation coefficient if idtvar = -1
286  *----------------------------------------------------------------------------*/
287 
288 void CS_PROCF (cstime, CSTIME) (int *const inpdt0,
289  int *const iptlro,
290  int *const ntmabs,
291  int *const idtvar,
292  double *const dtref,
293  double *const dtmin,
294  double *const dtmax,
295  double *const coumax,
296  double *const foumax,
297  double *const varrdt,
298  double *const relxst);
299 
300 /*----------------------------------------------------------------------------
301  *
302  * Fortran Interface:
303  *
304  * SUBROUTINE UINUM1
305  * *****************
306  *
307  *----------------------------------------------------------------------------*/
308 
309 void CS_PROCF (uinum1, UINUM1) (double *const blencv,
310  int *const ischcv,
311  int *const isstpc,
312  int *const ircflu,
313  double *const cdtvar,
314  int *const nitmax,
315  double *const epsilo,
316  int *const iresol,
317  int *const imgrpr,
318  int *const nswrsm);
319 
320 /*----------------------------------------------------------------------------
321  * Global numerical parameters.
322  *
323  * Fortran Interface:
324  *
325  * SUBROUTINE CSNUM2
326  * *****************
327  *
328  * INTEGER IVISSE --> gradient transpose
329  * INTEGER RELAXP --> pressure relaxation
330  * INTEGER IPUCOU --> velocity pressure coupling
331  * INTEGER EXTRAG --> wall pressure extrapolation
332  * INTEGER IMRGRA --> gradient reconstruction
333  * INTEGER NTERUP --> piso sweep number
334  *----------------------------------------------------------------------------*/
335 
336 void CS_PROCF (csnum2, CSNUM2) ( int *const ivisse,
337  double *const relaxp,
338  int *const ipucou,
339  double *const extrag,
340  int *const imrgra,
341  int *const nterup);
342 
343 void CS_PROCF (csphys, CSPHYS) (const int *const nmodpp,
344  int *const irovar,
345  int *const ivivar,
346  int *const icorio,
347  double *const gx,
348  double *const gy,
349  double *const gz,
350  double *const omegax,
351  double *const omegay,
352  double *const omegaz,
353  double *const ro0,
354  double *const viscl0,
355  double *const viscv0,
356  double *const visls0,
357  double *const cp0,
358  double *const t0,
359  double *const p0,
360  double *const xmasmr,
361  int *const itempk,
362  int *const itherm,
363  int *const itpscl);
364 
365 /*----------------------------------------------------------------------------
366  * User scalar min and max values for clipping.
367  *
368  * Fortran Interface:
369  *
370  * subroutine cssca2
371  * *****************
372  *
373  * integer iscavr <-- number of the related variance if any
374  *----------------------------------------------------------------------------*/
375 
376 void CS_PROCF (cssca2, CSSCA2) (const int *const iscavr);
377 
378 void CS_PROCF (cssca3, CSSCA3) (const int *const itherm,
379  const int *const iscalt,
380  const int *const iscavr,
381  double *const visls0,
382  double *const t0,
383  double *const p0,
384  double *const cp0);
385 
386 /*----------------------------------------------------------------------------
387  * Array of properties used in the calculation
388  *----------------------------------------------------------------------------*/
389 
390 void CS_PROCF (uiprop, UIPROP) (const int *const ivisls,
391  const int *const ismago,
392  const int *const iale,
393  const int *const icp,
394  const int *const iscavr);
395 
396 /*----------------------------------------------------------------------------
397  * Temporal averaging treatment
398  *----------------------------------------------------------------------------*/
399 
400 void CS_PROCF (uimoyt, UIMOYT) (const int *const ndgmox,
401  int *const ntdmom,
402  int *const imoold,
403  int *const idfmom);
404 
405 /*----------------------------------------------------------------------------
406  * Turbulence initialization parameters.
407  *
408  * Fortran Interface:
409  *
410  * SUBROUTINE CSTINI
411  * *****************
412  *
413  * INTEGER UREF --> reference velocity
414  * INTEGER ALMAX --> reference length
415  *----------------------------------------------------------------------------*/
416 
417 void CS_PROCF (cstini, CSTINI) (double *const uref,
418  double *const almax);
419 
420 /*----------------------------------------------------------------------------
421  * User momentum source terms.
422  *
423  * Fortran Interface:
424  *
425  * subroutine uitsnv (ncelet, vel, tsexp, tsimp)
426  * *****************
427  *
428  * integer ncelet <-- number of cells with halo
429  * double precision vel <-- fluid velocity
430  * double precision tsexp --> explicit source terms
431  * double precision tsimp --> implicit source terms
432  *----------------------------------------------------------------------------*/
433 
434 void CS_PROCF(uitsnv, UITSNV)(const cs_real_3_t *restrict vel,
435  cs_real_3_t *restrict tsexp,
436  cs_real_33_t *restrict tsimp);
437 
438 
439 /*----------------------------------------------------------------------------
440  * User scalar source terms.
441  *
442  * Fortran Interface:
443  *
444  * subroutine uitssc (f_id, pvar, tsexp, tsimp)
445  * *****************
446  *
447  * integer f_id <-- field id
448  * double precision pvar <-- scalar
449  * double precision tsexp --> explicit source terms
450  * double precision tsimp --> implicit source terms
451  *----------------------------------------------------------------------------*/
452 
453 void CS_PROCF(uitssc, UITSSC)(const int *f_id,
454  const cs_real_t *restrict pvar,
455  cs_real_t *restrict tsexp,
456  cs_real_t *restrict tsimp);
457 
458 
459 /*----------------------------------------------------------------------------
460  * Thermal scalar source terms.
461  *
462  * Fortran Interface:
463  *
464  * subroutine uitsth (f_id, pvar, tsexp, tsimp)
465  * *****************
466  *
467  * integer f_id <-- field id
468  * double precision pvar <-- scalar
469  * double precision tsexp --> explicit source terms
470  * double precision tsimp --> implicit source terms
471  *----------------------------------------------------------------------------*/
472 
473 void CS_PROCF(uitsth, UITSTH)(const int *f_id,
474  const cs_real_t *restrict pvar,
475  cs_real_t *restrict tsexp,
476  cs_real_t *restrict tsimp);
477 
478 /*----------------------------------------------------------------------------
479  * Variables and user scalars initialization.
480  *
481  * Fortran Interface:
482  *
483  * subroutine uiiniv
484  * *****************
485  *
486  * integer ncelet <-- number of cells with halo
487  * integer isuite <-- restart indicator
488  * integer iccfth <-- type of initialisation(compressible model)
489  * double precision ro0 <-- value of density if IROVAR=0
490  * double precision cp0 <-- value of specific heat if ICP=0
491  * double precision viscl0 <-- value of viscosity if IVIVAR=0
492  * double precision uref <-- value of reference velocity
493  * double precision almax <-- value of reference length
494  * double precision xyzcen <-- cell's gravity center
495  *----------------------------------------------------------------------------*/
496 
497 void CS_PROCF(uiiniv, UIINIV)(const int *ncelet,
498  const int *isuite,
499  int *iccfth,
500  const cs_real_t *ro0,
501  const cs_real_t *cp0,
502  const cs_real_t *viscl0,
503  const cs_real_t *uref,
504  const cs_real_t *almax,
505  const double *const xyzcen);
506 
507 /*----------------------------------------------------------------------------
508  * User law for material Properties
509  *
510  * Fortran Interface:
511  *
512  * SUBROUTINE UIPHYV (NCELET, ISCA, RTP)
513  * *****************
514  *
515  * INTEGER NCEL <-- number of cells whithout halo
516  * INTEGER NCELET <-- number of cells whith halo
517  * INTEGER ICP <-- pointer for predifined heat Cp
518  * INTEGER IVISLS <-- pointer for Lambda/Cp
519  * INTEGER IROVAR <-- =1 if rho variable, =0 if rho constant
520  * INTEGER IVIVAR <-- =1 if mu variable, =0 if mu constant
521  * INTEGER ISCALT <-- pointer for the thermal scalar in ISCA
522  * INTEGER ISCAVR <-- scalars that are variance
523  * INTEGER IVISCV <-- pointer for volumic viscosity viscv
524  * INTEGER ITEMPK <-- pointer for temperature (in K)
525  * DOUBLE PRECISION P0 <-- pressure reference value
526  * DOUBLE PRECISION T0 <-- temperature reference value
527  * DOUBLE PRECISION RO0 <-- density reference value
528  * DOUBLE PRECISION CP0 <-- specific heat reference value
529  * DOUBLE PRECISION VISCL0 <-- dynamic viscosity reference value
530  * DOUBLE PRECISION VISLS0 <-- diffusion coefficient of the scalars
531  * DOUBLE PRECISION VISCV0 <-- volumic viscosity
532  *----------------------------------------------------------------------------*/
533 
534 void CS_PROCF(uiphyv, UIPHYV)(const cs_int_t *ncel,
535  const cs_int_t *ncelet,
536  const cs_int_t *itherm,
537  const cs_int_t *icp,
538  const cs_int_t ivisls[],
539  const cs_int_t *irovar,
540  const cs_int_t *ivivar,
541  const cs_int_t *iscalt,
542  const cs_int_t iscavr[],
543  const cs_int_t *iviscv,
544  const cs_int_t *itempk,
545  const cs_real_t *p0,
546  const cs_real_t *t0,
547  const cs_real_t *ro0,
548  const cs_real_t *cp0,
549  const cs_real_t *viscl0,
550  const cs_real_t *visls0,
551  const cs_real_t *viscv0);
552 
553 /*----------------------------------------------------------------------------
554  * Head losses definition
555  *
556  * Fortran Interface:
557  *
558  * subroutine uikpdc
559  * *****************
560  *
561  * integer iappel <-- number of calls during a time step
562  * integer ncelet <-- number of cells with halo
563  * integer ncepdp --> number of cells with head losses
564  * integer icepdc --> ncepdp cells number with head losses
565  * double precision ckupdc --> head losses matrix
566  *----------------------------------------------------------------------------*/
567 
568 void CS_PROCF(uikpdc, UIKPDC)(const int* iappel,
569  const int* ncelet,
570  int* ncepdp,
571  int icepdc[],
572  double ckupdc[]);
573 
574 /*----------------------------------------------------------------------------
575  * 1D profile postprocessing
576  *
577  * Fortran Interface:
578  *
579  * SUBROUTINE UIPROF
580  * *****************
581  *
582  * INTEGER NCELET <-- number of cells with halo
583  * INTEGER NCEL <-- number of cells without halo
584  * INTEGER NTMABS <-- max iterations numbers
585  * INTEGER NTCABS <-- current iteration number
586  * DOUBLE PRECISION TTCABS <-- current physical time
587  * DOUBLE PRECISION TTMABS <-- max physical time
588  * DOUBLE PRECISION TTPABS <-- physical time at calculation beginning
589  * DOUBLE PRECISION XYZCEN <-- cell's gravity center
590  *----------------------------------------------------------------------------*/
591 
592 void CS_PROCF (uiprof, UIPROF)(const int *const ncelet,
593  const int *const ncel,
594  const int *const ntmabs,
595  const int *const ntcabs,
596  const double *const ttcabs,
597  const double *const ttmabs,
598  const double *const ttpabs,
599  const double *const xyzcen);
600 
601 /*----------------------------------------------------------------------------
602  * Free memory: clean global private variables and libxml2 variables.
603  *
604  * Fortran Interface:
605  *
606  * SUBROUTINE MEMUI1
607  * *****************
608  *
609  * INTEGER NCHARB <-- number of coal
610  *----------------------------------------------------------------------------*/
611 
612 void CS_PROCF (memui1, MEMUI1) (const int *const ncharb);
613 
614 /*=============================================================================
615  * Public function prototypes
616  *============================================================================*/
617 
618 /*----------------------------------------------------------------------------
619  * Get thermal scalar model.
620  *
621  * return:
622  * value of itherm
623  *----------------------------------------------------------------------------*/
624 
625 int
626 gui_thermal_model(void);
627 
628 /*-----------------------------------------------------------------------------
629  * Get initial value from property markup.
630  *
631  * parameters:
632  * property_name <-- name of the property
633  * value --> new initial value of the property
634  *----------------------------------------------------------------------------*/
635 
636 void
637 cs_gui_properties_value(const char *property_name,
638  double *value);
639 
640 /*-----------------------------------------------------------------------------
641  * Initialization choice of the reference variables parameters.
642  *
643  * parameters:
644  * name <-- parameter name
645  * value --> parameter value
646  *----------------------------------------------------------------------------*/
647 
648 void
649 cs_gui_reference_initialization(const char *param,
650  double *value);
651 
652 /*-----------------------------------------------------------------------------
653  * Set partitioning options.
654  *----------------------------------------------------------------------------*/
655 
656 void
657 cs_gui_partition(void);
658 
659 /*-----------------------------------------------------------------------------
660  * Define parallel IO settings.
661  *----------------------------------------------------------------------------*/
662 
663 void
664 cs_gui_parallel_io(void);
665 
666 /*-----------------------------------------------------------------------------
667  * Free memory: clean global private variables and libxml2 variables
668  *----------------------------------------------------------------------------*/
669 
670 void
671 cs_gui_clean_memory(void);
672 
673 /*----------------------------------------------------------------------------
674  * Logging output for MEI usage.
675  *----------------------------------------------------------------------------*/
676 
677 void
678 cs_gui_usage_log(void);
679 
680 /*----------------------------------------------------------------------------*/
681 
683 
684 #endif /* __CS_GUI_H__ */
void cs_gui_reference_initialization(const char *param, double *value)
Definition: cs_gui.c:5066
#define restrict
Definition: cs_defs.h:122
void uikpdc(const int *iappel, const int *ncelet, int *ncepdp, int icepdc[], double ckupdc[])
void cstini(double *const uref, double *const almax)
Definition: cs_gui.c:2955
void cssca3(const int *const itherm, const int *const iscalt, const int *const iscavr, double *const visls0, double *const t0, double *const p0, double *const cp0)
Definition: cs_gui.c:2873
void cs_gui_clean_memory(void)
Definition: cs_gui.c:5328
void csnsca(int *const nscaus)
Definition: cs_gui.c:2012
#define BEGIN_C_DECLS
Definition: cs_defs.h:405
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
void cscpva(int *const icp)
Definition: cs_gui.c:1964
void csphys(const int *const nmodpp, int *const irovar, int *const ivivar, int *const icorio, double *const gx, double *const gy, double *const gz, double *const omegax, double *const omegay, double *const omegaz, double *const ro0, double *const viscl0, double *const viscv0, double *const visls0, double *const cp0, double *const t0, double *const p0, double *const xmasmr, int *const itempk, int *const itherm, int *const itpscl)
Definition: cs_gui.c:2650
void cs_gui_parallel_io(void)
Definition: cs_gui.c:5236
void uimoyt(const int *const ndgmox, int *const ntdmom, int *const imoold, int *const idfmom)
Definition: cs_gui.c:3026
void cs_gui_usage_log(void)
Definition: cs_gui.c:5365
void uiinit(void)
Definition: cs_gui.c:1797
void cs_gui_partition(void)
Definition: cs_gui.c:5089
void memui1(const int *const ncharb)
Definition: cs_gui.c:4980
void csiphy(int *const iphydr)
Definition: cs_gui.c:2288
void uiscau(void)
Definition: cs_gui.c:2031
void cstime(int *const inpdt0, int *const iptlro, int *const ntmabs, int *const idtvar, double *const dtref, double *const dtmin, double *const dtmax, double *const coumax, double *const foumax, double *const varrdt, double *const relxst)
Definition: cs_gui.c:2390
void csidtv(int *const idtvar)
Definition: cs_gui.c:2252
void uiprof(const int *const ncelet, const int *const ncel, const int *const ntmabs, const int *const ntcabs, const double *const ttcabs, const double *const ttmabs, const double *const ttpabs, const double *const xyzcen)
Definition: cs_gui.c:4690
void uiiniv(const int *ncelet, const int *isuite, int *iccfth, const cs_real_t *ro0, const cs_real_t *cp0, const cs_real_t *viscl0, const cs_real_t *uref, const cs_real_t *almax, const double *const xyzcen)
Definition: cs_gui.c:3548
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:307
void cssca2(const int *const iscavr)
Definition: cs_gui.c:2801
void uitssc(const int *f_id, const cs_real_t *restrict pvar, cs_real_t *restrict tsexp, cs_real_t *restrict tsimp)
Definition: cs_gui.c:3294
void uiprop(const int *const ivisls, const int *const ismago, const int *const iale, const int *const icp, const int *const iscavr)
Definition: cs_gui.c:2980
void cs_gui_properties_value(const char *property_name, double *value)
Definition: cs_gui.c:5039
void csvvva(int *const iviscv)
Definition: cs_gui.c:1988
void uitsth(const int *f_id, const cs_real_t *restrict pvar, cs_real_t *restrict tsexp, cs_real_t *restrict tsimp)
Definition: cs_gui.c:3402
void csnum2(int *const ivisse, double *const relaxp, int *const ipucou, double *const extrag, int *const imrgra, int *const nterup)
Definition: cs_gui.c:2619
#define END_C_DECLS
Definition: cs_defs.h:406
double cs_real_t
Definition: cs_defs.h:296
void uiphyv(const cs_int_t *ncel, const cs_int_t *ncelet, const cs_int_t *itherm, const cs_int_t *icp, const cs_int_t ivisls[], const cs_int_t *irovar, const cs_int_t *ivivar, const cs_int_t *iscalt, const cs_int_t iscavr[], const cs_int_t *iviscv, const cs_int_t *itempk, const cs_real_t *p0, const cs_real_t *t0, const cs_real_t *ro0, const cs_real_t *cp0, const cs_real_t *viscl0, const cs_real_t *visls0, const cs_real_t *viscv0)
Definition: cs_gui.c:4457
void csther(int *itherm, int *itpscl)
Definition: cs_gui.c:1826
#define CS_PROCF(x, y)
Definition: cs_defs.h:419
void uitsnv(const cs_real_3_t *restrict vel, cs_real_3_t *restrict tsexp, cs_real_33_t *restrict tsimp)
Definition: cs_gui.c:3127
void csisui(int *const ntsuit, int *const ileaux, int *const iccvfg)
Definition: cs_gui.c:2353
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:311
void cscfgp(int *const icfgrp)
Definition: cs_gui.c:2320
void csivis(int *const iscavr, int *const ivisls, int *const iscalt, int *const itherm, int *const itempk)
Definition: cs_gui.c:2181
void csisca(int *iscavr, const int *itherm)
Definition: cs_gui.c:2110
void csturb(int *const iturb, int *const ideuch, int *const igrake, int *const igrari, double *const xlomlg)
Definition: cs_gui.c:1877
int gui_thermal_model(void)
Definition: cs_gui.c:4998
void uinum1(double *const blencv, int *const ischcv, int *const isstpc, int *const ircflu, double *const cdtvar, int *const nitmax, double *const epsilo, int *const iresol, int *const imgrpr, int *const nswrsm)
Definition: cs_gui.c:2469
void uithsc(int *const iscalt)
Definition: cs_gui.c:2069