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-2020 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_mesh.h"
37 #include "cs_mesh_quantities.h"
38 #include "cs_mesh_bad_cells.h"
39 #include "cs_probe.h"
40 #include "cs_volume_zone.h"
41 
42 /*----------------------------------------------------------------------------*/
43 
45 
46 /*============================================================================
47  * Macro definitions
48  *============================================================================*/
49 
50 /*=============================================================================
51  * Fortran function/subroutine prototypes
52  *============================================================================*/
53 
54 /*----------------------------------------------------------------------------
55  * Main Fortran subroutine
56  *----------------------------------------------------------------------------*/
57 
58 extern void CS_PROCF (caltri, CALTRI)
59 (
60  void
61 );
62 
63 /*----------------------------------------------------------------------------
64  * Convert gas temperature to and from enthalpy based on concentrations
65  *----------------------------------------------------------------------------*/
66 
67 extern void CS_PROCF (cpthp1, CPTHP1)
68 (
69  const cs_int_t *mode, /* <-- 1: h to t, 2: t to h */
70  cs_real_t *eh, /* <-> enthalpy of gas mix */
71  cs_real_t *xesp, /* <-- mas fraction of species */
72  cs_real_t *f1mc, /* <-- mean f1 */
73  cs_real_t *f2mc, /* <-- mean f2 */
74  cs_real_t *tp /* <-- gas temperature (K) */
75 );
76 
77 /*----------------------------------------------------------------------------
78  * Initialize Fortran base common block values
79  *----------------------------------------------------------------------------*/
80 
81 extern void CS_PROCF (csinit, CSINIT)
82 (
83  const cs_int_t *irgpar, /* <-- MPI Rank in parallel, -1 otherwise */
84  const cs_int_t *nrgpar /* <-- Number of MPI processes, or 1 */
85 );
86 
87 /*----------------------------------------------------------------------------
88  * Compute distance to wall by solving a 3d diffusion equation.
89  *----------------------------------------------------------------------------*/
90 
91 extern void CS_PROCF (distpr, DISTPR)
92 (
93  const cs_int_t *itypfb, /* <-- boudnary face types */
94  cs_real_t *distpa /* <-- wall distance */
95 );
96 
97 /*----------------------------------------------------------------------------
98  * Developer function for output of variables on a post-processing mesh
99  *----------------------------------------------------------------------------*/
100 
101 extern void CS_PROCF (dvvpst, DVVPST)
102 (
103  const cs_int_t *nummai, /* <-- number or post-processing mesh */
104  const cs_int_t *numtyp, /* <-- number or post-processing type
105  * (-1 as volume, -2 as boundary, or nummai) */
106  const cs_int_t *nvar, /* <-- number of variables */
107  const cs_int_t *ncelps, /* <-- number of post-processed cells */
108  const cs_int_t *nfbrps, /* <-- number of post processed boundary faces */
109  const cs_int_t lstcel[], /* <-- list of post-processed cells */
110  const cs_int_t lstfbr[], /* <-- list of post-processed boundary faces */
111  cs_real_t tracel[], /* --- work array for output cells */
112  cs_real_t trafbr[] /* --- work array for output boundary faces */
113 );
114 
115 /*----------------------------------------------------------------------------
116  * Find the nearest cell's center from a node
117  *----------------------------------------------------------------------------*/
118 
119 extern void CS_PROCF (findpt, FINDPT)
120 (
121  const cs_int_t *ncelet, /* <-- number of extended (real + ghost) cells */
122  const cs_int_t *ncel, /* <-- number of cells */
123  const cs_real_t *xyzcen, /* <-- cell centers */
124  const cs_real_t *xx, /* <-- node coordinate X */
125  const cs_real_t *yy, /* <-- node coordinate Y */
126  const cs_real_t *zz, /* <-- node coordinate Z */
127  cs_int_t *node, /* --> node we are looking for, zero if error */
128  cs_int_t *ndrang /* --> rank of associated process */
129 );
130 
131 /*----------------------------------------------------------------------------
132  * Check necessity of extended mesh from FORTRAN options.
133  *
134  * Interface Fortran :
135  *
136  * SUBROUTINE HALTYP (IVOSET)
137  * *****************
138  *
139  * INTEGER IVOSET : <-- : Indicator of necessity of extended mesh
140  *----------------------------------------------------------------------------*/
141 
142 extern void
143 CS_PROCF (haltyp, HALTYP)(const cs_int_t *ivoset);
144 
145 /*----------------------------------------------------------------------------
146  * Main Fortran options initialization
147  *----------------------------------------------------------------------------*/
148 
149 extern void CS_PROCF (initi1, INITI1)
150 (
151  void
152 );
153 
154 /*----------------------------------------------------------------------------
155  * Set the CDO mode in the FORTRAN part
156  *----------------------------------------------------------------------------*/
157 
158 extern void CS_PROCF (set_cdo_mode, SET_CDO_MODE)
159 (
160  const cs_int_t *mode /* <-- -1: no CDO, 1: with CDO, 2: CDO only */
161 );
162 
163 /*----------------------------------------------------------------------------
164  * User function for enthalpy <-> temperature conversion
165  *----------------------------------------------------------------------------*/
166 
167 void CS_PROCF (usthht, USTHHT)
168 (
169  const cs_int_t *mode, /* <-- -1 : t -> h ; 1 : h -> t */
170  cs_real_t *enthal, /* <-- enthalpy */
171  cs_real_t *temper /* <-- temperature */
172 );
173 
174 /*----------------------------------------------------------------------------*/
184 /*----------------------------------------------------------------------------*/
185 
186 void
187 cs_user_head_losses(const cs_zone_t *zone,
188  cs_real_t cku[][6]);
189 
190 /*----------------------------------------------------------------------------
191  * Absorption coefficient for radiative module
192  *----------------------------------------------------------------------------*/
193 
194 void
195 cs_user_rad_transfer_absorption(const int bc_type[],
196  const cs_real_t dt[],
197  cs_real_t ck[]);
198 
199 /*----------------------------------------------------------------------------
200  * Compute the net radiation flux
201  *----------------------------------------------------------------------------*/
202 
203 void
205  const cs_real_t dt[],
206  const cs_real_t coefap[],
207  const cs_real_t coefbp[],
208  const cs_real_t cofafp[],
209  const cs_real_t cofbfp[],
210  const cs_real_t twall[],
211  const cs_real_t qincid[],
212  const cs_real_t xlam[],
213  const cs_real_t epa[],
214  const cs_real_t eps[],
215  const cs_real_t ck[],
216  cs_real_t net_flux[]);
217 
218 /*----------------------------------------------------------------------------
219  * Convert temperature to enthalpy at boundary
220  *----------------------------------------------------------------------------*/
221 
222 void CS_PROCF (b_t_to_h, b_t_to_h)
223 (
224  const cs_lnum_t *nlst, /* --> number of faces in list */
225  const cs_lnum_t *lstfac, /* --> list of boundary faces at which
226  conversion is requested */
227  const cs_real_t *t_b, /* --> temperature at boundary */
228  cs_real_t *h_b /* --> enthalpy at boundary */
229 );
230 
231 /*----------------------------------------------------------------------------
232  * Convert enthalpy to temperature at cells
233  *----------------------------------------------------------------------------*/
234 
235 void CS_PROCF (c_h_to_t, c_h_to_t)
236 (
237  const cs_real_t *h, /* --> enthalpy */
238  cs_real_t *t /* --> temperature */
239 );
240 
241 /*----------------------------------------------------------------------------
242  * Add field indexes associated with a new non-user solved variable,
243  * with default options
244  *
245  * parameters:
246  * f_id <-- field id
247  *
248  * returns:
249  * scalar number for defined field
250  *----------------------------------------------------------------------------*/
251 
252 int
254 
255 /*----------------------------------------------------------------------------
256  * Return Lagrangian model status.
257  *
258  * parameters:
259  * model_flag --> 0 without Lagrangian, 1 or 2 with Lagrangian
260  * restart_flag --> 1 for Lagrangian restart, 0 otherwise
261  * frozen_flag --> 1 for frozen Eulerian flow, 0 otherwise
262  *----------------------------------------------------------------------------*/
263 
264 void
265 cs_lagr_status(int *model_flag,
266  int *restart_flag,
267  int *frozen_flag);
268 
269 /*============================================================================
270  * User function prototypes
271  *============================================================================*/
272 
273 /*----------------------------------------------------------------------------
274  * Data Entry of the 1D wall thermal module.
275  *----------------------------------------------------------------------------*/
276 
277 void
278 cs_user_1d_wall_thermal(int iappel,
279  int isuit1);
280 
281 /*----------------------------------------------------------------------------
282  * Define global options for couplings.
283  *
284  * These options allow defining the time step synchronization policy,
285  * as well as a time step multiplier.
286  *----------------------------------------------------------------------------*/
287 
288 void
289 cs_user_coupling(void);
290 
291 /*----------------------------------------------------------------------------
292  * This function is called at each time step for boundary conditions.
293  *----------------------------------------------------------------------------*/
294 
295 void
297  int icodcl[],
298  int bc_type[],
299  cs_real_t rcodcl[]);
300 
301 /*----------------------------------------------------------------------------*/
313 /*----------------------------------------------------------------------------*/
314 
315 void
317 
318 /*----------------------------------------------------------------------------*/
327 /*----------------------------------------------------------------------------*/
328 
329 void
331 
332 /*----------------------------------------------------------------------------*/
341 /*----------------------------------------------------------------------------*/
342 
343 void
345 
346 /*----------------------------------------------------------------------------*/
352 /*----------------------------------------------------------------------------*/
353 
354 void
356 
357 /*----------------------------------------------------------------------------*/
363 /*----------------------------------------------------------------------------*/
364 
365 void
367 
368 /*----------------------------------------------------------------------------*/
377 /*----------------------------------------------------------------------------*/
378 
379 void
381 
382 /*----------------------------------------------------------------------------*/
391 /*----------------------------------------------------------------------------*/
392 
393 void
395 
396 /*----------------------------------------------------------------------------*/
402 /*----------------------------------------------------------------------------*/
403 
404 void
406 
407 /*----------------------------------------------------------------------------*/
417 /*----------------------------------------------------------------------------*/
418 
419 void
421  int f_id,
422  cs_real_t *st_exp,
423  cs_real_t *st_imp);
424 
425 /*----------------------------------------------------------------------------*/
433 /*----------------------------------------------------------------------------*/
434 
435 void
436 cs_user_porosity(void);
437 
438 /*----------------------------------------------------------------------------
439  * Define mesh joinings.
440  *----------------------------------------------------------------------------*/
441 
442 void
443 cs_user_join(void);
444 
445 /*----------------------------------------------------------------------------
446  * Define linear solver options.
447  *
448  * This function is called at the setup stage, once user and most model-based
449  * fields are defined.
450  *----------------------------------------------------------------------------*/
451 
452 void
454 
455 /*----------------------------------------------------------------------------*/
461 /*----------------------------------------------------------------------------*/
462 
463 void
465 
466 /*----------------------------------------------------------------------------
467  * Tag bad cells within the mesh based on geometric criteria.
468  *----------------------------------------------------------------------------*/
469 
470 void
472  cs_mesh_quantities_t *mesh_quantities);
473 
474 /*----------------------------------------------------------------------------
475  * Define mesh files to read and optional associated transformations.
476  *----------------------------------------------------------------------------*/
477 
478 void
479 cs_user_mesh_input(void);
480 
481 /*----------------------------------------------------------------------------
482  * Modifiy geometry and mesh.
483  *----------------------------------------------------------------------------*/
484 
485 void
487 
488 /*----------------------------------------------------------------------------
489  * Insert boundary wall into a mesh.
490  *----------------------------------------------------------------------------*/
491 
492 void
494 
495 /*----------------------------------------------------------------------------
496  * Mesh smoothing.
497  *
498  * parameters:
499  * mesh <-> pointer to mesh structure to smoothe
500  *----------------------------------------------------------------------------*/
501 
502 void
504 
505 /*----------------------------------------------------------------------------
506  * Enable or disable mesh saving.
507  *
508  * By default, mesh is saved when modified.
509  *
510  * parameters:
511  * mesh <-> pointer to mesh structure
512  *----------------------------------------------------------------------------*/
513 
514 void
516 
517 /*----------------------------------------------------------------------------
518  * Set options for cutting of warped faces
519  *
520  * parameters:
521  * mesh <-> pointer to mesh structure to smoothe
522  *----------------------------------------------------------------------------*/
523 
524 void
526 
527 /*----------------------------------------------------------------------------
528  * Select physical model options, including user fields.
529  *
530  * This function is called at the earliest stages of the data setup.
531  *----------------------------------------------------------------------------*/
532 
533 void
534 cs_user_model(void);
535 
536 /*----------------------------------------------------------------------------
537  * Define advanced mesh numbering options.
538  *----------------------------------------------------------------------------*/
539 
540 void
541 cs_user_numbering(void);
542 
543 /*----------------------------------------------------------------------------
544  * Define parallel IO settings.
545  *----------------------------------------------------------------------------*/
546 
547 void
548 cs_user_parallel_io(void);
549 
550 /*----------------------------------------------------------------------------
551  * Define advanced partitioning options.
552  *----------------------------------------------------------------------------*/
553 
554 void
555 cs_user_partition(void);
556 
557 /*----------------------------------------------------------------------------
558  * Define sparse matrix tuning options.
559  *----------------------------------------------------------------------------*/
560 
561 void
563 
564 /*----------------------------------------------------------------------------
565  * Define or modify general numerical and physical user parameters.
566  *
567  * At the calling point of this function, most model-related most variables
568  * and other fields have been defined, so specific settings related to those
569  * fields may be set here.
570  *----------------------------------------------------------------------------*/
571 
572 void
574 
575 /*----------------------------------------------------------------------------
576  * User function for input of radiative transfer module options.
577  *----------------------------------------------------------------------------*/
578 
579 void
581 
582 /*-----------------------------------------------------------------------------
583  * User subroutine for input of radiative transfer boundary conditions
584  *----------------------------------------------------------------------------*/
585 
586 void
588  const int bc_type[],
589  int icodcl[],
590  int isothp[],
591  cs_real_t *tmin,
592  cs_real_t *tmax,
593  cs_real_t *tx,
594  const cs_real_t dt[],
595  cs_real_t rcodcl[],
596  const cs_real_t thwall[],
597  const cs_real_t qincid[],
598  cs_real_t hfcnvp[],
599  cs_real_t flcnvp[],
600  cs_real_t xlamp[],
601  cs_real_t epap[],
602  cs_real_t epsp[],
603  cs_real_t textp[],
604  cs_real_t tintp[]);
605 
606 /*----------------------------------------------------------------------------
607  * Define periodic faces.
608  *----------------------------------------------------------------------------*/
609 
610 void
611 cs_user_periodicity(void);
612 
613 /*----------------------------------------------------------------------------
614  * Define post-processing writers.
615  *
616  * The default output format and frequency may be configured, and additional
617  * post-processing writers allowing outputs in different formats or with
618  * different format options and output frequency than the main writer may
619  * be defined.
620  *----------------------------------------------------------------------------*/
621 
622 void
624 
625 /*-----------------------------------------------------------------------------
626  * Define monitoring probes and profiles. A profile is seen as a set of probes.
627  *----------------------------------------------------------------------------*/
628 
629 void
631 
632 /*----------------------------------------------------------------------------
633  * Define post-processing meshes.
634  *
635  * The main post-processing meshes may be configured, and additional
636  * post-processing meshes may be defined as a subset of the main mesh's
637  * cells or faces (both interior and boundary).
638  *----------------------------------------------------------------------------*/
639 
640 void
642 
643 /*----------------------------------------------------------------------------
644  * User function for output of values on a post-processing mesh.
645  *----------------------------------------------------------------------------*/
646 
647 void
648 cs_user_postprocess_values(const char *mesh_name,
649  int mesh_id,
650  int cat_id,
651  cs_probe_set_t *probes,
652  cs_lnum_t n_cells,
653  cs_lnum_t n_i_faces,
654  cs_lnum_t n_b_faces,
655  cs_lnum_t n_vertices,
656  const cs_lnum_t cell_list[],
657  const cs_lnum_t i_face_list[],
658  const cs_lnum_t b_face_list[],
659  const cs_lnum_t vertex_list[],
660  const cs_time_step_t *ts);
661 
662 /*----------------------------------------------------------------------------
663  * Override default frequency or calculation end based output.
664  *
665  * This allows fine-grained control of activation or deactivation,
666  *
667  * parameters:
668  * nt_max_abs <-- maximum time step number
669  * nt_cur_abs <-- current time step number
670  * t_cur_abs <-- absolute time at the current time step
671  *----------------------------------------------------------------------------*/
672 
673 void
674 cs_user_postprocess_activate(int nt_max_abs,
675  int nt_cur_abs,
676  double t_cur_abs);
677 
678 /*----------------------------------------------------------------------------
679  * Define couplings with other instances of Code_Saturne.
680  *----------------------------------------------------------------------------*/
681 
682 void
684 
685 /*----------------------------------------------------------------------------
686  * Set user solver.
687  *----------------------------------------------------------------------------*/
688 
689 int
690 cs_user_solver_set(void);
691 
692 /*----------------------------------------------------------------------------
693  * Main call to user solver.
694  *----------------------------------------------------------------------------*/
695 
696 void
698  const cs_mesh_quantities_t *mesh_quantities);
699 
700 /*----------------------------------------------------------------------------
701  * Define couplings with SYRTHES code.
702  *----------------------------------------------------------------------------*/
703 
704 void
706 
707 /*----------------------------------------------------------------------------
708  * Define time moments.
709  *----------------------------------------------------------------------------*/
710 
711 void
713 
714 /*----------------------------------------------------------------------------
715  * Define rotor/stator model.
716  *----------------------------------------------------------------------------*/
717 
718 void
720 
721 /*----------------------------------------------------------------------------
722  * Define rotor axes, associated cells, and rotor/stator faces.
723  *----------------------------------------------------------------------------*/
724 
725 void
727 
728 /*----------------------------------------------------------------------------
729  * Define rotation velocity of rotor.
730  *----------------------------------------------------------------------------*/
731 
732 void
734 
735 /*----------------------------------------------------------------------------*/
739 /*----------------------------------------------------------------------------*/
740 
741 void
742 cs_user_zones(void);
743 
744 /*----------------------------------------------------------------------------*/
748 /*----------------------------------------------------------------------------*/
749 
750 void
752  const cs_mesh_quantities_t *mesh_quantities,
753  cs_real_t *dt);
754 
755 /*----------------------------------------------------------------------------
756  * Computation of the relaxation time-scale to equilibrium in the frame of
757  * the homogeneous two-phase model.
758  *----------------------------------------------------------------------------*/
759 
760 void
762  const cs_real_t *alpha_eq,
763  const cs_real_t *y_eq,
764  const cs_real_t *z_eq,
765  const cs_real_t *ei,
766  const cs_real_t *v,
767  cs_real_t *relax_tau);
768 
769 /*============================================================================
770  * CDO User function prototypes
771  *============================================================================*/
772 
773 /*----------------------------------------------------------------------------*/
781 /*----------------------------------------------------------------------------*/
782 
783 void
785 
786 /*----------------------------------------------------------------------------*/
787 
788 /*============================================================================
789  * MEG function prototypes
790  *============================================================================*/
791 
792 /*----------------------------------------------------------------------------*/
805 /*----------------------------------------------------------------------------*/
806 
807 cs_real_t *
809  const char *field_name,
810  const char *condition);
811 
812 /*----------------------------------------------------------------------------*/
820 /*----------------------------------------------------------------------------*/
821 
822 void
824  cs_field_t *f[]);
825 
826 /*----------------------------------------------------------------------------*/
835 /*----------------------------------------------------------------------------*/
836 
837 cs_real_t *
838 cs_meg_initialization(const cs_zone_t *zone,
839  const char *field_name);
840 
841 /*----------------------------------------------------------------------------*/
854 /*----------------------------------------------------------------------------*/
855 
856 cs_real_t *
857 cs_meg_source_terms(const cs_zone_t *zone,
858  const char *name,
859  const char *source_type);
860 
861 /*----------------------------------------------------------------------------*/
862 
864 
865 #endif /* __CS_PROTOTYPES_H__ */
void cs_user_finalize_setup(cs_domain_t *domain)
Define or modify output user parameters. For CDO schemes, specify the elements such as properties...
Definition: cs_user_parameters.c:167
void cs_user_partition(void)
Define advanced partitioning options.
Definition: cs_user_performance_tuning.c:102
cs_real_t * cs_meg_initialization(const cs_zone_t *zone, const char *field_name)
Evaluate GUI defined mathematical expressions over volume zones for initialization.
Definition: cs_meg_initialization.c:71
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_internal_coupling_add_volumes(cs_mesh_t *mesh)
Define volumes as internal coupling zones.
Definition: cs_internal_coupling.c:3027
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 cs_user_extra_operations_finalize(cs_domain_t *domain)
This function is called at the end of the calculation.
Definition: cs_user_extra_operations.c:130
void initi1(void)
Definition: initi1.f90:29
void cs_user_internal_coupling(void)
Define internal coupling options.
Definition: cs_user_parameters.c:219
void cs_user_physical_properties(cs_domain_t *domain)
This function is called each time step to define physical properties.
Definition: cs_user_physical_properties.c:80
void cs_user_periodicity(void)
Define periodic faces.
Definition: cs_user_mesh.c:111
void cs_user_extra_operations(cs_domain_t *domain)
This function is called at the end of each time step.
Definition: cs_user_extra_operations.c:113
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
Field descriptor.
Definition: cs_field.h:124
void caltri(void)
Definition: caltri.f90:36
#define BEGIN_C_DECLS
Definition: cs_defs.h:467
void cs_user_parameters(cs_domain_t *domain)
Define or modify general numerical and physical user parameters.
Definition: cs_user_parameters.c:150
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:301
void cs_user_source_terms(cs_domain_t *domain, int f_id, cs_real_t *st_exp, cs_real_t *st_imp)
Additional user-defined source terms for variable equations (momentum, scalars, turbulence...).
Definition: cs_user_source_terms.c:182
void cs_user_postprocess_activate(int nt_max_abs, int nt_cur_abs, double t_cur_abs)
Definition: cs_user_postprocess.c:185
void cs_user_postprocess_meshes(void)
Define post-processing meshes.
Definition: cs_user_postprocess.c:109
void cs_user_model(void)
Select physical model options, including user fields.
Definition: cs_user_parameters.c:128
void cs_user_coupling(void)
Define global options for couplings.
Definition: cs_user_coupling.c:87
void cs_user_mesh_modify(cs_mesh_t *mesh)
Modify geometry and mesh.
Definition: cs_user_mesh.c:151
void cs_user_join(void)
Define mesh joinings.
Definition: cs_user_mesh.c:99
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. (cs_glob_porous_model > 0)...
Definition: cs_user_porosity.c:78
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:155
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:90
void cs_user_radiative_transfer_parameters(void)
User function for input of radiative transfer module options.
Definition: cs_user_radiative_transfer.c:112
double cs_real_t
Floating-point value.
Definition: cs_defs.h:302
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:181
Definition: cs_mesh.h:63
void set_cdo_mode(const cs_int_t *mode)
double precision, dimension(:,:), pointer xyzcen
Definition: mesh.f90:110
double precision, dimension(:,:,:), allocatable v
Definition: atimbr.f90:114
void cs_user_extra_operations_initialize(cs_domain_t *domain)
Initialize variables.
Definition: cs_user_extra_operations.c:96
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:123
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:123
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:97
Definition: cs_field_pointer.h:65
Definition: cs_field_pointer.h:99
void cs_user_linear_solvers(void)
Define linear solver options.
Definition: cs_user_parameters.c:189
Definition: cs_mesh_quantities.h:90
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:3046
integer, dimension(:), pointer, save itypfb
Definition: pointe.f90:100
integer, save isuit1
Definition: optcal.f90:328
Structure storing the main features of the computational domain and pointers to the main geometrical ...
Definition: cs_domain.h:87
integer, save nvar
number of solved variables (must be lower than nvarmx)
Definition: dimens.f90:42
cs_real_t * cs_meg_boundary_function(const cs_zone_t *zone, const char *field_name, const char *condition)
Definition: cs_meg_boundary_function.c:70
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:205
Definition: cs_field_pointer.h:189
void c_h_to_t(const cs_real_t *h, cs_real_t *t)
void cs_user_mesh_input(void)
Define mesh files to read and optional associated transformations.
Definition: cs_user_mesh.c:87
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:196
void cs_user_postprocess_writers(void)
Define post-processing writers.
Definition: cs_user_postprocess.c:93
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:298
cs_real_t * cs_meg_source_terms(const cs_zone_t *zone, const char *name, const char *source_type)
Definition: cs_meg_source_terms.c:70
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:190
int cs_add_model_field_indexes(int f_id)
#define END_C_DECLS
Definition: cs_defs.h:468
void cs_meg_volume_function(const cs_zone_t *zone, cs_field_t *f[])
This function is used to compute user defined values for fields over a given volume zone...
Definition: cs_meg_volume_function.c:67
void cs_user_turbomachinery_set_rotation_velocity(void)
Define rotation velocity of rotor.
Definition: cs_user_turbomachinery.c:113
struct _cs_probe_set_t cs_probe_set_t
Definition: cs_probe.h:53
void cs_user_hgn_thermo_relax_time(const cs_mesh_t *mesh, const cs_real_t *alpha_eq, const cs_real_t *y_eq, const cs_real_t *z_eq, const cs_real_t *ei, const cs_real_t *v, cs_real_t *relax_tau)
Computation of the relaxation time-scale.
Definition: cs_user_hgn.c:93
#define CS_PROCF(x, y)
Definition: cs_defs.h:481
void cs_user_mesh_boundary(cs_mesh_t *mesh)
Insert boundaries into a mesh.
Definition: cs_user_mesh.c:137
void cs_user_syrthes_coupling(void)
Define couplings with SYRTHES code.
Definition: cs_user_coupling.c:102
Definition: cs_field_pointer.h:98
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:96
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:116
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:165
void cs_user_1d_wall_thermal(int iappel, int isuit1)
Definition: cs_user_1d_wall_thermal.c:117
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:101
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:140
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:178
void cs_user_initialization(cs_domain_t *domain)
This function is called one time step to initialize problem.
Definition: cs_user_initialization.c:115
Definition: cs_field_pointer.h:190
Definition: cs_zone.h:55
void cs_user_zones(void)
Define volume and surface zones.
Definition: cs_user_zones.c:82