programmer's documentation
cs_prototypes.h
Go to the documentation of this file.
1 #ifndef __CS_PROTOTYPES_H__
2 #define __CS_PROTOTYPES_H__
3 
4 /*============================================================================
5  * Prototypes for Fortran functions and subroutines callable from C
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 #include "cs_mesh.h"
36 #include "cs_mesh_quantities.h"
37 #include "cs_mesh_bad_cells.h"
38 
39 #include "cs_domain.h"
40 
41 /*----------------------------------------------------------------------------*/
42 
44 
45 /*============================================================================
46  * Macro definitions
47  *============================================================================*/
48 
49 /*=============================================================================
50  * Fortran function/subroutine prototypes
51  *============================================================================*/
52 
53 /*----------------------------------------------------------------------------
54  * Main Fortran subroutine
55  *----------------------------------------------------------------------------*/
56 
57 extern void CS_PROCF (caltri, CALTRI)
58 (
59  void
60 );
61 
62 /*----------------------------------------------------------------------------
63  * Convert gas temperature to and from enthalpy based on concentrations
64  *----------------------------------------------------------------------------*/
65 
66 extern void CS_PROCF (cpthp1, CPTHP1)
67 (
68  const cs_int_t *mode, /* <-- 1: h to t, 2: t to h */
69  cs_real_t *eh, /* <-> enthalpy of gas mix */
70  cs_real_t *xesp, /* <-- mas fraction of species */
71  cs_real_t *f1mc, /* <-- mean f1 */
72  cs_real_t *f2mc, /* <-- mean f2 */
73  cs_real_t *tp /* <-- gas temperature (K) */
74 );
75 
76 /*----------------------------------------------------------------------------
77  * Initialize Fortran base common block values
78  *----------------------------------------------------------------------------*/
79 
80 extern void CS_PROCF (csinit, CSINIT)
81 (
82  const cs_int_t *irgpar, /* <-- MPI Rank in parallel, -1 otherwise */
83  const cs_int_t *nrgpar /* <-- Number of MPI processes, or 1 */
84 );
85 
86 /*----------------------------------------------------------------------------
87  * Compute distance to wall by solving a 3d diffusion equation.
88  *----------------------------------------------------------------------------*/
89 
90 extern void CS_PROCF (distpr, DISTPR)
91 (
92  const cs_int_t *itypfb, /* <-- boudnary face types */
93  cs_real_t *distpa /* <-- wall distance */
94 );
95 
96 /*----------------------------------------------------------------------------
97  * Developer function for output of variables on a post-processing mesh
98  *----------------------------------------------------------------------------*/
99 
100 extern void CS_PROCF (dvvpst, DVVPST)
101 (
102  const cs_int_t *nummai, /* <-- number or post-processing mesh */
103  const cs_int_t *numtyp, /* <-- number or post-processing type
104  * (-1 as volume, -2 as boundary, or nummai) */
105  const cs_int_t *nvar, /* <-- number of variables */
106  const cs_int_t *ncelps, /* <-- number of post-processed cells */
107  const cs_int_t *nfbrps, /* <-- number of post processed boundary faces */
108  const cs_int_t lstcel[], /* <-- list of post-processed cells */
109  const cs_int_t lstfbr[], /* <-- list of post-processed boundary faces */
110  cs_real_t tracel[], /* --- work array for output cells */
111  cs_real_t trafbr[] /* --- work array for output boundary faces */
112 );
113 
114 /*----------------------------------------------------------------------------
115  * Find the nearest cell's center from a node
116  *----------------------------------------------------------------------------*/
117 
118 extern void CS_PROCF (findpt, FINDPT)
119 (
120  const cs_int_t *ncelet, /* <-- number of extended (real + ghost) cells */
121  const cs_int_t *ncel, /* <-- number of cells */
122  const cs_real_t *xyzcen, /* <-- cell centers */
123  const cs_real_t *xx, /* <-- node coordinate X */
124  const cs_real_t *yy, /* <-- node coordinate Y */
125  const cs_real_t *zz, /* <-- node coordinate Z */
126  cs_int_t *node, /* --> node we are looking for, zero if error */
127  cs_int_t *ndrang /* --> rank of associated process */
128 );
129 
130 /*----------------------------------------------------------------------------
131  * Generator for distribution function of p's
132  *----------------------------------------------------------------------------*/
133 
134 extern void CS_PROCF (fische, FISCHE)
135 (
136  const cs_int_t *n,
137  const cs_real_t *mu,
138  cs_int_t p[]);
139 
140 /*----------------------------------------------------------------------------
141  * Check necessity of extended mesh from FORTRAN options.
142  *
143  * Interface Fortran :
144  *
145  * SUBROUTINE HALTYP (IVOSET)
146  * *****************
147  *
148  * INTEGER IVOSET : <-- : Indicator of necessity of extended mesh
149  *----------------------------------------------------------------------------*/
150 
151 extern void
152 CS_PROCF (haltyp, HALTYP)(const cs_int_t *ivoset);
153 
154 /*----------------------------------------------------------------------------
155  * Main Fortran options initialization
156  *----------------------------------------------------------------------------*/
157 
158 extern void CS_PROCF (initi1, INITI1)
159 (
160  void
161 );
162 
163 /*----------------------------------------------------------------------------
164  * Free Fortran allocated memory
165  *----------------------------------------------------------------------------*/
166 
167 extern void CS_PROCF (memfin, MEMFIN) (void);
168 
169 /*----------------------------------------------------------------------------
170  * User function for enthalpy <-> temperature conversion
171  *----------------------------------------------------------------------------*/
172 
173 void CS_PROCF (usthht, USTHHT)
174 (
175  const cs_int_t *mode, /* <-- -1 : t -> h ; 1 : h -> t */
176  cs_real_t *enthal, /* <-- enthalpy */
177  cs_real_t *temper /* <-- temperature */
178 );
179 
180 /*----------------------------------------------------------------------------
181  * User function for output of variables on a post-processing mesh
182  *----------------------------------------------------------------------------*/
183 
184 void CS_PROCF (usvpst, USVPST)
185 (
186  const cs_int_t *nummai, /* <-- number or post-processing mesh */
187  const cs_int_t *nvar, /* <-- number of variables */
188  const cs_int_t *nscal, /* <-- number of scalars */
189  const cs_int_t *nvlsta, /* <-- number of statistical variables (lagr) */
190  const cs_int_t *ncelps, /* <-- number of post-processed cells */
191  const cs_int_t *nfacps, /* <-- number of post processed interior faces */
192  const cs_int_t *nfbrps, /* <-- number of post processed boundary faces */
193  const cs_int_t itypps[3], /* <-- flag (0 or 1) for presence of cells, */
194  /* interior faces, and boundary faces */
195  const cs_int_t lstcel[], /* <-- list of post-processed cells */
196  const cs_int_t lstfac[], /* <-- list of post-processed interior faces */
197  const cs_int_t lstfbr[] /* <-- list of post-processed boundary faces */
198 );
199 
200 extern void CS_PROCF (usipes, USIPES)
201 (
202  cs_int_t *nmodpp
203 );
204 
205 /*-------------------------------------------------------------------------------
206  * Absorption coefficient for radiative module
207  *-------------------------------------------------------------------------------*/
208 
209 void
210 cs_user_rad_transfer_absorption(const int bc_type[],
211  const int izfrdp[],
212  const cs_real_t dt[],
213  cs_real_t ck[]);
214 
215 /*-------------------------------------------------------------------------------
216  * Compute the net radiation flux
217  *-------------------------------------------------------------------------------*/
218 
219 void
221  const int izfrdp[],
222  const cs_real_t dt[],
223  const cs_real_t coefap[],
224  const cs_real_t coefbp[],
225  const cs_real_t cofafp[],
226  const cs_real_t cofbfp[],
227  const cs_real_t twall[],
228  const cs_real_t qincid[],
229  const cs_real_t xlam[],
230  const cs_real_t epa[],
231  const cs_real_t eps[],
232  const cs_real_t ck[],
233  cs_real_t net_flux[]);
234 
235 /*----------------------------------------------------------------------------
236  * Uniform random number generator
237  *----------------------------------------------------------------------------*/
238 
239 void CS_PROCF (zufalli, zufalli)
240 (
241  const cs_int_t *n /* --> size of the vector */
242 );
243 
244 /*----------------------------------------------------------------------------
245  * Uniform random number generator
246  *----------------------------------------------------------------------------*/
247 
248 void CS_PROCF (zufall, zufall)
249 (
250  const cs_int_t *n, /* --> size of the vector */
251  const cs_real_t *a /* <-- generated random number vector */
252 );
253 
254 /*----------------------------------------------------------------------------
255  * Gaussian random number generator
256  *----------------------------------------------------------------------------*/
257 
258 void CS_PROCF (normalen, normalen)
259 (
260  const cs_int_t *n, /* --> size of the vector */
261  const cs_real_t *x /* <-- generated random number vector */
262 );
263 
264 /*----------------------------------------------------------------------------
265  * Convert temperature to enthalpy at boundary
266  *----------------------------------------------------------------------------*/
267 
268 void CS_PROCF (b_t_to_h, b_t_to_h)
269 (
270  const cs_lnum_t *nlst, /* --> number of faces in list */
271  const cs_lnum_t *lstfac, /* --> list of boundary faces at which
272  conversion is requested */
273  const cs_real_t *t_b, /* --> temperature at boundary */
274  cs_real_t *h_b /* --> enthalpy at boundary */
275  );
276 
277 /*----------------------------------------------------------------------------
278  * Convert enthalpy to temperature at cells
279  *----------------------------------------------------------------------------*/
280 
281 void CS_PROCF (c_h_to_t, c_h_to_t)
282 (
283  const cs_real_t *h, /* --> enthalpy */
284  cs_real_t *t /* --> temperature */
285  );
286 
287 /*----------------------------------------------------------------------------
288  * Add field indexes associated with a new non-user solved variable,
289  * with default options
290  *
291  * parameters:
292  * f_id <-- field id
293  *
294  * returns:
295  * scalar number for defined field
296  *----------------------------------------------------------------------------*/
297 
298 int
300 
301 /*----------------------------------------------------------------------------
302  * Map a field to time plot (probes) activation array.
303  *
304  * This will set the "post_id" keyword for the given field, if not
305  * already set.
306 
307  * parameters:
308  * f_id <-- field id
309  *
310  * returns:
311  * starting position of this field in the \ref ihisvr array.
312  *----------------------------------------------------------------------------*/
313 
314 int
315 cs_field_post_id(int f_id);
316 
317 /*----------------------------------------------------------------------------
318  * Return Lagrangian model status.
319  *
320  * parameters:
321  * model_flag --> 0 without Lagrangian, 1 or 2 with Lagrangian
322  * restart_flag --> 1 for Lagrangian restart, 0 otherwise
323  * frozen_flag --> 1 for frozen Eulerian flow, 0 otherwise
324  *----------------------------------------------------------------------------*/
325 
326 void
327 cs_lagr_status(int *model_flag,
328  int *restart_flag,
329  int *frozen_flag);
330 
331 /*============================================================================
332  * User function prototypes
333  *============================================================================*/
334 
335 /*----------------------------------------------------------------------------
336  * Define global options for couplings.
337  *
338  * These options allow defining the time step synchronization policy,
339  * as well as a time step multiplier.
340  *----------------------------------------------------------------------------*/
341 
342 void
343 cs_user_coupling(void);
344 
345 /*----------------------------------------------------------------------------
346  * This function is called at each time step for boundary conditions.
347  *----------------------------------------------------------------------------*/
348 
349 void
351  int icodcl[],
352  int bc_type[],
353  int izfrdp[],
354  cs_real_t rcodcl[]);
355 
356 /*----------------------------------------------------------------------------
357  * This function is called at the end of each time step.
358  *
359  * It has a very general purpose, although it is recommended to handle
360  * mainly postprocessing or data-extraction type operations.
361  *----------------------------------------------------------------------------*/
362 
363 void
365 
366 /*----------------------------------------------------------------------------
367  * This function is called one time step to initialize problem.
368  *----------------------------------------------------------------------------*/
369 
370 void
372 
373 /*----------------------------------------------------------------------------
374  * This function is called each time step to define physical properties.
375  *----------------------------------------------------------------------------*/
376 
377 void
379  const cs_mesh_quantities_t *mesh_quantities);
380 
381 /*----------------------------------------------------------------------------
382  * Define mesh joinings.
383  *----------------------------------------------------------------------------*/
384 
385 void
386 cs_user_join(void);
387 
388 /*----------------------------------------------------------------------------
389  * Define linear solver options.
390  *
391  * This function is called at the setup stage, once user and most model-based
392  * fields are defined.
393  *----------------------------------------------------------------------------*/
394 
395 void
397 
398 /*----------------------------------------------------------------------------
399  * Tag bad cells within the mesh based on geometric criteria.
400  *----------------------------------------------------------------------------*/
401 
402 void
404  cs_mesh_quantities_t *mesh_quantities);
405 
406 /*----------------------------------------------------------------------------
407  * Define mesh files to read and optional associated transformations.
408  *----------------------------------------------------------------------------*/
409 
410 void
411 cs_user_mesh_input(void);
412 
413 /*----------------------------------------------------------------------------
414  * Modifiy geometry and mesh.
415  *----------------------------------------------------------------------------*/
416 
417 void
419 
420 /*----------------------------------------------------------------------------
421  * Insert thin wall into a mesh.
422  *----------------------------------------------------------------------------*/
423 
424 void
426 
427 /*----------------------------------------------------------------------------
428  * Mesh smoothing.
429  *
430  * parameters:
431  * mesh <-> pointer to mesh structure to smoothe
432  *----------------------------------------------------------------------------*/
433 
434 void
436 
437 /*----------------------------------------------------------------------------
438  * Enable or disable mesh saving.
439  *
440  * By default, mesh is saved when modified.
441  *
442  * parameters:
443  * mesh <-> pointer to mesh structure
444  *----------------------------------------------------------------------------*/
445 
446 void
448 
449 /*----------------------------------------------------------------------------
450  * Set options for cutting of warped faces
451  *
452  * parameters:
453  * mesh <-> pointer to mesh structure to smoothe
454  *----------------------------------------------------------------------------*/
455 
456 void
458 
459 /*----------------------------------------------------------------------------
460  * Select physical model options, including user fields.
461  *
462  * This function is called at the earliest stages of the data setup.
463  *----------------------------------------------------------------------------*/
464 
465 void
466 cs_user_model(void);
467 
468 /*----------------------------------------------------------------------------
469  * Define advanced mesh numbering options.
470  *----------------------------------------------------------------------------*/
471 
472 void
473 cs_user_numbering(void);
474 
475 /*----------------------------------------------------------------------------
476  * Define parallel IO settings.
477  *----------------------------------------------------------------------------*/
478 
479 void
480 cs_user_parallel_io(void);
481 
482 /*----------------------------------------------------------------------------
483  * Define advanced partitioning options.
484  *----------------------------------------------------------------------------*/
485 
486 void
487 cs_user_partition(void);
488 
489 /*----------------------------------------------------------------------------
490  * Define sparse matrix tuning options.
491  *----------------------------------------------------------------------------*/
492 
493 void
495 
496 /*----------------------------------------------------------------------------
497  * Define or modify general numerical and physical user parameters.
498  *
499  * At the calling point of this function, most model-related most variables
500  * and other fields have been defined, so speciic settings related to those
501  * fields may be set here.
502  *----------------------------------------------------------------------------*/
503 
504 void
505 cs_user_parameters(void);
506 
507 /*----------------------------------------------------------------------------
508  * User function for input of radiative transfer module options.
509  *----------------------------------------------------------------------------*/
510 
511 void
513 
514 /*-------------------------------------------------------------------------------*
515  * User subroutine for input of radiative transfer boundary conditions
516  *-------------------------------------------------------------------------------*/
517 
518 void
520  const int bc_type[],
521  int icodcl[],
522  int izfrdp[],
523  int isothp[],
524  cs_real_t *tmin,
525  cs_real_t *tmax,
526  cs_real_t *tx,
527  const cs_real_t dt[],
528  cs_real_t rcodcl[],
529  const cs_real_t thwall[],
530  const cs_real_t qincid[],
531  cs_real_t hfcnvp[],
532  cs_real_t flcnvp[],
533  cs_real_t xlamp[],
534  cs_real_t epap[],
535  cs_real_t epsp[],
536  cs_real_t textp[],
537  cs_real_t tintp[]);
538 
539 /*----------------------------------------------------------------------------
540  * Define periodic faces.
541  *----------------------------------------------------------------------------*/
542 
543 void
544 cs_user_periodicity(void);
545 
546 /*----------------------------------------------------------------------------
547  * Define post-processing writers.
548  *
549  * The default output format and frequency may be configured, and additional
550  * post-processing writers allowing outputs in different formats or with
551  * different format options and output frequency than the main writer may
552  * be defined.
553  *----------------------------------------------------------------------------*/
554 
555 void
557 
558 /*-----------------------------------------------------------------------------
559  * Define monitoring probes and profiles. A profile is seen as a set of probes.
560  *----------------------------------------------------------------------------*/
561 
562 void
564 
565 /*----------------------------------------------------------------------------
566  * Define post-processing meshes.
567  *
568  * The main post-processing meshes may be configured, and additional
569  * post-processing meshes may be defined as a subset of the main mesh's
570  * cells or faces (both interior and boundary).
571  *----------------------------------------------------------------------------*/
572 
573 void
575 
576 /*----------------------------------------------------------------------------
577  * Override default frequency or calculation end based output.
578  *
579  * This allows fine-grained control of activation or deactivation,
580  *
581  * parameters:
582  * nt_max_abs <-- maximum time step number
583  * nt_cur_abs <-- current time step number
584  * t_cur_abs <-- absolute time at the current time step
585  *----------------------------------------------------------------------------*/
586 
587 void
588 cs_user_postprocess_activate(int nt_max_abs,
589  int nt_cur_abs,
590  double t_cur_abs);
591 
592 /*----------------------------------------------------------------------------
593  * Define couplings with other instances of Code_Saturne.
594  *----------------------------------------------------------------------------*/
595 
596 void
598 
599 /*----------------------------------------------------------------------------
600  * Set user solver.
601  *----------------------------------------------------------------------------*/
602 
603 int
604 cs_user_solver_set(void);
605 
606 /*----------------------------------------------------------------------------
607  * Main call to user solver.
608  *----------------------------------------------------------------------------*/
609 
610 void
612  const cs_mesh_quantities_t *mesh_quantities);
613 
614 /*----------------------------------------------------------------------------
615  * Define couplings with SYRTHES code.
616  *----------------------------------------------------------------------------*/
617 
618 void
620 
621 /*----------------------------------------------------------------------------
622  * Define time moments.
623  *----------------------------------------------------------------------------*/
624 
625 void
627 
628 /*----------------------------------------------------------------------------
629  * Define rotor/stator model.
630  *----------------------------------------------------------------------------*/
631 
632 void
634 
635 /*----------------------------------------------------------------------------
636  * Define rotor axes, associated cells, and rotor/stator faces.
637  *----------------------------------------------------------------------------*/
638 
639 void
641 
642 
643 /*============================================================================
644  * CDO User function prototypes
645  *============================================================================*/
646 
647 /*----------------------------------------------------------------------------*/
651 /*----------------------------------------------------------------------------*/
652 
653 bool
655 
656 /*----------------------------------------------------------------------------*/
660 /*----------------------------------------------------------------------------*/
661 
662 void
664 
665 /*----------------------------------------------------------------------------*/
673 /*----------------------------------------------------------------------------*/
674 
675 void
677 
678 /*----------------------------------------------------------------------------*/
686 /*----------------------------------------------------------------------------*/
687 
688 void
690 
691 /*----------------------------------------------------------------------------*/
698 /*----------------------------------------------------------------------------*/
699 
702 
703 /*----------------------------------------------------------------------------*/
710 /*----------------------------------------------------------------------------*/
711 
712 void
714 
715 /*----------------------------------------------------------------------------*/
722 /*----------------------------------------------------------------------------*/
723 
724 void
726 
727 /*----------------------------------------------------------------------------*/
734 /*----------------------------------------------------------------------------*/
735 
736 void
737 cs_user_cdo_extra_op(const cs_domain_t *domain);
738 
739 /*----------------------------------------------------------------------------*/
746 /*----------------------------------------------------------------------------*/
747 
748 void
750 
751 /*----------------------------------------------------------------------------*/
752 
753 /*----------------------------------------------------------------------------*/
757 /*----------------------------------------------------------------------------*/
758 
759 void
761  const cs_mesh_quantities_t *mesh_quantities,
762  cs_real_t *dt);
763 
765 
766 #endif /* __CS_PROTOTYPES_H__ */
void cs_user_partition(void)
Define advanced partitioning options.
Definition: cs_user_performance_tuning.c:101
void b_t_to_h(const cs_lnum_t *nlst, const cs_lnum_t *lstfac, const cs_real_t *t_b, cs_real_t *h_b)
void csinit(const cs_int_t *irgpar, const cs_int_t *nrgpar)
integer, save ncel
Definition: mesh.f90:50
void cs_user_radiative_transfer_bcs(int nvarcl, const int bc_type[], int icodcl[], int izfrdp[], int isothp[], cs_real_t *tmin, cs_real_t *tmax, cs_real_t *tx, const cs_real_t dt[], cs_real_t rcodcl[], const cs_real_t thwall[], const cs_real_t qincid[], cs_real_t hfcnvp[], cs_real_t flcnvp[], cs_real_t xlamp[], cs_real_t epap[], cs_real_t epsp[], cs_real_t textp[], cs_real_t tintp[])
User definition of radiative transfer boundary conditions.
Definition: cs_user_radiative_transfer_bcs.c:190
void initi1(void)
Definition: initi1.f90:29
void cs_user_cdo_end_extra_op(const cs_domain_t *domain)
Final step for user-defined operations on results provided by the CDO kernel.
Definition: cs_user_cdo_extra_op.c:135
void cs_user_rad_transfer_net_flux(const int itypfb[], const int izfrdp[], const cs_real_t dt[], const cs_real_t coefap[], const cs_real_t coefbp[], const cs_real_t cofafp[], const cs_real_t cofbfp[], const cs_real_t twall[], const cs_real_t qincid[], const cs_real_t xlam[], const cs_real_t epa[], const cs_real_t eps[], const cs_real_t ck[], cs_real_t net_flux[])
Compute the net radiation flux.
Definition: cs_user_radiative_transfer.c:181
void cs_user_cdo_init_domain(cs_domain_t *domain)
Specify for the computational domain: – which type of boundaries closed the computational domain – ...
Definition: cs_user_cdo.c:122
void cs_user_periodicity(void)
Define periodic faces.
Definition: cs_user_mesh.c:129
void cpthp1(const cs_int_t *mode, cs_real_t *eh, cs_real_t *xesp, cs_real_t *f1mc, cs_real_t *f2mc, cs_real_t *tp)
void cs_user_turbomachinery(void)
Define rotor/stator model.
Definition: cs_user_turbomachinery.c:89
void cs_user_rad_transfer_absorption(const int bc_type[], const int izfrdp[], const cs_real_t dt[], cs_real_t ck[])
Absorption coefficient for radiative module.
Definition: cs_user_radiative_transfer.c:141
integer, dimension(:), pointer itypfb
Definition: pointe.f90:122
void zufall(const cs_int_t *n, const cs_real_t *a)
void cs_user_mesh_thinwall(cs_mesh_t *mesh)
Insert thin wall into a mesh.
Definition: cs_user_mesh.c:153
void caltri(void)
Definition: caltri.f90:24
bool cs_user_cdo_activated(void)
Activate or not the CDO module.
Definition: cs_user_cdo.c:91
#define BEGIN_C_DECLS
Definition: cs_defs.h:448
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:295
void cs_user_postprocess_activate(int nt_max_abs, int nt_cur_abs, double t_cur_abs)
Definition: cs_user_postprocess.c:130
cs_cdo_cc_algo_t
Definition: cs_cdo_quantities.h:53
void cs_user_postprocess_meshes(void)
Define post-processing meshes.
Definition: cs_user_postprocess.c:98
void cs_user_model(void)
Select physical model options, including user fields.
Definition: cs_user_parameters.c:122
void cs_user_coupling(void)
Define global options for couplings.
Definition: cs_user_coupling.c:87
void cs_user_cdo_extra_op(const cs_domain_t *domain)
Additional user-defined operations on results provided by the CDO kernel. Define advanced post-proces...
Definition: cs_user_cdo_extra_op.c:118
void cs_user_mesh_modify(cs_mesh_t *mesh)
Modify geometry and mesh.
Definition: cs_user_mesh.c:166
Definition: cs_field_pointer.h:66
void cs_user_join(void)
Define mesh joinings.
Definition: cs_user_mesh.c:118
void dvvpst(const cs_int_t *nummai, const cs_int_t *numtyp, const cs_int_t *nvar, const cs_int_t *ncelps, const cs_int_t *nfbrps, const cs_int_t lstcel[], const cs_int_t lstfbr[], cs_real_t tracel[], cs_real_t trafbr[])
void cs_user_cdo_numeric_settings(cs_domain_t *domain)
Setup advanced features concerning the numerical parameters of the equation resolved during the compu...
Definition: cs_user_cdo_numerics.c:108
void zufalli(const cs_int_t *n)
void cs_user_cdo_add_mesh_locations(void)
Specify additional mesh locations.
Definition: cs_user_cdo.c:103
void cs_user_scaling_elec(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities, cs_real_t *dt)
Define scaling parameter for electric model.
Definition: cs_user_electric_scaling.c:88
int cs_field_post_id(int f_id)
void cs_user_radiative_transfer_parameters(void)
User function for input of radiative transfer module options.
Definition: cs_user_radiative_transfer.c:113
double cs_real_t
Floating-point value.
Definition: cs_defs.h:296
void cs_user_numbering(void)
Define advanced mesh numbering options.
Definition: cs_user_performance_tuning.c:90
void usthht(const cs_int_t *mode, cs_real_t *enthal, cs_real_t *temper)
void usipes(cs_int_t *nmodpp)
integer, save ncelet
Definition: mesh.f90:46
void cs_user_mesh_save(cs_mesh_t *mesh)
Enable or disable mesh saving.
Definition: cs_user_mesh.c:194
Definition: cs_mesh.h:62
void cs_user_parameters(void)
Define or modify general numerical and physical user parameters.
Definition: cs_user_parameters.c:143
double precision, dimension(:,:), pointer xyzcen
Definition: mesh.f90:114
void cs_user_matrix_tuning(void)
Define sparse matrix tuning options.
Definition: cs_user_performance_tuning.c:123
void cs_user_mesh_warping(void)
Set options for cutting of warped faces.
Definition: cs_user_mesh.c:140
void cs_user_solver(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities)
Main call to user solver.
Definition: cs_user_solver.c:105
void cs_user_boundary_conditions(int nvarcl, int icodcl[], int bc_type[], int izfrdp[], cs_real_t rcodcl[])
User definition of boundary conditions.
Definition: cs_user_boundary_conditions.c:107
void cs_user_postprocess_probes(void)
Define monitoring probes and profiles.
Definition: cs_user_postprocess.c:112
void cs_lagr_status(int *model_flag, int *restart_flag, int *frozen_flag)
int cs_user_solver_set(void)
Set user solver.
Definition: cs_user_solver.c:89
Definition: cs_field_pointer.h:92
Definition: cs_field_pointer.h:64
double precision, save a
Definition: cs_fuel_incl.f90:146
Definition: cs_field_pointer.h:94
void memfin(void)
Definition: memfin.f90:24
void cs_user_linear_solvers(void)
Define linear solver options.
Definition: cs_user_parameters.c:164
Definition: cs_mesh_quantities.h:51
void cs_user_cdo_start_extra_op(const cs_domain_t *domain)
Initial step for user-defined operations on results provided by the CDO kernel.
Definition: cs_user_cdo_extra_op.c:101
Definition: cs_domain.h:62
void usvpst(const cs_int_t *nummai, const cs_int_t *nvar, const cs_int_t *nscal, const cs_int_t *nvlsta, const cs_int_t *ncelps, const cs_int_t *nfacps, const cs_int_t *nfbrps, const cs_int_t itypps[3], const cs_int_t lstcel[], const cs_int_t lstfac[], const cs_int_t lstfbr[])
integer, save nvar
number of solved variables (must be lower than nvarmx)
Definition: dimens.f90:42
void distpr(const cs_int_t *itypfb, cs_real_t *distpa)
void fische(const cs_int_t *n, const cs_real_t *mu, cs_int_t p[])
void normalen(const cs_int_t *n, const cs_real_t *x)
void cs_user_time_moments(void)
Define time moments.
Definition: cs_user_parameters.c:179
void cs_user_cdo_set_domain(cs_domain_t *domain)
Associate material property and/or convection field to user-defined equations and specify boundary co...
Definition: cs_user_cdo.c:140
Definition: cs_field_pointer.h:172
void c_h_to_t(const cs_real_t *h, cs_real_t *t)
void cs_user_extra_operations(void)
This function is called at the end of each time step.
Definition: cs_user_extra_operations.c:114
void cs_user_mesh_input(void)
Define mesh files to read and optional associated transformations.
Definition: cs_user_mesh.c:107
void cs_user_mesh_bad_cells_tag(cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Tag bad cells within the mesh based on user-defined geometric criteria.
Definition: cs_user_mesh.c:208
void cs_user_postprocess_writers(void)
Define post-processing writers.
Definition: cs_user_postprocess.c:82
cs_cdo_cc_algo_t cs_user_cdo_geometric_settings(void)
Setup advanced features concerning the way geometric quantities are built.
Definition: cs_user_cdo_numerics.c:84
void findpt(const cs_int_t *ncelet, const cs_int_t *ncel, const cs_real_t *xyzcen, const cs_real_t *xx, const cs_real_t *yy, const cs_real_t *zz, cs_int_t *node, cs_int_t *ndrang)
void haltyp(const cs_int_t *ivoset)
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:292
integer(c_int), pointer, save nvarcl
number of variable plus number of turbulent fluxes (used by the boundary conditions) ...
Definition: optcal.f90:661
int cs_add_model_field_indexes(int f_id)
#define END_C_DECLS
Definition: cs_defs.h:449
integer, save nscal
number of solved user scalars effective number of scalars solutions of an advection equation...
Definition: dimens.f90:55
#define CS_PROCF(x, y)
Definition: cs_defs.h:472
void cs_user_syrthes_coupling(void)
Define couplings with SYRTHES code.
Definition: cs_user_coupling.c:101
Definition: cs_field_pointer.h:93
void cs_user_physical_properties(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities)
Function is called each time step to define physical properties.
Definition: cs_user_physical_properties.c:110
void cs_user_turbomachinery_rotor(void)
Define rotor axes, associated cells, and rotor/stator faces.
Definition: cs_user_turbomachinery.c:100
Definition: cs_field_pointer.h:103
void cs_user_parallel_io(void)
Define parallel IO settings.
Definition: cs_user_performance_tuning.c:112
Definition: cs_field_pointer.h:70
void cs_user_saturne_coupling(void)
Define couplings with other instances of Code_Saturne.
Definition: cs_user_coupling.c:115
void cs_user_mesh_smoothe(cs_mesh_t *mesh)
Mesh smoothing.
Definition: cs_user_mesh.c:179
Definition: mesh.f90:26
Definition: cs_field_pointer.h:173
void cs_user_initialization(void)
Definition: cs_user_initialization.c:118