programmer's documentation
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-2016 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 /*----------------------------------------------------------------------------
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 *iturb,
91  int *ideuch,
92  int *igrake,
93  int *igrari,
94  double *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 *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 *iviscv);
121 
122 /*----------------------------------------------------------------------------
123  * User thermal scalar.
124  *
125  * Fortran Interface:
126  *
127  * SUBROUTINE UITHSC
128  * *****************
129  *----------------------------------------------------------------------------*/
130 
131 void CS_PROCF (uithsc, UITHSC) (void);
132 
133 /*----------------------------------------------------------------------------
134  * User scalar label.
135  *
136  * Fortran Interface:
137  *
138  * SUBROUTINE UISCSC
139  * *****************
140  *----------------------------------------------------------------------------*/
141 
142 void CS_PROCF (uiscsc, UISCSC) (void);
143 
144 /*----------------------------------------------------------------------------
145  * Constant or variable indicator for the user scalar laminar viscosity.
146  *
147  * Fortran Interface:
148  *
149  * subroutine csivis
150  * *****************
151  *----------------------------------------------------------------------------*/
152 
153 void CS_PROCF (csivis, CSIVIS) (void);
154 
155 /*----------------------------------------------------------------------------
156  * Time passing parameter.
157  *
158  * Fortran Interface:
159  *
160  * SUBROUTINE CSIDTV (IDTVAR)
161  * *****************
162  *
163  * INTEGER IDTVAR --> fixed or variable time step
164  *----------------------------------------------------------------------------*/
165 
166 void CS_PROCF(csidtv, CSIDTV) (int *idtvar);
167 
168 /*----------------------------------------------------------------------------
169  * Hydrostatic pressure parameter.
170  *
171  * Fortran Interface:
172  *
173  * SUBROUTINE CSIPHY (IPHYDR)
174  * *****************
175  *
176  * INTEGER IPHYDR --> hydrostatic pressure
177  *----------------------------------------------------------------------------*/
178 
179 void CS_PROCF (csiphy, CSIPHY) (int *iphydr);
180 
181 /*----------------------------------------------------------------------------
182  * Hydrostatic equilibrium parameter.
183  *
184  * Fortran Interface:
185  *
186  * SUBROUTINE CSCFGP (ICFGRP)
187  * *****************
188  *
189  * INTEGER ICFGRP --> hydrostatic equilibrium
190  *----------------------------------------------------------------------------*/
191 
192 void CS_PROCF (cscfgp, CSCFGP) (int *icfgrp);
193 
194 /*----------------------------------------------------------------------------
195  * Restart parameters.
196  *
197  * Fortran Interface:
198  *
199  * SUBROUTINE CSISUI
200  * *****************
201  *
202  * INTEGER NTSUIT --> checkpoint frequency
203  * INTEGER ILEAUX --> restart with auxiliary
204  * INTEGER ICCFVG --> restart with frozen field
205  *----------------------------------------------------------------------------*/
206 
207 
208 void CS_PROCF (csisui, CSISUI) (int *ntsuit,
209  int *ileaux,
210  int *iccvfg);
211 
212 /*----------------------------------------------------------------------------
213  * Time passing parameters.
214  *
215  * Fortran Interface:
216  *
217  * SUBROUTINE CSTIME
218  * *****************
219  *
220  * INTEGER INPDT0 --> zero tim step
221  * INTEGER IPTLTO --> thermal time step control
222  * INTEGER NTMABS --> iterations numbers
223  * INTEGER IDTVAR --> time step's options
224  * DOUBLE PRECISION DTREF --> time step
225  * DOUBLE PRECISION DTMIN --> minimal time step
226  * DOUBLE PRECISION DTMAX --> maximal time step
227  * DOUBLE PRECISION COUMAX --> maximal courant number
228  * DOUBLE PRECISION FOUMAX --> maximal fournier number
229  * DOUBLE PRECISION VARRDT --> max time step variation between 2 iterations
230  * DOUBLE PRECISION RELXST --> relaxation coefficient if idtvar = -1
231  *----------------------------------------------------------------------------*/
232 
233 void CS_PROCF (cstime, CSTIME) (int *inpdt0,
234  int *iptlro,
235  int *ntmabs,
236  int *idtvar,
237  double *dtref,
238  double *dtmin,
239  double *dtmax,
240  double *coumax,
241  double *foumax,
242  double *varrdt,
243  double *relxst);
244 
245 /*----------------------------------------------------------------------------
246  *
247  * Fortran Interface:
248  *
249  * SUBROUTINE UINUM1
250  * *****************
251  *
252  *----------------------------------------------------------------------------*/
253 
254 void CS_PROCF (uinum1, UINUM1) (double *blencv,
255  int *ischcv,
256  int *isstpc,
257  int *ircflu,
258  double *cdtvar,
259  double *epsilo,
260  int *nswrsm);
261 
262 /*----------------------------------------------------------------------------
263  * Global numerical parameters.
264  *
265  * Fortran Interface:
266  *
267  * SUBROUTINE CSNUM2
268  * *****************
269  *
270  * INTEGER IVISSE --> gradient transpose
271  * INTEGER RELAXP --> pressure relaxation
272  * INTEGER IPUCOU --> velocity pressure coupling
273  * INTEGER EXTRAG --> wall pressure extrapolation
274  * INTEGER IMRGRA --> gradient reconstruction
275  * INTEGER NTERUP --> piso sweep number
276  *----------------------------------------------------------------------------*/
277 
278 void CS_PROCF (csnum2, CSNUM2) ( int *ivisse,
279  double *relaxp,
280  int *ipucou,
281  double *extrag,
282  int *imrgra,
283  int *nterup);
284 
285 void CS_PROCF (csphys, CSPHYS) (const int *nmodpp,
286  int *irovar,
287  int *ivivar,
288  int *icorio,
289  double *gx,
290  double *gy,
291  double *gz,
292  double *ro0,
293  double *viscl0,
294  double *viscv0,
295  double *visls0,
296  double *cp0,
297  double *t0,
298  double *p0,
299  double *xmasmr,
300  int *itempk);
301 
302 /*----------------------------------------------------------------------------
303  * User scalar min and max values for clipping.
304  *
305  * Fortran Interface:
306  *
307  * subroutine cssca2
308  * *****************
309  *
310  * integer iturb <-- turbulence model
311  * integer iturt --> turbulent flux model
312  *----------------------------------------------------------------------------*/
313 
314 void CS_PROCF (cssca2, CSSCA2) (const int *iturb,
315  int *iturt);
316 
317 void CS_PROCF (cssca3, CSSCA3) (double *visls0,
318  double *t0,
319  double *p0,
320  double *cp0);
321 
322 /*----------------------------------------------------------------------------
323  * Turbulence initialization parameters.
324  *
325  * Fortran Interface:
326  *
327  * SUBROUTINE CSTINI
328  * *****************
329  *
330  * INTEGER UREF --> reference velocity
331  * INTEGER ALMAX --> reference length
332  *----------------------------------------------------------------------------*/
333 
334 void CS_PROCF (cstini, CSTINI) (double *uref,
335  double *almax);
336 
337 /*----------------------------------------------------------------------------
338  * Solver taking a scalar porosity into account
339  *
340  * Fortran Interface:
341  *
342  * SUBROUTINE UIIPSU
343  * *****************
344  *
345  * INTEGER IPOROS --> porosity
346  *----------------------------------------------------------------------------*/
347 
348 void CS_PROCF (uiipsu, UIIPSU) (int *iporos);
349 
350 /*----------------------------------------------------------------------------
351  * Define porosity.
352  *
353  * Fortran Interface:
354  *
355  * SUBROUTINE UIPORO
356  * *****************
357  *
358  * INTEGER IPOROS <-- porosity
359  *----------------------------------------------------------------------------*/
360 
361 void CS_PROCF (uiporo, UIPORO) (const int *ncelet,
362  const int *iporos);
363 
364 /*----------------------------------------------------------------------------
365  * User momentum source terms.
366  *
367  * Fortran Interface:
368  *
369  * subroutine uitsnv (ncelet, vel, tsexp, tsimp)
370  * *****************
371  *
372  * integer ncelet <-- number of cells with halo
373  * double precision vel <-- fluid velocity
374  * double precision tsexp --> explicit source terms
375  * double precision tsimp --> implicit source terms
376  *----------------------------------------------------------------------------*/
377 
378 void CS_PROCF(uitsnv, UITSNV)(const cs_real_3_t *restrict vel,
379  cs_real_3_t *restrict tsexp,
380  cs_real_33_t *restrict tsimp);
381 
382 
383 /*----------------------------------------------------------------------------
384  * User scalar source terms.
385  *
386  * Fortran Interface:
387  *
388  * subroutine uitssc (f_id, pvar, tsexp, tsimp)
389  * *****************
390  *
391  * integer f_id <-- field id
392  * double precision pvar <-- scalar
393  * double precision tsexp --> explicit source terms
394  * double precision tsimp --> implicit source terms
395  *----------------------------------------------------------------------------*/
396 
397 void CS_PROCF(uitssc, UITSSC)(const int *f_id,
398  const cs_real_t *restrict pvar,
399  cs_real_t *restrict tsexp,
400  cs_real_t *restrict tsimp);
401 
402 
403 /*----------------------------------------------------------------------------
404  * Thermal scalar source terms.
405  *
406  * Fortran Interface:
407  *
408  * subroutine uitsth (f_id, pvar, tsexp, tsimp)
409  * *****************
410  *
411  * integer f_id <-- field id
412  * double precision pvar <-- scalar
413  * double precision tsexp --> explicit source terms
414  * double precision tsimp --> implicit source terms
415  *----------------------------------------------------------------------------*/
416 
417 void CS_PROCF(uitsth, UITSTH)(const int *f_id,
418  const cs_real_t *restrict pvar,
419  cs_real_t *restrict tsexp,
420  cs_real_t *restrict tsimp);
421 
422 /*----------------------------------------------------------------------------
423  * Variables and user scalars initialization.
424  *
425  * Fortran Interface:
426  *
427  * subroutine uiiniv
428  * *****************
429  *
430  * integer ncelet <-- number of cells with halo
431  * integer isuite <-- restart indicator
432  * integer idarcy <-- darcy module activation
433  * integer iccfth <-- type of initialization (compressible model)
434  * double precision ro0 <-- value of density if IROVAR=0
435  * double precision cp0 <-- value of specific heat if ICP=0
436  * double precision viscl0 <-- value of viscosity if IVIVAR=0
437  * double precision uref <-- value of reference velocity
438  * double precision almax <-- value of reference length
439  * double precision xyzcen <-- cell's gravity center
440  *----------------------------------------------------------------------------*/
441 
442 void CS_PROCF(uiiniv, UIINIV)(const int *ncelet,
443  const int *isuite,
444  const int *idarcy,
445  int *iccfth,
446  const cs_real_t *ro0,
447  const cs_real_t *cp0,
448  const cs_real_t *viscl0,
449  const cs_real_t *uref,
450  const cs_real_t *almax,
451  const double *xyzcen);
452 
453 /*----------------------------------------------------------------------------
454  * User law for material Properties
455  *
456  * Fortran Interface:
457  *
458  * subroutine uiphyv
459  * *****************
460  *
461  * integer ncel <-- number of cells whithout halo
462  * integer ncelet <-- number of cells whith halo
463  * integer icp <-- pointer for specific heat Cp
464  * integer irovar <-- =1 if rho variable, =0 if rho constant
465  * integer ivivar <-- =1 if mu variable, =0 if mu constant
466  * integer iviscv <-- pointer for volumic viscosity viscv
467  * integer itempk <-- pointer for temperature (in K)
468  * double precision p0 <-- pressure reference value
469  * double precision t0 <-- temperature reference value
470  * double precision ro0 <-- density reference value
471  * double precision cp0 <-- specific heat reference value
472  * double precision viscl0 <-- dynamic viscosity reference value
473  * double precision visls0 <-- diffusion coefficient of the scalars
474  * double precision viscv0 <-- volumic viscosity
475  *----------------------------------------------------------------------------*/
476 
477 void CS_PROCF(uiphyv, UIPHYV)(const cs_int_t *ncel,
478  const cs_int_t *ncelet,
479  const cs_int_t *icp,
480  const cs_int_t *irovar,
481  const cs_int_t *ivivar,
482  const cs_int_t *iviscv,
483  const cs_int_t *itempk,
484  const cs_real_t *p0,
485  const cs_real_t *t0,
486  const cs_real_t *ro0,
487  const cs_real_t *cp0,
488  const cs_real_t *viscl0,
489  const cs_real_t *visls0,
490  const cs_real_t *viscv0);
491 
492 /*----------------------------------------------------------------------------
493  * Head losses definition
494  *
495  * Fortran Interface:
496  *
497  * subroutine uikpdc
498  * *****************
499  *
500  * integer iappel <-- number of calls during a time step
501  * integer ncelet <-- number of cells with halo
502  * integer ncepdp --> number of cells with head losses
503  * integer icepdc --> ncepdp cells number with head losses
504  * double precision ckupdc --> head losses matrix
505  *----------------------------------------------------------------------------*/
506 
507 void CS_PROCF(uikpdc, UIKPDC)(const int* iappel,
508  const int* ncelet,
509  int* ncepdp,
510  int icepdc[],
511  double ckupdc[]);
512 
513 /*----------------------------------------------------------------------------
514  * 1D profile postprocessing
515  *
516  * Fortran Interface:
517  *
518  * SUBROUTINE UIPROF
519  * *****************
520  *
521  * INTEGER NCELET <-- number of cells with halo
522  * INTEGER NCEL <-- number of cells without halo
523  * INTEGER NTMABS <-- max iterations numbers
524  * INTEGER NTCABS <-- current iteration number
525  * DOUBLE PRECISION TTCABS <-- current physical time
526  * DOUBLE PRECISION TTMABS <-- max physical time
527  * DOUBLE PRECISION TTPABS <-- physical time at calculation beginning
528  * DOUBLE PRECISION XYZCEN <-- cell's gravity center
529  *----------------------------------------------------------------------------*/
530 
531 void CS_PROCF (uiprof, UIPROF)(const int *ncelet,
532  const int *ncel,
533  const int *ntmabs,
534  const int *ntcabs,
535  const double *ttcabs,
536  const double *ttmabs,
537  const double *ttpabs,
538  const double *xyzcen);
539 
540 
541 /*----------------------------------------------------------------------------
542  * darcy model : read laws for capacity, saturation and permeability
543  *
544  * Fortran Interface:
545  *
546  * subroutine uidapp
547  * *****************
548  * integer permeability <-- permeability type
549  * integer diffusion <-- diffusion type
550  * integer gravity <-- check if gravity is taken into account
551  * double gravity_x <-- x component for gravity vector
552  * double gravity_y <-- y component for gravity vector
553  * double gravity_z <-- z component for gravity vector
554  *----------------------------------------------------------------------------*/
555 
556 void CS_PROCF (uidapp, UIDAPP) (const cs_int_t *permeability,
557  const cs_int_t *diffusion,
558  const cs_int_t *gravity,
559  const double *gravity_x,
560  const double *gravity_y,
561  const double *gravity_z);
562 
563 /*----------------------------------------------------------------------------
564  * Free memory: clean global private variables and libxml2 variables.
565  *
566  * Fortran Interface:
567  *
568  * SUBROUTINE MEMUI1
569  * *****************
570  *
571  * INTEGER NCHARB <-- number of coal
572  *----------------------------------------------------------------------------*/
573 
574 void CS_PROCF (memui1, MEMUI1) (const int *ncharb);
575 
576 /*=============================================================================
577  * Public function prototypes
578  *============================================================================*/
579 
580 /*----------------------------------------------------------------------------
581  * Get thermal scalar model.
582  *
583  * return:
584  * value of itherm
585  *----------------------------------------------------------------------------*/
586 
587 int
589 
590 /*----------------------------------------------------------------------------
591  * Define user variables through the GUI.
592  *----------------------------------------------------------------------------*/
593 
594 void
596 
597 /*-----------------------------------------------------------------------------
598  * Get initial value from property markup.
599  *
600  * parameters:
601  * property_name <-- name of the property
602  * value --> new initial value of the property
603  *----------------------------------------------------------------------------*/
604 
605 void
606 cs_gui_properties_value(const char *property_name,
607  double *value);
608 
609 /*-----------------------------------------------------------------------------
610  * Initialization choice of the reference variables parameters.
611  *
612  * parameters:
613  * name <-- parameter name
614  * value --> parameter value
615  *----------------------------------------------------------------------------*/
616 
617 void
618 cs_gui_reference_initialization(const char *param,
619  double *value);
620 
621 /*-----------------------------------------------------------------------------
622  * Selection of linear solvers.
623  *----------------------------------------------------------------------------*/
624 
625 void
627 
628 /*-----------------------------------------------------------------------------
629  * Set turbomachinery model
630  *----------------------------------------------------------------------------*/
631 
632 void
634 
635 /*-----------------------------------------------------------------------------
636  * Set turbomachinery options.
637  *----------------------------------------------------------------------------*/
638 
639 void
641 
642 /*-----------------------------------------------------------------------------
643  * Set partitioning options.
644  *----------------------------------------------------------------------------*/
645 
646 void
647 cs_gui_partition(void);
648 
649 /*-----------------------------------------------------------------------------
650  * Define parallel IO settings.
651  *----------------------------------------------------------------------------*/
652 
653 void
654 cs_gui_parallel_io(void);
655 
656 /*----------------------------------------------------------------------------
657  * Time moments definition
658  *----------------------------------------------------------------------------*/
659 
660 void
661 cs_gui_time_moments(void);
662 
663 /*-----------------------------------------------------------------------------
664  * Free memory: clean global private variables and libxml2 variables
665  *----------------------------------------------------------------------------*/
666 
667 void
668 cs_gui_clean_memory(void);
669 
670 /*----------------------------------------------------------------------------
671  * Logging output for MEI usage.
672  *----------------------------------------------------------------------------*/
673 
674 void
675 cs_gui_usage_log(void);
676 
677 /*----------------------------------------------------------------------------*/
678 
680 
681 #endif /* __CS_GUI_H__ */
void uiphyv(const cs_int_t *ncel, const cs_int_t *ncelet, const cs_int_t *icp, const cs_int_t *irovar, const cs_int_t *ivivar, 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:4619
real(c_double), pointer, save gy
Definition: cstphy.f90:65
void cs_gui_reference_initialization(const char *param, double *value)
Definition: cs_gui.c:5730
double precision, save viscv0
reference volume viscosity (noted in the equation expressing in the paragraph dedicated to iviscv) ...
Definition: ppincl.f90:728
void uiporo(const int *ncelet, const int *iporos)
Definition: cs_gui.c:3269
integer, save ncel
Definition: mesh.f90:50
#define restrict
Definition: cs_defs.h:122
void cs_gui_user_variables(void)
Definition: cs_gui.c:5634
void uiipsu(int *iporos)
Definition: cs_gui.c:3217
integer(c_int), pointer, save ivisse
take into account in the momentum equation
Definition: optcal.f90:668
void uikpdc(const int *iappel, const int *ncelet, int *ncepdp, int icepdc[], double ckupdc[])
integer(c_int), pointer, save iphydr
improve hydrostatic pressure algorithm
Definition: optcal.f90:735
integer, save icp
specific heat
Definition: numvar.f90:193
void csturb(int *iturb, int *ideuch, int *igrake, int *igrari, double *xlomlg)
Definition: cs_gui.c:2243
void uiprof(const int *ncelet, const int *ncel, const int *ntmabs, const int *ntcabs, const double *ttcabs, const double *ttmabs, const double *ttpabs, const double *xyzcen)
Definition: cs_gui.c:4893
integer, save iporos
take the porosity fomulation into account
Definition: optcal.f90:843
void cscfgp(int *icfgrp)
Definition: cs_gui.c:2584
real(c_double), pointer, save dtref
reference time step
Definition: optcal.f90:440
void csisui(int *ntsuit, int *ileaux, int *iccvfg)
Definition: cs_gui.c:2617
integer(c_int), pointer, save ntmabs
Maximum absolute time step number.
Definition: optcal.f90:401
void cs_gui_clean_memory(void)
Definition: cs_gui.c:6324
void cssca3(double *visls0, double *t0, double *p0, double *cp0)
Definition: cs_gui.c:3096
integer, save ntsuit
saving period of the restart filesy5
Definition: entsor.f90:78
real(c_double), pointer, save ttpabs
Absolute time value for previous calculation.
Definition: optcal.f90:407
real(c_double), pointer, save uref
the characteristic flow velocity, used for the initialization of the turbulence. Negative value: not ...
Definition: cstphy.f90:521
integer, dimension(:), allocatable icepdc
number of the ncepdc cells in which a pressure drop is imposed. See {iicepd} and the user subroutine ...
Definition: pointe.f90:262
#define BEGIN_C_DECLS
Definition: cs_defs.h:419
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
void cs_gui_turbomachinery(void)
Definition: cs_gui.c:5858
void cs_gui_parallel_io(void)
Definition: cs_gui.c:6151
integer idarcy
pointer to specify richards model
Definition: ppincl.f90:243
integer(c_int), pointer, save idtvar
option for a variable time step
Definition: optcal.f90:437
real(c_double), pointer, save gz
Definition: cstphy.f90:65
void csphys(const int *nmodpp, int *irovar, int *ivivar, int *icorio, double *gx, double *gy, double *gz, double *ro0, double *viscl0, double *viscv0, double *visls0, double *cp0, double *t0, double *p0, double *xmasmr, int *itempk)
Definition: cs_gui.c:2861
int cs_gui_thermal_model(void)
Definition: cs_gui.c:5597
void uinum1(double *blencv, int *ischcv, int *isstpc, int *ircflu, double *cdtvar, double *epsilo, int *nswrsm)
Definition: cs_gui.c:2733
real(c_double), pointer, save foumax
maximum Fourier number (when idtvar is different from 0)
Definition: optcal.f90:449
integer, dimension(nvarmx), save ischcv
type of convective scheme
Definition: optcal.f90:252
integer, dimension(nvarmx), save isstpc
switch off the slope test:
Definition: optcal.f90:257
integer, save ivivar
variable viscosity field :
Definition: optcal.f90:86
void csnum2(int *ivisse, double *relaxp, int *ipucou, double *extrag, int *imrgra, int *nterup)
Definition: cs_gui.c:2831
real(c_double), pointer, save xmasmr
molar mass of the perfect gas in (if ieos=1)
Definition: cstphy.f90:181
integer(c_int), pointer, save igrake
buoyant term in
Definition: optcal.f90:578
real(c_double), pointer, save cp0
reference specific heat.
Definition: cstphy.f90:176
integer, save isuite
Definition: optcal.f90:381
void cs_gui_usage_log(void)
Definition: cs_gui.c:6353
real(c_double), pointer, save ttmabs
Maximum absolute time.
Definition: optcal.f90:414
integer, save ncelet
Definition: mesh.f90:46
void uiinit(void)
Definition: cs_gui.c:2169
integer, save ncharb
Number of coals.
Definition: cpincl.f90:49
void cs_gui_partition(void)
Definition: cs_gui.c:6004
integer(c_int), pointer, save nterup
number of interations on the pressure-velocity coupling on Navier-Stokes (for the PISO algorithm) ...
Definition: optcal.f90:112
real(c_double), pointer, save ttcabs
Current absolute time. In case of restart, this is equal to ttpabs + additional computed time...
Definition: optcal.f90:411
void cs_gui_turbomachinery_rotor(void)
Definition: cs_gui.c:5893
real(c_double), pointer, save dtmin
minimum value of dt (when idtvar is different from 0). Take dtmin = min (ld/ud, sqrt(lt/(gdelta rho/r...
Definition: optcal.f90:456
double precision, dimension(:,:), pointer xyzcen
Definition: mesh.f90:114
double precision, dimension(nvarmx), save blencv
percentage of upwind:
Definition: optcal.f90:247
integer(c_int), pointer, save iccvfg
Definition: optcal.f90:699
real(c_double), pointer, save xlomlg
mixing length for the mixing length model
Definition: cstphy.f90:526
void csivis(void)
Definition: cs_gui.c:2441
integer(c_int), pointer, save itherm
thermal model
Definition: optcal.f90:490
void cscpva(int *icp)
Definition: cs_gui.c:2330
real(c_double), pointer, save p0
reference pressure for the total pressure. except with the compressible module, the total pressure i...
Definition: cstphy.f90:115
double precision, dimension(nscamx), save visls0
visls0 : viscosity of scalars if constant
Definition: optcal.f90:966
integer, save icfgrp
indicates if the boundary conditions should take into account (=1) or not (=0) the hydrostatic balanc...
Definition: ppincl.f90:768
integer(c_int), pointer, save iturb
Definition: optcal.f90:529
real(c_double), pointer, save dtmax
maximum value of dt (when idtvar is different from 0). Take dtmax = max (ld/ud, sqrt(lt/(gdelta rho/r...
Definition: optcal.f90:460
void csidtv(int *idtvar)
Definition: cs_gui.c:2516
integer(c_int), pointer, save itpscl
temperature scale
Definition: optcal.f90:496
real(c_double), pointer, save t0
reference temperature.
Definition: cstphy.f90:161
integer, save irovar
variable density field :
Definition: optcal.f90:81
real(c_double), pointer, save gx
Gravity.
Definition: cstphy.f90:65
double precision, dimension(:,:), allocatable ckupdc
value of the coefficients of the pressure drop tensor of the ncepdc cells in which a pressure drop is...
Definition: pointe.f90:271
integer(c_int), pointer, save ipucou
Pseudo coupled pressure-velocity solver.
Definition: optcal.f90:693
void csiphy(int *iphydr)
Definition: cs_gui.c:2552
integer, save itempk
temperature deduced from the specific total energy
Definition: ppincl.f90:672
void uiiniv(const int *ncelet, const int *isuite, const int *idarcy, 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 *xyzcen)
Definition: cs_gui.c:3799
cs_real_t cs_real_3_t[3]
vector of 3 floating-point values
Definition: cs_defs.h:307
integer(c_int), pointer, save icorio
Coriolis effects.
Definition: cstphy.f90:68
void cstime(int *inpdt0, int *iptlro, int *ntmabs, int *idtvar, double *dtref, double *dtmin, double *dtmax, double *coumax, double *foumax, double *varrdt, double *relxst)
Definition: cs_gui.c:2654
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:3575
double precision, dimension(nvarmx), save cdtvar
multiplicator coefficient for the time step of each variable
Definition: optcal.f90:466
void cssca2(const int *iturb, int *iturt)
Definition: cs_gui.c:3016
void cs_gui_properties_value(const char *property_name, double *value)
Definition: cs_gui.c:5703
void cstini(double *uref, double *almax)
Definition: cs_gui.c:3182
real(c_double), pointer, save relxst
relaxation coefficient for the steady algorithm
Definition: optcal.f90:472
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:3684
#define END_C_DECLS
Definition: cs_defs.h:420
integer, save ileaux
Definition: optcal.f90:381
double cs_real_t
Definition: cs_defs.h:296
integer(c_int), pointer, save ntcabs
Current absolute time step number. In case of restart, this is equal to ntpabs + number of new iterat...
Definition: optcal.f90:398
real(c_double), pointer, save varrdt
relative allowed variation of dt (when idtvar is different from 0)
Definition: optcal.f90:452
integer(c_int), pointer, save inpdt0
indicator "zero time step"
Definition: optcal.f90:425
void uidapp(const cs_int_t *permeability, const cs_int_t *diffusion, const cs_int_t *gravity, const double *gravity_x, const double *gravity_y, const double *gravity_z)
Definition: cs_gui.c:5188
void csther(int *itherm, int *itpscl)
Definition: cs_gui.c:2192
#define CS_PROCF(x, y)
Definition: cs_defs.h:433
real(c_double), pointer, save coumax
maximum Courant number (when idtvar is different from 0)
Definition: optcal.f90:443
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:3426
real(c_double), pointer, save ro0
reference density. Negative value: not initialized. Its value is not used in gas or coal combustion m...
Definition: cstphy.f90:99
void memui1(const int *ncharb)
Definition: cs_gui.c:5579
double precision, dimension(nvarmx), save epsilo
relative precision of the linear solver
Definition: optcal.f90:352
cs_real_t cs_real_33_t[3][3]
3x3 matrix of floating-point values
Definition: cs_defs.h:311
void csvvva(int *iviscv)
Definition: cs_gui.c:2354
real(c_double), pointer, save viscl0
reference molecular dynamic viscosity. Negative value: not initialized.
Definition: cstphy.f90:106
integer, dimension(nscamx), save iturt
turbulent flux model for for any scalar , iturt(isca)
Definition: optcal.f90:638
void uiscsc(void)
Definition: cs_gui.c:2415
void cs_gui_time_moments(void)
Definition: cs_gui.c:6243
integer, dimension(nvarmx), save nswrsm
max number of iteration for the iterative process used to solved the convection diffusion equations ...
Definition: optcal.f90:333
integer(c_int), pointer, save iptlro
Clip the time step with respect to the buoyant effects.
Definition: optcal.f90:430
real(c_double), pointer, save almax
is a characteristic macroscopic length of the domain, used for the initialization of the turbulence a...
Definition: cstphy.f90:512
integer(c_int), pointer, save igrari
buoyant term in
Definition: optcal.f90:583
integer, save iviscv
additional property:
Definition: ppincl.f90:696
double precision, dimension(nvarmx), save extrag
gradient extrapolation at the boundary
Definition: optcal.f90:301
void uithsc(void)
Definition: cs_gui.c:2376
integer(c_int), pointer, save imrgra
type of gradient reconstruction
Definition: optcal.f90:276
void cs_gui_linear_solvers(void)
Definition: cs_gui.c:5753
integer(c_int), pointer, save ideuch
Wall functions.
Definition: optcal.f90:553
integer, dimension(nvarmx), save ircflu
face flux reconstruction:
Definition: optcal.f90:317