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  * Solver taking a scalar porosity into account
422  *
423  * Fortran Interface:
424  *
425  * SUBROUTINE UIIPSU
426  * *****************
427  *
428  * INTEGER IPOROS --> porosity
429  *----------------------------------------------------------------------------*/
430 
431 void CS_PROCF (uiipsu, UIIPSU) (int *iporos);
432 
433 /*----------------------------------------------------------------------------
434  * Define porosity.
435  *
436  * Fortran Interface:
437  *
438  * SUBROUTINE UIPORO
439  * *****************
440  *
441  * INTEGER IPOROS <-- porosity
442  *----------------------------------------------------------------------------*/
443 
444 void CS_PROCF (uiporo, UIPORO) (const int *ncelet,
445  const int *iporos);
446 
447 /*----------------------------------------------------------------------------
448  * User momentum source terms.
449  *
450  * Fortran Interface:
451  *
452  * subroutine uitsnv (ncelet, vel, tsexp, tsimp)
453  * *****************
454  *
455  * integer ncelet <-- number of cells with halo
456  * double precision vel <-- fluid velocity
457  * double precision tsexp --> explicit source terms
458  * double precision tsimp --> implicit source terms
459  *----------------------------------------------------------------------------*/
460 
461 void CS_PROCF(uitsnv, UITSNV)(const cs_real_3_t *restrict vel,
462  cs_real_3_t *restrict tsexp,
463  cs_real_33_t *restrict tsimp);
464 
465 
466 /*----------------------------------------------------------------------------
467  * User scalar source terms.
468  *
469  * Fortran Interface:
470  *
471  * subroutine uitssc (f_id, pvar, tsexp, tsimp)
472  * *****************
473  *
474  * integer f_id <-- field id
475  * double precision pvar <-- scalar
476  * double precision tsexp --> explicit source terms
477  * double precision tsimp --> implicit source terms
478  *----------------------------------------------------------------------------*/
479 
480 void CS_PROCF(uitssc, UITSSC)(const int *f_id,
481  const cs_real_t *restrict pvar,
482  cs_real_t *restrict tsexp,
483  cs_real_t *restrict tsimp);
484 
485 
486 /*----------------------------------------------------------------------------
487  * Thermal scalar source terms.
488  *
489  * Fortran Interface:
490  *
491  * subroutine uitsth (f_id, pvar, tsexp, tsimp)
492  * *****************
493  *
494  * integer f_id <-- field id
495  * double precision pvar <-- scalar
496  * double precision tsexp --> explicit source terms
497  * double precision tsimp --> implicit source terms
498  *----------------------------------------------------------------------------*/
499 
500 void CS_PROCF(uitsth, UITSTH)(const int *f_id,
501  const cs_real_t *restrict pvar,
502  cs_real_t *restrict tsexp,
503  cs_real_t *restrict tsimp);
504 
505 /*----------------------------------------------------------------------------
506  * Variables and user scalars initialization.
507  *
508  * Fortran Interface:
509  *
510  * subroutine uiiniv
511  * *****************
512  *
513  * integer ncelet <-- number of cells with halo
514  * integer isuite <-- restart indicator
515  * integer iccfth <-- type of initialisation(compressible model)
516  * double precision ro0 <-- value of density if IROVAR=0
517  * double precision cp0 <-- value of specific heat if ICP=0
518  * double precision viscl0 <-- value of viscosity if IVIVAR=0
519  * double precision uref <-- value of reference velocity
520  * double precision almax <-- value of reference length
521  * double precision xyzcen <-- cell's gravity center
522  *----------------------------------------------------------------------------*/
523 
524 void CS_PROCF(uiiniv, UIINIV)(const int *ncelet,
525  const int *isuite,
526  int *iccfth,
527  const cs_real_t *ro0,
528  const cs_real_t *cp0,
529  const cs_real_t *viscl0,
530  const cs_real_t *uref,
531  const cs_real_t *almax,
532  const double *const xyzcen);
533 
534 /*----------------------------------------------------------------------------
535  * User law for material Properties
536  *
537  * Fortran Interface:
538  *
539  * SUBROUTINE UIPHYV (NCELET, ISCA, RTP)
540  * *****************
541  *
542  * INTEGER NCEL <-- number of cells whithout halo
543  * INTEGER NCELET <-- number of cells whith halo
544  * INTEGER ICP <-- pointer for predifined heat Cp
545  * INTEGER IVISLS <-- pointer for Lambda/Cp
546  * INTEGER IROVAR <-- =1 if rho variable, =0 if rho constant
547  * INTEGER IVIVAR <-- =1 if mu variable, =0 if mu constant
548  * INTEGER ISCALT <-- pointer for the thermal scalar in ISCA
549  * INTEGER ISCAVR <-- scalars that are variance
550  * INTEGER IVISCV <-- pointer for volumic viscosity viscv
551  * INTEGER ITEMPK <-- pointer for temperature (in K)
552  * DOUBLE PRECISION P0 <-- pressure reference value
553  * DOUBLE PRECISION T0 <-- temperature reference value
554  * DOUBLE PRECISION RO0 <-- density reference value
555  * DOUBLE PRECISION CP0 <-- specific heat reference value
556  * DOUBLE PRECISION VISCL0 <-- dynamic viscosity reference value
557  * DOUBLE PRECISION VISLS0 <-- diffusion coefficient of the scalars
558  * DOUBLE PRECISION VISCV0 <-- volumic viscosity
559  *----------------------------------------------------------------------------*/
560 
561 void CS_PROCF(uiphyv, UIPHYV)(const cs_int_t *ncel,
562  const cs_int_t *ncelet,
563  const cs_int_t *itherm,
564  const cs_int_t *icp,
565  const cs_int_t ivisls[],
566  const cs_int_t *irovar,
567  const cs_int_t *ivivar,
568  const cs_int_t *iscalt,
569  const cs_int_t iscavr[],
570  const cs_int_t *iviscv,
571  const cs_int_t *itempk,
572  const cs_real_t *p0,
573  const cs_real_t *t0,
574  const cs_real_t *ro0,
575  const cs_real_t *cp0,
576  const cs_real_t *viscl0,
577  const cs_real_t *visls0,
578  const cs_real_t *viscv0);
579 
580 /*----------------------------------------------------------------------------
581  * Head losses definition
582  *
583  * Fortran Interface:
584  *
585  * subroutine uikpdc
586  * *****************
587  *
588  * integer iappel <-- number of calls during a time step
589  * integer ncelet <-- number of cells with halo
590  * integer ncepdp --> number of cells with head losses
591  * integer icepdc --> ncepdp cells number with head losses
592  * double precision ckupdc --> head losses matrix
593  *----------------------------------------------------------------------------*/
594 
595 void CS_PROCF(uikpdc, UIKPDC)(const int* iappel,
596  const int* ncelet,
597  int* ncepdp,
598  int icepdc[],
599  double ckupdc[]);
600 
601 /*----------------------------------------------------------------------------
602  * 1D profile postprocessing
603  *
604  * Fortran Interface:
605  *
606  * SUBROUTINE UIPROF
607  * *****************
608  *
609  * INTEGER NCELET <-- number of cells with halo
610  * INTEGER NCEL <-- number of cells without halo
611  * INTEGER NTMABS <-- max iterations numbers
612  * INTEGER NTCABS <-- current iteration number
613  * DOUBLE PRECISION TTCABS <-- current physical time
614  * DOUBLE PRECISION TTMABS <-- max physical time
615  * DOUBLE PRECISION TTPABS <-- physical time at calculation beginning
616  * DOUBLE PRECISION XYZCEN <-- cell's gravity center
617  *----------------------------------------------------------------------------*/
618 
619 void CS_PROCF (uiprof, UIPROF)(const int *const ncelet,
620  const int *const ncel,
621  const int *const ntmabs,
622  const int *const ntcabs,
623  const double *const ttcabs,
624  const double *const ttmabs,
625  const double *const ttpabs,
626  const double *const xyzcen);
627 
628 /*----------------------------------------------------------------------------
629  * Free memory: clean global private variables and libxml2 variables.
630  *
631  * Fortran Interface:
632  *
633  * SUBROUTINE MEMUI1
634  * *****************
635  *
636  * INTEGER NCHARB <-- number of coal
637  *----------------------------------------------------------------------------*/
638 
639 void CS_PROCF (memui1, MEMUI1) (const int *const ncharb);
640 
641 /*=============================================================================
642  * Public function prototypes
643  *============================================================================*/
644 
645 /*----------------------------------------------------------------------------
646  * Get thermal scalar model.
647  *
648  * return:
649  * value of itherm
650  *----------------------------------------------------------------------------*/
651 
652 int
653 gui_thermal_model(void);
654 
655 /*-----------------------------------------------------------------------------
656  * Get initial value from property markup.
657  *
658  * parameters:
659  * property_name <-- name of the property
660  * value --> new initial value of the property
661  *----------------------------------------------------------------------------*/
662 
663 void
664 cs_gui_properties_value(const char *property_name,
665  double *value);
666 
667 /*-----------------------------------------------------------------------------
668  * Initialization choice of the reference variables parameters.
669  *
670  * parameters:
671  * name <-- parameter name
672  * value --> parameter value
673  *----------------------------------------------------------------------------*/
674 
675 void
676 cs_gui_reference_initialization(const char *param,
677  double *value);
678 
679 /*-----------------------------------------------------------------------------
680  * Set partitioning options.
681  *----------------------------------------------------------------------------*/
682 
683 void
684 cs_gui_partition(void);
685 
686 /*-----------------------------------------------------------------------------
687  * Define parallel IO settings.
688  *----------------------------------------------------------------------------*/
689 
690 void
691 cs_gui_parallel_io(void);
692 
693 /*-----------------------------------------------------------------------------
694  * Free memory: clean global private variables and libxml2 variables
695  *----------------------------------------------------------------------------*/
696 
697 void
698 cs_gui_clean_memory(void);
699 
700 /*----------------------------------------------------------------------------
701  * Logging output for MEI usage.
702  *----------------------------------------------------------------------------*/
703 
704 void
705 cs_gui_usage_log(void);
706 
707 /*----------------------------------------------------------------------------*/
708 
710 
711 #endif /* __CS_GUI_H__ */
void cs_gui_reference_initialization(const char *param, double *value)
Definition: cs_gui.c:5269
void uiporo(const int *ncelet, const int *iporos)
Definition: cs_gui.c:3079
#define restrict
Definition: cs_defs.h:122
void uiipsu(int *iporos)
Definition: cs_gui.c:3030
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:2998
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:2916
void cs_gui_clean_memory(void)
Definition: cs_gui.c:5531
void csnsca(int *const nscaus)
Definition: cs_gui.c:2055
#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:2007
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:2693
void cs_gui_parallel_io(void)
Definition: cs_gui.c:5439
void uimoyt(const int *const ndgmox, int *const ntdmom, int *const imoold, int *const idfmom)
Definition: cs_gui.c:3272
void cs_gui_usage_log(void)
Definition: cs_gui.c:5568
void uiinit(void)
Definition: cs_gui.c:1840
void cs_gui_partition(void)
Definition: cs_gui.c:5292
void memui1(const int *const ncharb)
Definition: cs_gui.c:5183
void csiphy(int *const iphydr)
Definition: cs_gui.c:2331
void uiscau(void)
Definition: cs_gui.c:2074
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:2433
void csidtv(int *const idtvar)
Definition: cs_gui.c:2295
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:4893
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:3751
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:2844
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:3497
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:3226
void cs_gui_properties_value(const char *property_name, double *value)
Definition: cs_gui.c:5242
void csvvva(int *const iviscv)
Definition: cs_gui.c:2031
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:3605
void csnum2(int *const ivisse, double *const relaxp, int *const ipucou, double *const extrag, int *const imrgra, int *const nterup)
Definition: cs_gui.c:2662
#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:4660
void csther(int *itherm, int *itpscl)
Definition: cs_gui.c:1869
#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:3330
void csisui(int *const ntsuit, int *const ileaux, int *const iccvfg)
Definition: cs_gui.c:2396
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:2363
void csivis(int *const iscavr, int *const ivisls, int *const iscalt, int *const itherm, int *const itempk)
Definition: cs_gui.c:2224
void csisca(int *iscavr, const int *itherm)
Definition: cs_gui.c:2153
void csturb(int *const iturb, int *const ideuch, int *const igrake, int *const igrari, double *const xlomlg)
Definition: cs_gui.c:1920
int gui_thermal_model(void)
Definition: cs_gui.c:5201
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:2512
void uithsc(int *const iscalt)
Definition: cs_gui.c:2112