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-2018 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 #include "cs_probe.h"
39 #include "cs_volume_zone.h"
40 
41 #include "cs_domain.h"
42 
43 /*----------------------------------------------------------------------------*/
44 
46 
47 /*============================================================================
48  * Macro definitions
49  *============================================================================*/
50 
51 /*=============================================================================
52  * Fortran function/subroutine prototypes
53  *============================================================================*/
54 
55 /*----------------------------------------------------------------------------
56  * Main Fortran subroutine
57  *----------------------------------------------------------------------------*/
58 
59 extern void CS_PROCF (caltri, CALTRI)
60 (
61  void
62 );
63 
64 /*----------------------------------------------------------------------------
65  * Convert gas temperature to and from enthalpy based on concentrations
66  *----------------------------------------------------------------------------*/
67 
68 extern void CS_PROCF (cpthp1, CPTHP1)
69 (
70  const cs_int_t *mode, /* <-- 1: h to t, 2: t to h */
71  cs_real_t *eh, /* <-> enthalpy of gas mix */
72  cs_real_t *xesp, /* <-- mas fraction of species */
73  cs_real_t *f1mc, /* <-- mean f1 */
74  cs_real_t *f2mc, /* <-- mean f2 */
75  cs_real_t *tp /* <-- gas temperature (K) */
76 );
77 
78 /*----------------------------------------------------------------------------
79  * Initialize Fortran base common block values
80  *----------------------------------------------------------------------------*/
81 
82 extern void CS_PROCF (csinit, CSINIT)
83 (
84  const cs_int_t *irgpar, /* <-- MPI Rank in parallel, -1 otherwise */
85  const cs_int_t *nrgpar /* <-- Number of MPI processes, or 1 */
86 );
87 
88 /*----------------------------------------------------------------------------
89  * Compute distance to wall by solving a 3d diffusion equation.
90  *----------------------------------------------------------------------------*/
91 
92 extern void CS_PROCF (distpr, DISTPR)
93 (
94  const cs_int_t *itypfb, /* <-- boudnary face types */
95  cs_real_t *distpa /* <-- wall distance */
96 );
97 
98 /*----------------------------------------------------------------------------
99  * Developer function for output of variables on a post-processing mesh
100  *----------------------------------------------------------------------------*/
101 
102 extern void CS_PROCF (dvvpst, DVVPST)
103 (
104  const cs_int_t *nummai, /* <-- number or post-processing mesh */
105  const cs_int_t *numtyp, /* <-- number or post-processing type
106  * (-1 as volume, -2 as boundary, or nummai) */
107  const cs_int_t *nvar, /* <-- number of variables */
108  const cs_int_t *ncelps, /* <-- number of post-processed cells */
109  const cs_int_t *nfbrps, /* <-- number of post processed boundary faces */
110  const cs_int_t lstcel[], /* <-- list of post-processed cells */
111  const cs_int_t lstfbr[], /* <-- list of post-processed boundary faces */
112  cs_real_t tracel[], /* --- work array for output cells */
113  cs_real_t trafbr[] /* --- work array for output boundary faces */
114 );
115 
116 /*----------------------------------------------------------------------------
117  * Find the nearest cell's center from a node
118  *----------------------------------------------------------------------------*/
119 
120 extern void CS_PROCF (findpt, FINDPT)
121 (
122  const cs_int_t *ncelet, /* <-- number of extended (real + ghost) cells */
123  const cs_int_t *ncel, /* <-- number of cells */
124  const cs_real_t *xyzcen, /* <-- cell centers */
125  const cs_real_t *xx, /* <-- node coordinate X */
126  const cs_real_t *yy, /* <-- node coordinate Y */
127  const cs_real_t *zz, /* <-- node coordinate Z */
128  cs_int_t *node, /* --> node we are looking for, zero if error */
129  cs_int_t *ndrang /* --> rank of associated process */
130 );
131 
132 /*----------------------------------------------------------------------------
133  * Check necessity of extended mesh from FORTRAN options.
134  *
135  * Interface Fortran :
136  *
137  * SUBROUTINE HALTYP (IVOSET)
138  * *****************
139  *
140  * INTEGER IVOSET : <-- : Indicator of necessity of extended mesh
141  *----------------------------------------------------------------------------*/
142 
143 extern void
144 CS_PROCF (haltyp, HALTYP)(const cs_int_t *ivoset);
145 
146 /*----------------------------------------------------------------------------
147  * Main Fortran options initialization
148  *----------------------------------------------------------------------------*/
149 
150 extern void CS_PROCF (initi1, INITI1)
151 (
152  void
153 );
154 
155 /*----------------------------------------------------------------------------
156  * User function for enthalpy <-> temperature conversion
157  *----------------------------------------------------------------------------*/
158 
159 void CS_PROCF (usthht, USTHHT)
160 (
161  const cs_int_t *mode, /* <-- -1 : t -> h ; 1 : h -> t */
162  cs_real_t *enthal, /* <-- enthalpy */
163  cs_real_t *temper /* <-- temperature */
164 );
165 
166 /*----------------------------------------------------------------------------
167  * User function for output of variables on a post-processing mesh
168  *----------------------------------------------------------------------------*/
169 
170 void CS_PROCF (usvpst, USVPST)
171 (
172  const cs_int_t *nummai, /* <-- number or post-processing mesh */
173  const cs_int_t *nvar, /* <-- number of variables */
174  const cs_int_t *nscal, /* <-- number of scalars */
175  const cs_int_t *nvlsta, /* <-- number of statistical variables (lagr) */
176  const cs_int_t *ncelps, /* <-- number of post-processed cells */
177  const cs_int_t *nfacps, /* <-- number of post processed interior faces */
178  const cs_int_t *nfbrps, /* <-- number of post processed boundary faces */
179  const cs_int_t itypps[3], /* <-- flag (0 or 1) for presence of cells, */
180  /* interior faces, and boundary faces */
181  const cs_int_t lstcel[], /* <-- list of post-processed cells */
182  const cs_int_t lstfac[], /* <-- list of post-processed interior faces */
183  const cs_int_t lstfbr[] /* <-- list of post-processed boundary faces */
184 );
185 
186 /*----------------------------------------------------------------------------*/
196 /*----------------------------------------------------------------------------*/
197 
198 void
200  cs_real_t cku[][6]);
201 
202 /*----------------------------------------------------------------------------
203  * Absorption coefficient for radiative module
204  *----------------------------------------------------------------------------*/
205 
206 void
207 cs_user_rad_transfer_absorption(const int bc_type[],
208  const cs_real_t dt[],
209  cs_real_t ck[]);
210 
211 /*----------------------------------------------------------------------------
212  * Compute the net radiation flux
213  *----------------------------------------------------------------------------*/
214 
215 void
217  const cs_real_t dt[],
218  const cs_real_t coefap[],
219  const cs_real_t coefbp[],
220  const cs_real_t cofafp[],
221  const cs_real_t cofbfp[],
222  const cs_real_t twall[],
223  const cs_real_t qincid[],
224  const cs_real_t xlam[],
225  const cs_real_t epa[],
226  const cs_real_t eps[],
227  const cs_real_t ck[],
228  cs_real_t net_flux[]);
229 
230 /*----------------------------------------------------------------------------
231  * Convert temperature to enthalpy at boundary
232  *----------------------------------------------------------------------------*/
233 
234 void CS_PROCF (b_t_to_h, b_t_to_h)
235 (
236  const cs_lnum_t *nlst, /* --> number of faces in list */
237  const cs_lnum_t *lstfac, /* --> list of boundary faces at which
238  conversion is requested */
239  const cs_real_t *t_b, /* --> temperature at boundary */
240  cs_real_t *h_b /* --> enthalpy at boundary */
241 );
242 
243 /*----------------------------------------------------------------------------
244  * Convert enthalpy to temperature at cells
245  *----------------------------------------------------------------------------*/
246 
247 void CS_PROCF (c_h_to_t, c_h_to_t)
248 (
249  const cs_real_t *h, /* --> enthalpy */
250  cs_real_t *t /* --> temperature */
251 );
252 
253 /*----------------------------------------------------------------------------
254  * Add field indexes associated with a new non-user solved variable,
255  * with default options
256  *
257  * parameters:
258  * f_id <-- field id
259  *
260  * returns:
261  * scalar number for defined field
262  *----------------------------------------------------------------------------*/
263 
264 int
266 
267 /*----------------------------------------------------------------------------
268  * Return Lagrangian model status.
269  *
270  * parameters:
271  * model_flag --> 0 without Lagrangian, 1 or 2 with Lagrangian
272  * restart_flag --> 1 for Lagrangian restart, 0 otherwise
273  * frozen_flag --> 1 for frozen Eulerian flow, 0 otherwise
274  *----------------------------------------------------------------------------*/
275 
276 void
277 cs_lagr_status(int *model_flag,
278  int *restart_flag,
279  int *frozen_flag);
280 
281 /*============================================================================
282  * User function prototypes
283  *============================================================================*/
284 
285 /*----------------------------------------------------------------------------
286  * Data Entry of the 1D wall thermal module.
287  *----------------------------------------------------------------------------*/
288 
289 void
290 cs_user_1d_wall_thermal(int iappel,
291  int isuit1);
292 
293 /*----------------------------------------------------------------------------
294  * Define global options for couplings.
295  *
296  * These options allow defining the time step synchronization policy,
297  * as well as a time step multiplier.
298  *----------------------------------------------------------------------------*/
299 
300 void
301 cs_user_coupling(void);
302 
303 /*----------------------------------------------------------------------------
304  * This function is called at each time step for boundary conditions.
305  *----------------------------------------------------------------------------*/
306 
307 void
309  int icodcl[],
310  int bc_type[],
311  cs_real_t rcodcl[]);
312 
313 /*----------------------------------------------------------------------------
314  * This function is called at the end of each time step.
315  *
316  * It has a very general purpose, although it is recommended to handle
317  * mainly postprocessing or data-extraction type operations.
318  *----------------------------------------------------------------------------*/
319 
320 void
322 
323 /*----------------------------------------------------------------------------
324  * This function is called one time step to initialize problem.
325  *----------------------------------------------------------------------------*/
326 
327 void
329 
330 /*----------------------------------------------------------------------------*/
336 /*----------------------------------------------------------------------------*/
337 
338 void
340 
341 /*----------------------------------------------------------------------------*/
350 /*----------------------------------------------------------------------------*/
351 
352 void
354 
355 /*----------------------------------------------------------------------------*/
363 /*----------------------------------------------------------------------------*/
364 
365 void
367 
368 /*----------------------------------------------------------------------------
369  * This function is called each time step to define physical properties.
370  *----------------------------------------------------------------------------*/
371 
372 void
374  const cs_mesh_quantities_t *mesh_quantities);
375 
376 /*----------------------------------------------------------------------------
377  * Define mesh joinings.
378  *----------------------------------------------------------------------------*/
379 
380 void
381 cs_user_join(void);
382 
383 /*----------------------------------------------------------------------------
384  * Define linear solver options.
385  *
386  * This function is called at the setup stage, once user and most model-based
387  * fields are defined.
388  *----------------------------------------------------------------------------*/
389 
390 void
392 
393 /*----------------------------------------------------------------------------*/
397 /*----------------------------------------------------------------------------*/
398 
399 void
400 cs_user_output(void);
401 
402 /*----------------------------------------------------------------------------
403  * Tag bad cells within the mesh based on geometric criteria.
404  *----------------------------------------------------------------------------*/
405 
406 void
408  cs_mesh_quantities_t *mesh_quantities);
409 
410 /*----------------------------------------------------------------------------
411  * Define mesh files to read and optional associated transformations.
412  *----------------------------------------------------------------------------*/
413 
414 void
415 cs_user_mesh_input(void);
416 
417 /*----------------------------------------------------------------------------
418  * Modifiy geometry and mesh.
419  *----------------------------------------------------------------------------*/
420 
421 void
423 
424 /*----------------------------------------------------------------------------
425  * Insert boundary wall into a mesh.
426  *----------------------------------------------------------------------------*/
427 
428 void
430 
431 /*----------------------------------------------------------------------------
432  * Mesh smoothing.
433  *
434  * parameters:
435  * mesh <-> pointer to mesh structure to smoothe
436  *----------------------------------------------------------------------------*/
437 
438 void
440 
441 /*----------------------------------------------------------------------------
442  * Enable or disable mesh saving.
443  *
444  * By default, mesh is saved when modified.
445  *
446  * parameters:
447  * mesh <-> pointer to mesh structure
448  *----------------------------------------------------------------------------*/
449 
450 void
452 
453 /*----------------------------------------------------------------------------
454  * Set options for cutting of warped faces
455  *
456  * parameters:
457  * mesh <-> pointer to mesh structure to smoothe
458  *----------------------------------------------------------------------------*/
459 
460 void
462 
463 /*----------------------------------------------------------------------------
464  * Select physical model options, including user fields.
465  *
466  * This function is called at the earliest stages of the data setup.
467  *----------------------------------------------------------------------------*/
468 
469 void
470 cs_user_model(void);
471 
472 /*----------------------------------------------------------------------------
473  * Define advanced mesh numbering options.
474  *----------------------------------------------------------------------------*/
475 
476 void
477 cs_user_numbering(void);
478 
479 /*----------------------------------------------------------------------------
480  * Define parallel IO settings.
481  *----------------------------------------------------------------------------*/
482 
483 void
484 cs_user_parallel_io(void);
485 
486 /*----------------------------------------------------------------------------
487  * Define advanced partitioning options.
488  *----------------------------------------------------------------------------*/
489 
490 void
491 cs_user_partition(void);
492 
493 /*----------------------------------------------------------------------------
494  * Define sparse matrix tuning options.
495  *----------------------------------------------------------------------------*/
496 
497 void
499 
500 /*----------------------------------------------------------------------------
501  * Define or modify general numerical and physical user parameters.
502  *
503  * At the calling point of this function, most model-related most variables
504  * and other fields have been defined, so speciic settings related to those
505  * fields may be set here.
506  *----------------------------------------------------------------------------*/
507 
508 void
509 cs_user_parameters(void);
510 
511 /*----------------------------------------------------------------------------
512  * User function for input of radiative transfer module options.
513  *----------------------------------------------------------------------------*/
514 
515 void
517 
518 /*-------------------------------------------------------------------------------*
519  * User subroutine for input of radiative transfer boundary conditions
520  *-------------------------------------------------------------------------------*/
521 
522 void
524  const int bc_type[],
525  int icodcl[],
526  int isothp[],
527  cs_real_t *tmin,
528  cs_real_t *tmax,
529  cs_real_t *tx,
530  const cs_real_t dt[],
531  cs_real_t rcodcl[],
532  const cs_real_t thwall[],
533  const cs_real_t qincid[],
534  cs_real_t hfcnvp[],
535  cs_real_t flcnvp[],
536  cs_real_t xlamp[],
537  cs_real_t epap[],
538  cs_real_t epsp[],
539  cs_real_t textp[],
540  cs_real_t tintp[]);
541 
542 /*----------------------------------------------------------------------------
543  * Define periodic faces.
544  *----------------------------------------------------------------------------*/
545 
546 void
547 cs_user_periodicity(void);
548 
549 /*----------------------------------------------------------------------------
550  * Define post-processing writers.
551  *
552  * The default output format and frequency may be configured, and additional
553  * post-processing writers allowing outputs in different formats or with
554  * different format options and output frequency than the main writer may
555  * be defined.
556  *----------------------------------------------------------------------------*/
557 
558 void
560 
561 /*-----------------------------------------------------------------------------
562  * Define monitoring probes and profiles. A profile is seen as a set of probes.
563  *----------------------------------------------------------------------------*/
564 
565 void
567 
568 /*----------------------------------------------------------------------------
569  * Define post-processing meshes.
570  *
571  * The main post-processing meshes may be configured, and additional
572  * post-processing meshes may be defined as a subset of the main mesh's
573  * cells or faces (both interior and boundary).
574  *----------------------------------------------------------------------------*/
575 
576 void
578 
579 /*----------------------------------------------------------------------------
580  * User function for output of values on a post-processing mesh.
581  *----------------------------------------------------------------------------*/
582 
583 void
584 cs_user_postprocess_values(const char *mesh_name,
585  int mesh_id,
586  int cat_id,
587  cs_probe_set_t *probes,
588  cs_lnum_t n_cells,
589  cs_lnum_t n_i_faces,
590  cs_lnum_t n_b_faces,
591  cs_lnum_t n_vertices,
592  const cs_lnum_t cell_list[],
593  const cs_lnum_t i_face_list[],
594  const cs_lnum_t b_face_list[],
595  const cs_lnum_t vertex_list[],
596  const cs_time_step_t *ts);
597 
598 /*----------------------------------------------------------------------------
599  * Override default frequency or calculation end based output.
600  *
601  * This allows fine-grained control of activation or deactivation,
602  *
603  * parameters:
604  * nt_max_abs <-- maximum time step number
605  * nt_cur_abs <-- current time step number
606  * t_cur_abs <-- absolute time at the current time step
607  *----------------------------------------------------------------------------*/
608 
609 void
610 cs_user_postprocess_activate(int nt_max_abs,
611  int nt_cur_abs,
612  double t_cur_abs);
613 
614 /*----------------------------------------------------------------------------
615  * Define couplings with other instances of Code_Saturne.
616  *----------------------------------------------------------------------------*/
617 
618 void
620 
621 /*----------------------------------------------------------------------------
622  * Set user solver.
623  *----------------------------------------------------------------------------*/
624 
625 int
626 cs_user_solver_set(void);
627 
628 /*----------------------------------------------------------------------------
629  * Main call to user solver.
630  *----------------------------------------------------------------------------*/
631 
632 void
634  const cs_mesh_quantities_t *mesh_quantities);
635 
636 /*----------------------------------------------------------------------------
637  * Define couplings with SYRTHES code.
638  *----------------------------------------------------------------------------*/
639 
640 void
642 
643 /*----------------------------------------------------------------------------
644  * Define time moments.
645  *----------------------------------------------------------------------------*/
646 
647 void
649 
650 /*----------------------------------------------------------------------------
651  * Define rotor/stator model.
652  *----------------------------------------------------------------------------*/
653 
654 void
656 
657 /*----------------------------------------------------------------------------
658  * Define rotor axes, associated cells, and rotor/stator faces.
659  *----------------------------------------------------------------------------*/
660 
661 void
663 
664 /*----------------------------------------------------------------------------*/
668 /*----------------------------------------------------------------------------*/
669 
670 void
671 cs_user_zones(void);
672 
673 /*============================================================================
674  * CDO User function prototypes
675  *============================================================================*/
676 
677 /*----------------------------------------------------------------------------*/
681 /*----------------------------------------------------------------------------*/
682 
683 bool
685 
686 /*----------------------------------------------------------------------------*/
690 /*----------------------------------------------------------------------------*/
691 
692 void
694 
695 /*----------------------------------------------------------------------------*/
703 /*----------------------------------------------------------------------------*/
704 
705 void
707 
708 /*----------------------------------------------------------------------------*/
716 /*----------------------------------------------------------------------------*/
717 
718 void
720 
721 /*----------------------------------------------------------------------------*/
728 /*----------------------------------------------------------------------------*/
729 
732 
733 /*----------------------------------------------------------------------------*/
740 /*----------------------------------------------------------------------------*/
741 
742 void
744 
745 /*----------------------------------------------------------------------------*/
752 /*----------------------------------------------------------------------------*/
753 
754 void
756 
757 /*----------------------------------------------------------------------------*/
764 /*----------------------------------------------------------------------------*/
765 
766 void
767 cs_user_cdo_extra_op(const cs_domain_t *domain);
768 
769 /*----------------------------------------------------------------------------*/
776 /*----------------------------------------------------------------------------*/
777 
778 void
780 
781 /*----------------------------------------------------------------------------*/
785 /*----------------------------------------------------------------------------*/
786 
787 void
789  const cs_mesh_quantities_t *mesh_quantities,
790  cs_real_t *dt);
791 
792 /*----------------------------------------------------------------------------*/
793 
795 
796 #endif /* __CS_PROTOTYPES_H__ */
void cs_user_partition(void)
Define advanced partitioning options.
Definition: cs_user_performance_tuning.c:102
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 cs_user_output(void)
Define or modify output user parameters.
Definition: cs_user_parameters.c:153
void cs_user_internal_coupling_add_volumes(cs_mesh_t *mesh)
Define volumes as internal coupling zones.
Definition: cs_user_parameters.c:222
void csinit(const cs_int_t *irgpar, const cs_int_t *nrgpar)
time step descriptor
Definition: cs_time_step.h:51
integer, save ncel
Definition: mesh.f90:50
void initi1(void)
Definition: initi1.f90:29
void cs_user_internal_coupling(void)
Define internal coupling options.
Definition: cs_user_parameters.c:205
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:145
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:121
void cs_user_periodicity(void)
Define periodic faces.
Definition: cs_user_mesh.c:131
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 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:451
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:296
void cs_user_postprocess_activate(int nt_max_abs, int nt_cur_abs, double t_cur_abs)
Definition: cs_user_postprocess.c:184
void cs_user_postprocess_meshes(void)
Define post-processing meshes.
Definition: cs_user_postprocess.c:108
void cs_user_model(void)
Select physical model options, including user fields.
Definition: cs_user_parameters.c:125
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:130
void cs_user_mesh_modify(cs_mesh_t *mesh)
Modify geometry and mesh.
Definition: cs_user_mesh.c:171
void cs_user_join(void)
Define mesh joinings.
Definition: cs_user_mesh.c:119
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 cs_user_cdo_add_mesh_locations(void)
Specify additional mesh locations.
Definition: cs_user_cdo.c:103
void cs_user_postprocess_values(const char *mesh_name, int mesh_id, int cat_id, cs_probe_set_t *probes, cs_lnum_t n_cells, cs_lnum_t n_i_faces, cs_lnum_t n_b_faces, cs_lnum_t n_vertices, const cs_lnum_t cell_list[], const cs_lnum_t i_face_list[], const cs_lnum_t b_face_list[], const cs_lnum_t vertex_list[], const cs_time_step_t *ts)
User function for output of values on a post-processing mesh.
Definition: cs_user_postprocess.c:154
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:89
void cs_user_radiative_transfer_parameters(void)
User function for input of radiative transfer module options.
Definition: cs_user_radiative_transfer.c:111
double cs_real_t
Floating-point value.
Definition: cs_defs.h:297
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)
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:201
Definition: cs_mesh.h:63
void cs_user_parameters(void)
Define or modify general numerical and physical user parameters.
Definition: cs_user_parameters.c:141
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:126
void cs_user_mesh_warping(void)
Set options for cutting of warped faces.
Definition: cs_user_mesh.c:143
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_postprocess_probes(void)
Define monitoring probes and profiles.
Definition: cs_user_postprocess.c:122
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:93
Definition: cs_field_pointer.h:65
Definition: cs_field_pointer.h:95
void cs_user_linear_solvers(void)
Define linear solver options.
Definition: cs_user_parameters.c:175
Definition: cs_mesh_quantities.h:52
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:115
void cs_user_internal_coupling_from_disjoint_meshes(cs_mesh_t *mesh)
Define volumesi from separated meshes as internal coupling zones.
Definition: cs_user_parameters.c:238
integer, dimension(:), pointer, save itypfb
Definition: pointe.f90:123
integer, save isuit1
Definition: optcal.f90:421
Definition: cs_domain.h:63
void cs_user_head_losses(const cs_volume_zone_t *zone, cs_real_t cku[][6])
Compute GUI-defined head losses for a given volume zone.
Definition: cs_user_head_losses.c:115
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 cs_user_time_moments(void)
Define time moments.
Definition: cs_user_parameters.c:191
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:137
Definition: cs_field_pointer.h:176
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:111
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:216
void cs_user_postprocess_writers(void)
Define post-processing writers.
Definition: cs_user_postprocess.c:92
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:293
void cs_user_radiative_transfer_bcs(int nvar, const int bc_type[], int icodcl[], 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:189
int cs_add_model_field_indexes(int f_id)
#define END_C_DECLS
Definition: cs_defs.h:452
cs_cdo_cell_center_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
integer, save nscal
number of solved user scalars effective number of scalars solutions of an advection equation...
Definition: dimens.f90:55
struct _cs_probe_set_t cs_probe_set_t
Definition: cs_probe.h:53
#define CS_PROCF(x, y)
Definition: cs_defs.h:465
void cs_user_mesh_boundary(cs_mesh_t *mesh)
Insert boundaries into a mesh.
Definition: cs_user_mesh.c:157
void cs_user_syrthes_coupling(void)
Define couplings with SYRTHES code.
Definition: cs_user_coupling.c:102
Definition: cs_field_pointer.h:94
void cs_user_physical_properties(const cs_mesh_t *mesh, const cs_mesh_quantities_t *mesh_quantities)
Function called at each time step to define physical properties.
Definition: cs_user_physical_properties.c:107
void cs_user_turbomachinery_rotor(void)
Define rotor axes, associated cells, and rotor/stator faces.
Definition: cs_user_turbomachinery.c:101
Definition: cs_volume_zone.h:82
void cs_user_parallel_io(void)
Define parallel IO settings.
Definition: cs_user_performance_tuning.c:114
Definition: cs_field_pointer.h:71
cs_cdo_cell_center_algo_t
Definition: cs_cdo_quantities.h:57
void cs_user_saturne_coupling(void)
Define couplings with other instances of Code_Saturne.
Definition: cs_user_coupling.c:117
void cs_user_mesh_smoothe(cs_mesh_t *mesh)
Mesh smoothing.
Definition: cs_user_mesh.c:185
void cs_user_1d_wall_thermal(int iappel, int isuit1)
Definition: cs_user_1d_wall_thermal.c:116
void cs_user_boundary_conditions(int nvar, int icodcl[], int bc_type[], cs_real_t rcodcl[])
User definition of boundary conditions.
Definition: cs_user_boundary_conditions.c:100
void cs_user_rad_transfer_absorption(const int bc_type[], const cs_real_t dt[], cs_real_t ck[])
Absorption coefficient for radiative module.
Definition: cs_user_radiative_transfer.c:139
Definition: mesh.f90:26
void cs_user_rad_transfer_net_flux(const int itypfb[], 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:177
Definition: cs_field_pointer.h:177
void cs_user_zones(void)
Define volume and surface zones.
Definition: cs_user_zones.c:82
void cs_user_initialization(void)
Definition: cs_user_initialization.c:113