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