src/gui/cs_gui.h Source File

| programmer's documentation

- Main Page
- Related Pages
- Modules
- Data Structures
- Files

- File List
- Globals

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-2013 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
38 BEGIN_C_DECLS
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 thermal scalar.
137 *
138 * Fortran Interface:
139 *
140 * SUBROUTINE UITHSC
141 * *****************
142 *
143 * INTEGER ISCALT --> thermal scalars number
144 *----------------------------------------------------------------------------*/
145
146 void CS_PROCF (uithsc, UITHSC) (int *const iscalt);
147
148 /*----------------------------------------------------------------------------
149 * User scalars which are variance.
150 *
151 * Fortran Interface:
152 *
153 * SUBROUTINE CSISCA (ISCAVR)
154 * *****************
155 *
156 * INTEGER ISCAVR --> user scalars variance array
157 * integer itherm <-- type of thermal model
158 *----------------------------------------------------------------------------*/
159
160 void CS_PROCF (csisca, CSISCA) ( int *const iscavr,
161 int *const itherm,
162 const int *const iscapp);
163
164 /*----------------------------------------------------------------------------
165 * Constant or variable indicator for the user scalar laminar viscosity.
166 *
167 * Fortran Interface:
168 *
169 * SUBROUTINE CSIVIS
170 * *****************
171 *
172 * INTEGER ISCAVR <-> number of the related variance if any
173 * INTEGER IVISLS --> indicator for the user scalar viscosity
174 * INTEGER ISCALT <-> number of the user thermal scalar if any
175 * INTEGER ISCSTH <-> type of the user thermal scalar
176 * INTEGER ITEMPK --> rtp index for temperature (in K)
177 *----------------------------------------------------------------------------*/
178
179 /*----------------------------------------------------------------------------
180 * Constant or variable indicator for the user scalar laminar viscosity.
181 *
182 * Fortran Interface:
183 *
184 * subroutine csivis (iscavr, ivisls, iscalt, itherm, itempk)
185 * *****************
186 *
187 * integer iscavr <--> number of the related variance if any
188 * integer ivisls <-- indicator for the user scalar viscosity
189 * integer iscalt <--> number of the user thermal scalar if any
190 * integer itherm <--> type of thermal model
191 * integer itempk --> rtp index for temperature (in K)
192 *----------------------------------------------------------------------------*/
193
194 void CS_PROCF (csivis, CSIVIS) (int *const iscavr,
195 int *const ivisls,
196 int *const iscalt,
197 int *const itherm,
198 int *const itempk);
199
200 /*----------------------------------------------------------------------------
201 * Time passing parameter.
202 *
203 * Fortran Interface:
204 *
205 * SUBROUTINE CSIDTV (IDTVAR)
206 * *****************
207 *
208 * INTEGER IDTVAR --> fixed or variable time step
209 *----------------------------------------------------------------------------*/
210
211 void CS_PROCF(csidtv, CSIDTV) (int *const idtvar);
212
213 /*----------------------------------------------------------------------------
214 * Hydrostatic pressure parameter.
215 *
216 * Fortran Interface:
217 *
218 * SUBROUTINE CSIPHY (IPHYDR)
219 * *****************
220 *
221 * INTEGER IPHYDR --> hydrostatic pressure
222 *----------------------------------------------------------------------------*/
223
224 void CS_PROCF (csiphy, CSIPHY) (int *const iphydr);
225
226 /*----------------------------------------------------------------------------
227 * Hydrostatic equilibrium parameter.
228 *
229 * Fortran Interface:
230 *
231 * SUBROUTINE CSCFGP (ICFGRP)
232 * *****************
233 *
234 * INTEGER ICFGRP --> hydrostatic equilibrium
235 *----------------------------------------------------------------------------*/
236
237 void CS_PROCF (cscfgp, CSCFGP) (int *const icfgrp);
238
239 /*----------------------------------------------------------------------------
240 *
241 * SUBROUTINE CSVNUM()
242 * *****************
243 *----------------------------------------------------------------------------*/
244
245 void CS_PROCF (csvnum, CSVNUM) (const int *const nvar,
246 const int *const iu,
247 const int *const iv,
248 const int *const iw,
249 const int *const ipr,
250 const int *const iturb,
251 const int *const ik,
252 const int *const iep,
253 const int *const ir11,
254 const int *const ir22,
255 const int *const ir33,
256 const int *const ir12,
257 const int *const ir13,
258 const int *const ir23,
259 const int *const iomg,
260 const int *const iphi,
261 const int *const ifb,
262 const int *const ial,
263 const int *const inusa,
264 const int *const iale,
265 const int *const iuma,
266 const int *const ivma,
267 const int *const iwma,
268 const int *const isca,
269 const int *const iscapp,
270 const int *const itherm);
271
272 /*----------------------------------------------------------------------------
273 * Restart parameters.
274 *
275 * Fortran Interface:
276 *
277 * SUBROUTINE CSISUI
278 * *****************
279 *
280 * INTEGER NTSUIT --> checkpoint frequency
281 * INTEGER ILEAUX --> restart with auxiliary
282 * INTEGER ICCFVG --> restart with frozen field
283 *----------------------------------------------------------------------------*/
284
285
286 void CS_PROCF (csisui, CSISUI) (int *const ntsuit,
287 int *const ileaux,
288 int *const iccvfg);
289
290 /*----------------------------------------------------------------------------
291 * Time passing parameters.
292 *
293 * Fortran Interface:
294 *
295 * SUBROUTINE CSTIME
296 * *****************
297 *
298 * INTEGER INPDT0 --> zero tim step
299 * INTEGER IPTLTO --> thermal time step control
300 * INTEGER NTMABS --> iterations numbers
301 * INTEGER IDTVAR --> time step's options
302 * DOUBLE PRECISION DTREF --> time step
303 * DOUBLE PRECISION DTMIN --> minimal time step
304 * DOUBLE PRECISION DTMAX --> maximal time step
305 * DOUBLE PRECISION COUMAX --> maximal courant number
306 * DOUBLE PRECISION FOUMAX --> maximal fournier number
307 * DOUBLE PRECISION VARRDT --> max time step variation between 2 iterations
308 * DOUBLE PRECISION RELXST --> relaxation coefficient if idtvar = -1
309 *----------------------------------------------------------------------------*/
310
311 void CS_PROCF (cstime, CSTIME) (int *const inpdt0,
312 int *const iptlro,
313 int *const ntmabs,
314 int *const idtvar,
315 double *const dtref,
316 double *const dtmin,
317 double *const dtmax,
318 double *const coumax,
319 double *const foumax,
320 double *const varrdt,
321 double *const relxst);
322
323 /*----------------------------------------------------------------------------
324 *
325 * Fortran Interface:
326 *
327 * SUBROUTINE UINUM1
328 * *****************
329 *
330 *----------------------------------------------------------------------------*/
331
332 void CS_PROCF (uinum1, UINUM1) (const int *const isca,
333 const int *const iscapp,
334 double *const blencv,
335 int *const ischcv,
336 int *const isstpc,
337 int *const ircflu,
338 double *const cdtvar,
339 int *const nitmax,
340 double *const epsilo,
341 int *const iresol,
342 int *const imgrpr,
343 int *const nswrsm);
344
345 /*----------------------------------------------------------------------------
346 * Global numerical parameters.
347 *
348 * Fortran Interface:
349 *
350 * SUBROUTINE CSNUM2
351 * *****************
352 *
353 * INTEGER IVISSE --> gradient transpose
354 * INTEGER RELAXP --> pressure relaxation
355 * INTEGER IPUCOU --> velocity pressure coupling
356 * INTEGER EXTRAG --> wall pressure extrapolation
357 * INTEGER IMRGRA --> gradient reconstruction
358 * INTEGER NTERUP --> piso sweep number
359 *----------------------------------------------------------------------------*/
360
361 void CS_PROCF (csnum2, CSNUM2) ( int *const ivisse,
362 double *const relaxp,
363 int *const ipucou,
364 double *const extrag,
365 int *const imrgra,
366 int *const nterup);
367
368 void CS_PROCF (csphys, CSPHYS) (const int *const nmodpp,
369 int *const irovar,
370 int *const ivivar,
371 int *const icorio,
372 double *const gx,
373 double *const gy,
374 double *const gz,
375 double *const omegax,
376 double *const omegay,
377 double *const omegaz,
378 double *const ro0,
379 double *const viscl0,
380 double *const viscv0,
381 double *const visls0,
382 double *const cp0,
383 double *const t0,
384 double *const p0,
385 double *const xmasmr,
386 int *const itempk);
387
388 /*----------------------------------------------------------------------------
389 * User scalar min and max values for clipping.
390 *
391 * Fortran Interface:
392 *
393 * subroutine cssca2 (iscalt, iscavr, scamin, scamax)
394 * *****************
395 *
396 * integer iscalt <-- index of the thermal scalar
397 * integer iscavr <-- number of the related variance if any
398 * double precision scamin --> user scalar min array
399 * double precision scamax --> user scalar max array
400 *----------------------------------------------------------------------------*/
401
402 void CS_PROCF (cssca2, CSSCA2) (const int *const iscalt,
403 const int *const iscavr,
404 double *const scamin,
405 double *const scamax);
406
407 /*----------------------------------------------------------------------------
408 * Read reference dynamic and user scalar viscosity
409 *----------------------------------------------------------------------------*/
410
411 void CS_PROCF (cssca3, CSSCA3) (const int *const itherm,
412 const int *const iscalt,
413 const int *const iscavr,
414 double *const visls0,
415 double *const t0,
416 double *const p0);
417
418 /*----------------------------------------------------------------------------
419 * Array of properties used in the calculation
420 *----------------------------------------------------------------------------*/
421
422 void CS_PROCF (uiprop, UIPROP) (const int *const irom,
423 const int *const iviscl,
424 const int *const ivisct,
425 const int *const ivisls,
426 const int *const icour,
427 const int *const ifour,
428 const int *const ismago,
429 const int *const iale,
430 const int *const icp,
431 const int *const iscalt,
432 const int *const iscavr,
433 const int *const iprtot,
434 const int *const ipppro,
435 const int *const ipproc,
436 const int *const icmome,
437 const int *const ipptx,
438 const int *const ippty,
439 const int *const ipptz,
440 const int *const ippdt,
441 const int *const ivisma,
442 const int *const idtvar,
443 const int *const ipucou,
444 const int *const iappel);
445
446 /*----------------------------------------------------------------------------
447 * Temporal averaging treatment
448 *----------------------------------------------------------------------------*/
449
450 void CS_PROCF (uimoyt, UIMOYT) (const int *const ndgmox,
451 int *const ntdmom,
452 int *const imoold,
453 int *const idfmom);
454
455 /*----------------------------------------------------------------------------
456 * Turbulence initialization parameters.
457 *
458 * Fortran Interface:
459 *
460 * SUBROUTINE CSTINI
461 * *****************
462 *
463 * INTEGER UREF --> reference velocity
464 * INTEGER ALMAX --> reference length
465 *----------------------------------------------------------------------------*/
466
467 void CS_PROCF (cstini, CSTINI) (double *const uref,
468 double *const almax);
469
470 void CS_PROCF(fcnmva, FCNMVA)
471 (
472 const char *const fstr, /* Fortran string */
473 int *const len, /* String Length */
474 int *const var_id /* Variable Id (1 to n) */
475 CS_ARGF_SUPP_CHAINE
476 );
477
478 void CS_PROCF(cfnmva, CFNMVA)
479 (
480 char *const fstr, /* Fortran string */
481 int *const len, /* String Length */
482 int *const var_id /* Variable Id (1 to n) */
483 CS_ARGF_SUPP_CHAINE
484 );
485
486 void CS_PROCF(nvamem, NVAMEM) (void);
487
488 /*----------------------------------------------------------------------------
489 * User momentum source terms.
490 *
491 * Fortran Interface:
492 *
493 * subroutine uitsnv (ncelet, vel, tsexp, tsimp)
494 * *****************
495 *
496 * integer ncelet <-- number of cells with halo
497 * double precision vel <-- fluid velocity
498 * double precision tsexp --> explicit source terms
499 * double precision tsimp --> implicit source terms
500 *----------------------------------------------------------------------------*/
501
502 void CS_PROCF(uitsnv, UITSNV)(const cs_real_3_t *restrict vel,
503 cs_real_3_t *restrict tsexp,
504 cs_real_33_t *restrict tsimp);
505
506
507 /*----------------------------------------------------------------------------
508 * User scalar source terms.
509 *
510 * Fortran Interface:
511 *
512 * subroutine uitssc (iscal, pvar, tsexp, tsimp)
513 * *****************
514 *
515 * integer iscal <-- index of the corresponding scalar
516 * double precision pvar <-- scalar
517 * double precision tsexp --> explicit source terms
518 * double precision tsimp --> implicit source terms
519 *----------------------------------------------------------------------------*/
520
521 void CS_PROCF(uitssc, UITSSC)(const int *iscal,
522 const cs_real_t *restrict pvar,
523 cs_real_t *restrict tsexp,
524 cs_real_t *restrict tsimp);
525
526
527 /*----------------------------------------------------------------------------
528 * Thermal scalar source terms.
529 *
530 * Fortran Interface:
531 *
532 * subroutine uitsth (iscal, pvar, tsexp, tsimp)
533 * *****************
534 *
535 * integer iscal <-- index of the corresponding scalar
536 * double precision pvar <-- scalar
537 * double precision tsexp --> explicit source terms
538 * double precision tsimp --> implicit source terms
539 *----------------------------------------------------------------------------*/
540
541 void CS_PROCF(uitsth, UITSTH)(const int *iscal,
542 const cs_real_t *restrict pvar,
543 cs_real_t *restrict tsexp,
544 cs_real_t *restrict tsimp);
545
546 /*----------------------------------------------------------------------------
547 * Variables and user scalars initialization.
548 *
549 * Fortran Interface:
550 *
551 * subroutine uiiniv
552 * *****************
553 *
554 * integer ncelet <-- number of cells with halo
555 * integer isuite <-- restart indicator
556 * integer isca <-- indirection array for scalar number
557 * integer iscold <-- scalar number for restart
558 * integer iccfth <-- type of initialisation(compressible model)
559 * integer ipr <-- rtp index for pressure
560 * integer iscalt <-- index of the thermal scalar
561 * integer itempk <-- rtp index for temperature (in K)
562 * integer ienerg <-- rtp index for energy total
563 * double precision ro0 <-- value of density if IROVAR=0
564 * double precision cp0 <-- value of specific heat if ICP=0
565 * double precision viscl0 <-- value of viscosity if IVIVAR=0
566 * double precision uref <-- value of reference velocity
567 * double precision almax <-- value of reference length
568 * double precision xyzcen <-- cell's gravity center
569 * double precision rtp --> variables and scalars array
570 *----------------------------------------------------------------------------*/
571
572 void CS_PROCF(uiiniv, UIINIV)(const int *ncelet,
573 const int *isuite,
574 const int *isca,
575 const int *iscold,
576 int *iccfth,
577 const int *const ipr,
578 const int *const iscalt,
579 const int *const itempk,
580 const int *const ienerg,
581 const cs_real_t *ro0,
582 const cs_real_t *cp0,
583 const cs_real_t *viscl0,
584 const cs_real_t *uref,
585 const cs_real_t *almax,
586 const double *const xyzcen,
587 double rtp[]);
588
589 /*----------------------------------------------------------------------------
590 * User law for material Properties
591 *
592 * Fortran Interface:
593 *
594 * SUBROUTINE UIPHYV (NCELET, ISCA, RTP)
595 * *****************
596 *
597 * INTEGER NCEL <-- number of cells whithout halo
598 * INTEGER NCELET <-- number of cells whith halo
599 * INTEGER NSCAUS <-- number of user scalar including thermal scalar
600 * INTEGER IVISCL <-- pointer for mulecular viscosity mu
601 * INTEGER ICP <-- pointer for predifined heat Cp
602 * INTEGER IVISLS <-- pointer for Lambda/Cp
603 * INTEGER IROVAR <-- =1 if rho variable, =0 if rho constant
604 * INTEGER IVIVAR <-- =1 if mu variable, =0 if mu constant
605 * INTEGER ISCA <-- indirection array for scalar number
606 * INTEGER ISCALT <-- pointer for the thermal scalar in ISCA
607 * INTEGER ISCAVR <-- scalars that are variance
608 * INTEGER IPPROC <-- indirection array for cell properties
609 * INTEGER IVISCV <-- pointer for volumic viscosity viscv
610 * INTEGER ITEMPK <-- pointer for temperature (in K)
611 * DOUBLE PRECISION P0 <-- pressure reference value
612 * DOUBLE PRECISION T0 <-- temperature reference value
613 * DOUBLE PRECISION RO0 <-- density reference value
614 * DOUBLE PRECISION CP0 <-- specific heat reference value
615 * DOUBLE PRECISION VISCL0 <-- dynamic viscosity reference value
616 * DOUBLE PRECISION VISLS0 <-- diffusion coefficient of the scalars
617 * DOUBLE PRECISION VISCV0 <-- volumic viscosity
618 * DOUBLE PRECISION RTP <-- variables and scalars array
619 *----------------------------------------------------------------------------*/
620
621 void CS_PROCF(uiphyv, UIPHYV)(const cs_int_t *const ncel,
622 const cs_int_t *const ncelet,
623 const cs_int_t *const nscaus,
624 const cs_int_t *const itherm,
625 const cs_int_t iviscl[],
626 const cs_int_t icp[],
627 const cs_int_t ivisls[],
628 const cs_int_t irovar[],
629 const cs_int_t ivivar[],
630 const cs_int_t isca[],
631 const cs_int_t iscalt[],
632 const cs_int_t iscavr[],
633 const cs_int_t ipproc[],
634 const cs_int_t iviscv[],
635 const cs_int_t itempk[],
636 const cs_real_t p0[],
637 const cs_real_t t0[],
638 const cs_real_t ro0[],
639 const cs_real_t cp0[],
640 const cs_real_t viscl0[],
641 const cs_real_t visls0[],
642 const cs_real_t viscv0[],
643 const cs_real_t rtp[],
644 double propce[]);
645
646 /*----------------------------------------------------------------------------
647 * Head losses definition
648 *
649 * Fortran Interface:
650 *
651 * subroutine uikpdc
652 * *****************
653 *
654 * integer iappel <-- number of calls during a time step
655 * integer ncelet <-- number of cells with halo
656 * integer ncepdp --> number of cells with head losses
657 * integer icepdc --> ncepdp cells number with head losses
658 * double precision ckupdc --> head losses matrix
659 * double precision rtpa <-- variables array at previous time step
660 *----------------------------------------------------------------------------*/
661
662 void CS_PROCF(uikpdc, UIKPDC)(const int* iappel,
663 const int* ncelet,
664 int* ncepdp,
665 int icepdc[],
666 double ckupdc[],
667 const double rtpa[] );
668
669 /*----------------------------------------------------------------------------
670 * 1D profile postprocessing
671 *
672 * Fortran Interface:
673 *
674 * SUBROUTINE UIPROF
675 * *****************
676 *
677 * INTEGER NCELET <-- number of cells with halo
678 * INTEGER NCEL <-- number of cells without halo
679 * INTEGER NTMABS <-- max iterations numbers
680 * INTEGER NTCABS <-- current iteration number
681 * DOUBLE PRECISION TTCABS <-- current physical time
682 * DOUBLE PRECISION TTMABS <-- max physical time
683 * DOUBLE PRECISION TTPABS <-- physical time at calculation beginning
684 * DOUBLE PRECISION XYZCEN <-- cell's gravity center
685 * DOUBLE PRECISION RTP <-- variables and scalars array
686 * DOUBLE PRECISION PROPCE <-- property array
687 * INTEGER IPPROC <-- indirection array for cell properties
688 *----------------------------------------------------------------------------*/
689
690 void CS_PROCF (uiprof, UIPROF)(const int *const ncelet,
691 const int *const ncel,
692 const int *const ntmabs,
693 const int *const ntcabs,
694 const double *const ttcabs,
695 const double *const ttmabs,
696 const double *const ttpabs,
697 const double *const xyzcen,
698 const double *const rtp,
699 const double *const propce,
700 const int *const ipproc);
701
702 /*----------------------------------------------------------------------------
703 * Free memory: clean global private variables and libxml2 variables.
704 *
705 * Fortran Interface:
706 *
707 * SUBROUTINE MEMUI1
708 * *****************
709 *
710 * INTEGER NCHARB <-- number of coal
711 *----------------------------------------------------------------------------*/
712
713 void CS_PROCF (memui1, MEMUI1) (const int *const ncharb);
714
715 /*=============================================================================
716 * Public function prototypes
717 *============================================================================*/
718
719 /*-----------------------------------------------------------------------------
720 * Get initial value from property markup.
721 *
722 * parameters:
723 * property_name <-- name of the property
724 * value --> new initial value of the property
725 *----------------------------------------------------------------------------*/
726
727 void
728 cs_gui_properties_value(const char *property_name,
729 double *value);
730
731 /*-----------------------------------------------------------------------------
732 * Initialization choice of the reference variables parameters.
733 *
734 * parameters:
735 * name <-- parameter name
736 * value --> parameter value
737 *----------------------------------------------------------------------------*/
738
739 void
740 cs_gui_reference_initialization(const char *param,
741 double *value);
742
743 /*-----------------------------------------------------------------------------
744 * Set partitioning options.
745 *----------------------------------------------------------------------------*/
746
747 void
748 cs_gui_partition(void);
749
750 /*-----------------------------------------------------------------------------
751 * Define parallel IO settings.
752 *----------------------------------------------------------------------------*/
753
754 void
755 cs_gui_parallel_io(void);
756
757 /*-----------------------------------------------------------------------------
758 * Free memory: clean global private variables and libxml2 variables
759 *----------------------------------------------------------------------------*/
760
761 void
762 cs_gui_clean_memory(void);
763
764 /*----------------------------------------------------------------------------
765 * Logging output for MEI usage.
766 *----------------------------------------------------------------------------*/
767
768 void
769 cs_gui_usage_log(void);
770
771 /*----------------------------------------------------------------------------*/
772
773 END_C_DECLS
774
775 #endif /* __CS_GUI_H__ */