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-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 
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) */
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) */
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 
774 
775 #endif /* __CS_GUI_H__ */