7.1
general 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-2021 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_field.h"
37 #include "cs_mesh.h"
38 #include "cs_mesh_quantities.h"
39 #include "cs_mesh_bad_cells.h"
40 #include "cs_probe.h"
41 #include "cs_volume_zone.h"
42 
43 /*----------------------------------------------------------------------------*/
44 
45 BEGIN_C_DECLS
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  * Poisson equation resolution for hydrostatic pressure.
66  *----------------------------------------------------------------------------*/
67 
68 extern void cs_hydrostatic_pressure_compute(int *indhyd,
69  int iterns,
70  cs_real_t fext[][3],
71  cs_real_t dfext[][3],
72  cs_real_t phydr[],
73  cs_real_t flumas[],
74  cs_real_t flumab[],
75  cs_real_t viscf[],
76  cs_real_t viscb[],
77  cs_real_t dam[],
78  cs_real_t xam[],
79  cs_real_t dpvar[],
80  cs_real_t rhs[]);
81 
82 /*----------------------------------------------------------------------------
83  * Convert gas temperature to and from enthalpy based on concentrations
84  *----------------------------------------------------------------------------*/
85 
86 extern void CS_PROCF (cpthp1, CPTHP1)
87 (
88  const int *mode, /* <-- 1: h to t, 2: t to h */
89  cs_real_t *eh, /* <-> enthalpy of gas mix */
90  cs_real_t *xesp, /* <-- mas fraction of species */
91  cs_real_t *f1mc, /* <-- mean f1 */
92  cs_real_t *f2mc, /* <-- mean f2 */
93  cs_real_t *tp /* <-- gas temperature (K) */
94 );
95 
96 /*----------------------------------------------------------------------------
97  * Initialize Fortran base common block values
98  *----------------------------------------------------------------------------*/
99 
100 extern void CS_PROCF (csinit, CSINIT)
101 (
102  const int *irgpar, /* <-- MPI Rank in parallel, -1 otherwise */
103  const int *nrgpar /* <-- Number of MPI processes, or 1 */
104 );
105 
106 /*----------------------------------------------------------------------------
107  * Compute distance to wall by solving a 3d diffusion equation.
108  *----------------------------------------------------------------------------*/
109 
110 extern void CS_PROCF (distpr, DISTPR)
111 (
112  const int *itypfb, /* <-- boudnary face types */
113  cs_real_t *distpa /* <-- wall distance */
114 );
115 
116 /*----------------------------------------------------------------------------
117  * Developer function for output of variables on a post-processing mesh
118  *----------------------------------------------------------------------------*/
119 
120 extern void CS_PROCF (dvvpst, DVVPST)
121 (
122  const int *nummai, /* <-- number or post-processing mesh */
123  const int *numtyp, /* <-- number or post-processing type
124  * (-1 as volume, -2 as boundary, or nummai) */
125  const int *nvar, /* <-- number of variables */
126  const cs_lnum_t *ncelps, /* <-- number of post-processed cells */
127  const cs_lnum_t *nfbrps, /* <-- number of post processed boundary faces */
128  const cs_lnum_t lstcel[], /* <-- list of post-processed cells */
129  const cs_lnum_t lstfbr[], /* <-- list of post-processed boundary faces */
130  cs_real_t tracel[], /* --- work array for output cells */
131  cs_real_t trafbr[] /* --- work array for output boundary faces */
132 );
133 
134 /*----------------------------------------------------------------------------
135  * Find the nearest cell's center from a node
136  *----------------------------------------------------------------------------*/
137 
138 extern void CS_PROCF (findpt, FINDPT)
139 (
140  const cs_lnum_t *ncelet, /* <-- number of extended (real + ghost) cells */
141  const cs_lnum_t *ncel, /* <-- number of cells */
142  const cs_real_t *xyzcen, /* <-- cell centers */
143  const cs_real_t *xx, /* <-- node coordinate X */
144  const cs_real_t *yy, /* <-- node coordinate Y */
145  const cs_real_t *zz, /* <-- node coordinate Z */
146  cs_lnum_t *node, /* --> node we are looking for, zero if error */
147  int *ndrang /* --> rank of associated process */
148 );
149 
150 /*----------------------------------------------------------------------------
151  * Check necessity of extended mesh from FORTRAN options.
152  *
153  * Interface Fortran :
154  *
155  * SUBROUTINE HALTYP (IVOSET)
156  * *****************
157  *
158  * INTEGER IVOSET : <-- : Indicator of necessity of extended mesh
159  *----------------------------------------------------------------------------*/
160 
161 extern void
162 CS_PROCF (haltyp, HALTYP)(const int *ivoset);
163 
164 /*----------------------------------------------------------------------------
165  * Main Fortran options initialization
166  *----------------------------------------------------------------------------*/
167 
168 extern void CS_PROCF (initi1, INITI1)
169 (
170  void
171 );
172 
173 /*----------------------------------------------------------------------------*/
179 /*----------------------------------------------------------------------------*/
180 
181 int *
182 cs_atmo_get_auto_flag(void);
183 
184 /*----------------------------------------------------------------------------
185  * Add field indexes associated with a new non-user solved variable,
186  * with default options
187  *
188  * parameters:
189  * f_id <-- field id
190  *
191  * returns:
192  * scalar number for defined field
193  *----------------------------------------------------------------------------*/
194 
195 int
196 cs_add_model_field_indexes(int f_id);
197 
198 /*----------------------------------------------------------------------------*/
208 /*----------------------------------------------------------------------------*/
209 
210 void
211 cs_coal_bt2h(cs_lnum_t n_faces,
212  const cs_lnum_t face_ids[],
213  const cs_real_t t[],
214  cs_real_t h[]);
215 
216 /*----------------------------------------------------------------------------*/
226 /*----------------------------------------------------------------------------*/
227 
228 void
229 cs_coal_thfieldconv1(int location_id,
230  const cs_real_t eh[],
231  cs_real_t tp[]);
232 
233 /*----------------------------------------------------------------------------*/
239 /*----------------------------------------------------------------------------*/
240 
241 cs_real_t *
242 cs_get_b_head_loss(void);
243 
244 /*----------------------------------------------------------------------------*/
250 /*----------------------------------------------------------------------------*/
251 
252 cs_real_t *
253 cs_get_cavitation_dgdp_st(void);
254 
255 /*----------------------------------------------------------------------------*/
261 /*----------------------------------------------------------------------------*/
262 
263 cs_real_t *
264 cs_get_cavitation_gam(void);
265 
266 /*----------------------------------------------------------------------------*/
276 /*----------------------------------------------------------------------------*/
277 
278 void
279 cs_fuel_bt2h(cs_lnum_t n_faces,
280  const cs_lnum_t face_ids[],
281  const cs_real_t t[],
282  cs_real_t h[]);
283 
284 /*----------------------------------------------------------------------------*/
294 /*----------------------------------------------------------------------------*/
295 
296 void
297 cs_fuel_thfieldconv1(int location_id,
298  const cs_real_t eh[],
299  cs_real_t tp[]);
300 
301 /*----------------------------------------------------------------------------
302  * Return Lagrangian model status.
303  *
304  * parameters:
305  * model_flag --> 0 without Lagrangian, 1 or 2 with Lagrangian
306  * restart_flag --> 1 for Lagrangian restart, 0 otherwise
307  * frozen_flag --> 1 for frozen Eulerian flow, 0 otherwise
308  *----------------------------------------------------------------------------*/
309 
310 void
311 cs_lagr_status(int *model_flag,
312  int *restart_flag,
313  int *frozen_flag);
314 
315 /*----------------------------------------------------------------------------
316  * Return condensation model metal structures metal surface.
317  *
318  * return:
319  * metal structures surface
320  *----------------------------------------------------------------------------*/
321 
322 double
323 cs_tagms_s_metal(void);
324 
325 /*============================================================================
326  * User function prototypes
327  *============================================================================*/
328 
329 /*----------------------------------------------------------------------------
330  * Data Entry of the 1D wall thermal module.
331  *----------------------------------------------------------------------------*/
332 
333 void
334 cs_user_1d_wall_thermal(int iappel,
335  int isuit1);
336 
337 /*----------------------------------------------------------------------------
338  * Setup boundary conditions to be applied.
339  *----------------------------------------------------------------------------*/
340 
341 void
342 cs_user_boundary_conditions_setup(cs_domain_t *domain);
343 
344 /*----------------------------------------------------------------------------
345  * This function is called at each time step for boundary conditions.
346  *----------------------------------------------------------------------------*/
347 
348 void
349 cs_user_boundary_conditions(int nvar,
350  int icodcl[],
351  int bc_type[],
352  cs_real_t rcodcl[]);
353 
354 /*----------------------------------------------------------------------------*/
366 /*----------------------------------------------------------------------------*/
367 
368 void
369 cs_user_extra_operations_initialize(cs_domain_t *domain);
370 
371 /*----------------------------------------------------------------------------*/
380 /*----------------------------------------------------------------------------*/
381 
382 void
383 cs_user_extra_operations(cs_domain_t *domain);
384 
385 /*----------------------------------------------------------------------------*/
394 /*----------------------------------------------------------------------------*/
395 
396 void
397 cs_user_extra_operations_finalize(cs_domain_t *domain);
398 
399 /*----------------------------------------------------------------------------*/
409 /*----------------------------------------------------------------------------*/
410 
411 void
412 cs_user_head_losses(const cs_zone_t *zone,
413  cs_real_t cku[][6]);
414 
415 /*----------------------------------------------------------------------------*/
421 /*----------------------------------------------------------------------------*/
422 
423 void
424 cs_user_initialization(cs_domain_t *domain);
425 
426 /*----------------------------------------------------------------------------*/
432 /*----------------------------------------------------------------------------*/
433 
434 void
435 cs_user_internal_coupling(void);
436 
437 /*----------------------------------------------------------------------------*/
446 /*----------------------------------------------------------------------------*/
447 
448 void
449 cs_user_internal_coupling_add_volumes(cs_mesh_t *mesh);
450 
451 /*----------------------------------------------------------------------------*/
460 /*----------------------------------------------------------------------------*/
461 
462 void
463 cs_user_internal_coupling_from_disjoint_meshes(cs_mesh_t *mesh);
464 
465 /*----------------------------------------------------------------------------*/
471 /*----------------------------------------------------------------------------*/
472 
473 void
474 cs_user_physical_properties(cs_domain_t *domain);
475 
476 /*----------------------------------------------------------------------------*/
494 /*----------------------------------------------------------------------------*/
495 
496 void
497 cs_user_physical_properties_h_to_t(cs_domain_t *domain,
498  const cs_zone_t *z,
499  bool z_local,
500  const cs_real_t h[restrict],
501  cs_real_t t[restrict]);
502 
503 /*----------------------------------------------------------------------------*/
521 /*----------------------------------------------------------------------------*/
522 
523 void
524 cs_user_physical_properties_t_to_h(cs_domain_t *domain,
525  const cs_zone_t *z,
526  bool z_local,
527  const cs_real_t t[restrict],
528  cs_real_t h[restrict]);
529 
530 /*----------------------------------------------------------------------------*/
540 /*----------------------------------------------------------------------------*/
541 
542 void
543 cs_user_source_terms(cs_domain_t *domain,
544  int f_id,
545  cs_real_t *st_exp,
546  cs_real_t *st_imp);
547 
548 /*----------------------------------------------------------------------------*/
558 /*----------------------------------------------------------------------------*/
559 
560 void
561 cs_user_porosity(cs_domain_t *domain);
562 
563 /*----------------------------------------------------------------------------
564  * Define mesh joinings.
565  *----------------------------------------------------------------------------*/
566 
567 void
568 cs_user_join(void);
569 
570 /*----------------------------------------------------------------------------
571  * Define linear solver options.
572  *
573  * This function is called at the setup stage, once user and most model-based
574  * fields are defined.
575  *----------------------------------------------------------------------------*/
576 
577 void
578 cs_user_linear_solvers(void);
579 
580 /*----------------------------------------------------------------------------*/
586 /*----------------------------------------------------------------------------*/
587 
588 void
589 cs_user_finalize_setup(cs_domain_t *domain);
590 
591 /*----------------------------------------------------------------------------
592  * Tag bad cells within the mesh based on geometric criteria.
593  *----------------------------------------------------------------------------*/
594 
595 void
596 cs_user_mesh_bad_cells_tag(cs_mesh_t *mesh,
597  cs_mesh_quantities_t *mesh_quantities);
598 
599 /*----------------------------------------------------------------------------
600  * Define mesh files to read and optional associated transformations.
601  *----------------------------------------------------------------------------*/
602 
603 void
604 cs_user_mesh_input(void);
605 
606 /*----------------------------------------------------------------------------
607  * Modifiy geometry and mesh.
608  *----------------------------------------------------------------------------*/
609 
610 void
611 cs_user_mesh_modify(cs_mesh_t *mesh);
612 
613 /*----------------------------------------------------------------------------
614  * Insert boundary wall into a mesh.
615  *----------------------------------------------------------------------------*/
616 
617 void
618 cs_user_mesh_boundary(cs_mesh_t *mesh);
619 
620 /*----------------------------------------------------------------------------
621  * Mesh smoothing.
622  *
623  * parameters:
624  * mesh <-> pointer to mesh structure to smoothe
625  *----------------------------------------------------------------------------*/
626 
627 void
628 cs_user_mesh_smoothe(cs_mesh_t *mesh);
629 
630 /*----------------------------------------------------------------------------
631  * Enable or disable mesh saving.
632  *
633  * By default, mesh is saved when modified.
634  *
635  * parameters:
636  * mesh <-> pointer to mesh structure
637  *----------------------------------------------------------------------------*/
638 
639 void
640 cs_user_mesh_save(cs_mesh_t *mesh);
641 
642 /*----------------------------------------------------------------------------
643  * Set options for cutting of warped faces
644  *
645  * parameters:
646  * mesh <-> pointer to mesh structure to smoothe
647  *----------------------------------------------------------------------------*/
648 
649 void
650 cs_user_mesh_warping(void);
651 
652 /*----------------------------------------------------------------------------*/
660 /*----------------------------------------------------------------------------*/
661 
662 void
663 cs_user_mesh_modify_partial(cs_mesh_t *mesh,
664  cs_mesh_quantities_t *mesh_quantities);
665 
666 /*----------------------------------------------------------------------------*/
670 /*----------------------------------------------------------------------------*/
671 
672 void
673 cs_user_mesh_cartesian_define(void);
674 
675 /*----------------------------------------------------------------------------
676  * Select physical model options, including user fields.
677  *
678  * This function is called at the earliest stages of the data setup.
679  *----------------------------------------------------------------------------*/
680 
681 void
682 cs_user_model(void);
683 
684 /*----------------------------------------------------------------------------
685  * Define advanced mesh numbering options.
686  *----------------------------------------------------------------------------*/
687 
688 void
689 cs_user_numbering(void);
690 
691 /*----------------------------------------------------------------------------
692  * Define parallel IO settings.
693  *----------------------------------------------------------------------------*/
694 
695 void
696 cs_user_parallel_io(void);
697 
698 /*----------------------------------------------------------------------------
699  * Define advanced partitioning options.
700  *----------------------------------------------------------------------------*/
701 
702 void
703 cs_user_partition(void);
704 
705 /*----------------------------------------------------------------------------
706  * Define sparse matrix tuning options.
707  *----------------------------------------------------------------------------*/
708 
709 void
710 cs_user_matrix_tuning(void);
711 
712 /*----------------------------------------------------------------------------
713  * Define or modify general numerical and physical user parameters.
714  *
715  * At the calling point of this function, most model-related most variables
716  * and other fields have been defined, so specific settings related to those
717  * fields may be set here.
718  *----------------------------------------------------------------------------*/
719 
720 void
721 cs_user_parameters(cs_domain_t *domain);
722 
723 /*----------------------------------------------------------------------------
724  * User function for input of radiative transfer module options.
725  *----------------------------------------------------------------------------*/
726 
727 void
728 cs_user_radiative_transfer_parameters(void);
729 
730 /*-----------------------------------------------------------------------------
731  * User subroutine for input of radiative transfer boundary conditions
732  *----------------------------------------------------------------------------*/
733 
734 void
735 cs_user_radiative_transfer_bcs(int nvar,
736  const int bc_type[],
737  int icodcl[],
738  int isothp[],
739  cs_real_t *tmin,
740  cs_real_t *tmax,
741  cs_real_t *tx,
742  const cs_real_t dt[],
743  cs_real_t rcodcl[],
744  const cs_real_t thwall[],
745  const cs_real_t qincid[],
746  cs_real_t hfcnvp[],
747  cs_real_t flcnvp[],
748  cs_real_t xlamp[],
749  cs_real_t epap[],
750  cs_real_t epsp[],
751  cs_real_t textp[]);
752 
753 /*----------------------------------------------------------------------------
754  * Define periodic faces.
755  *----------------------------------------------------------------------------*/
756 
757 void
758 cs_user_periodicity(void);
759 
760 /*----------------------------------------------------------------------------
761  * Define post-processing writers.
762  *
763  * The default output format and frequency may be configured, and additional
764  * post-processing writers allowing outputs in different formats or with
765  * different format options and output frequency than the main writer may
766  * be defined.
767  *----------------------------------------------------------------------------*/
768 
769 void
770 cs_user_postprocess_writers(void);
771 
772 /*-----------------------------------------------------------------------------
773  * Define monitoring probes and profiles. A profile is seen as a set of probes.
774  *----------------------------------------------------------------------------*/
775 
776 void
777 cs_user_postprocess_probes(void);
778 
779 /*----------------------------------------------------------------------------
780  * Define post-processing meshes.
781  *
782  * The main post-processing meshes may be configured, and additional
783  * post-processing meshes may be defined as a subset of the main mesh's
784  * cells or faces (both interior and boundary).
785  *----------------------------------------------------------------------------*/
786 
787 void
788 cs_user_postprocess_meshes(void);
789 
790 /*----------------------------------------------------------------------------
791  * User function for output of values on a post-processing mesh.
792  *----------------------------------------------------------------------------*/
793 
794 void
795 cs_user_postprocess_values(const char *mesh_name,
796  int mesh_id,
797  int cat_id,
798  cs_probe_set_t *probes,
799  cs_lnum_t n_cells,
800  cs_lnum_t n_i_faces,
801  cs_lnum_t n_b_faces,
802  cs_lnum_t n_vertices,
803  const cs_lnum_t cell_list[],
804  const cs_lnum_t i_face_list[],
805  const cs_lnum_t b_face_list[],
806  const cs_lnum_t vertex_list[],
807  const cs_time_step_t *ts);
808 
809 /*----------------------------------------------------------------------------
810  * Override default frequency or calculation end based output.
811  *
812  * This allows fine-grained control of activation or deactivation,
813  *
814  * parameters:
815  * nt_max_abs <-- maximum time step number
816  * nt_cur_abs <-- current time step number
817  * t_cur_abs <-- absolute time at the current time step
818  *----------------------------------------------------------------------------*/
819 
820 void
821 cs_user_postprocess_activate(int nt_max_abs,
822  int nt_cur_abs,
823  double t_cur_abs);
824 
825 /*----------------------------------------------------------------------------
826  * Absorption coefficient for radiative module
827  *----------------------------------------------------------------------------*/
828 
829 void
830 cs_user_rad_transfer_absorption(const int bc_type[],
831  cs_real_t ck[]);
832 
833 /*----------------------------------------------------------------------------
834  * Compute the net radiation flux
835  *----------------------------------------------------------------------------*/
836 
837 void
838 cs_user_rad_transfer_net_flux(const int itypfb[],
839  const cs_real_t coefap[],
840  const cs_real_t coefbp[],
841  const cs_real_t cofafp[],
842  const cs_real_t cofbfp[],
843  const cs_real_t twall[],
844  const cs_real_t qincid[],
845  const cs_real_t xlam[],
846  const cs_real_t epa[],
847  const cs_real_t eps[],
848  const cs_real_t ck[],
849  cs_real_t net_flux[]);
850 
851 /*----------------------------------------------------------------------------
852  * Set user solver.
853  *----------------------------------------------------------------------------*/
854 
855 int
856 cs_user_solver_set(void);
857 
858 /*----------------------------------------------------------------------------
859  * Main call to user solver.
860  *----------------------------------------------------------------------------*/
861 
862 void
863 cs_user_solver(const cs_mesh_t *mesh,
864  const cs_mesh_quantities_t *mesh_quantities);
865 
866 /*----------------------------------------------------------------------------
867  * Define couplings with other instances of Code_Saturne.
868  *----------------------------------------------------------------------------*/
869 
870 void
871 cs_user_saturne_coupling(void);
872 
873 /*----------------------------------------------------------------------------
874  * Define couplings with SYRTHES code.
875  *----------------------------------------------------------------------------*/
876 
877 void
878 cs_user_syrthes_coupling(void);
879 
880 /*----------------------------------------------------------------------------*/
890 /*----------------------------------------------------------------------------*/
891 
892 void
893 cs_user_syrthes_coupling_volume_h(int coupling_id,
894  const char *syrthes_name,
895  cs_lnum_t n_elts,
896  const cs_lnum_t elt_ids[],
897  cs_real_t h_vol[]);
898 
899 /*----------------------------------------------------------------------------
900  * Define time moments.
901  *----------------------------------------------------------------------------*/
902 
903 void
904 cs_user_time_moments(void);
905 
906 /*----------------------------------------------------------------------------
907  * Define rotor/stator model.
908  *----------------------------------------------------------------------------*/
909 
910 void
911 cs_user_turbomachinery(void);
912 
913 /*----------------------------------------------------------------------------
914  * Define rotor axes, associated cells, and rotor/stator faces.
915  *----------------------------------------------------------------------------*/
916 
917 void
918 cs_user_turbomachinery_rotor(void);
919 
920 /*----------------------------------------------------------------------------
921  * Define rotation velocity of rotor.
922  *----------------------------------------------------------------------------*/
923 
924 void
925 cs_user_turbomachinery_set_rotation_velocity(void);
926 
927 /*----------------------------------------------------------------------------*/
931 /*----------------------------------------------------------------------------*/
932 
933 void
934 cs_user_zones(void);
935 
936 /*----------------------------------------------------------------------------*/
940 /*----------------------------------------------------------------------------*/
941 
942 void
943 cs_user_scaling_elec(const cs_mesh_t *mesh,
944  const cs_mesh_quantities_t *mesh_quantities,
945  cs_real_t *dt);
946 
947 /*----------------------------------------------------------------------------
948  * Computation of the relaxation time-scale to equilibrium in the frame of
949  * the homogeneous two-phase model.
950  *----------------------------------------------------------------------------*/
951 
952 void
953 cs_user_hgn_thermo_relax_time(const cs_mesh_t *mesh,
954  const cs_real_t *alpha_eq,
955  const cs_real_t *y_eq,
956  const cs_real_t *z_eq,
957  const cs_real_t *ei,
958  const cs_real_t *v,
959  cs_real_t *relax_tau);
960 
961 /*============================================================================
962  * MEG function prototypes
963  *============================================================================*/
964 
965 /*----------------------------------------------------------------------------*/
978 /*----------------------------------------------------------------------------*/
979 
980 cs_real_t *
981 cs_meg_boundary_function(const cs_zone_t *zone,
982  const char *field_name,
983  const char *condition);
984 
985 /*----------------------------------------------------------------------------*/
993 /*----------------------------------------------------------------------------*/
994 
995 void
996 cs_meg_volume_function(const cs_zone_t *zone,
997  cs_field_t *f[]);
998 
999 /*----------------------------------------------------------------------------*/
1007 /*----------------------------------------------------------------------------*/
1008 
1009 cs_real_t *
1010 cs_meg_initialization(const cs_zone_t *zone,
1011  const char *field_name);
1012 
1013 /*----------------------------------------------------------------------------*/
1025 /*----------------------------------------------------------------------------*/
1026 
1027 cs_real_t *
1028 cs_meg_source_terms(const cs_zone_t *zone,
1029  const char *name,
1030  const char *source_type);
1031 
1032 /*----------------------------------------------------------------------------*/
1044 /*----------------------------------------------------------------------------*/
1045 
1046 void
1047 cs_meg_immersed_boundaries_inout(int *ipenal,
1048  const char *object_name,
1049  cs_real_t xyz[3],
1050  cs_real_t t);
1051 
1052 /*----------------------------------------------------------------------------*/
1062 /*----------------------------------------------------------------------------*/
1063 
1064 void
1065 cs_meg_fsi_struct(const char *object_type,
1066  const char *name,
1067  const cs_real_t fluid_f[],
1068  cs_real_t val[]);
1069 
1070 /*----------------------------------------------------------------------------*/
1074 /*----------------------------------------------------------------------------*/
1075 
1076 void
1077 cs_meg_post_activate(void);
1078 
1079 /*----------------------------------------------------------------------------*/
1087 /*----------------------------------------------------------------------------*/
1088 
1089 void
1090 cs_meg_post_profiles(const char *name,
1091  int n_coords,
1092  cs_real_t coords[][3]);
1093 
1094 /*----------------------------------------------------------------------------*/
1098 /*----------------------------------------------------------------------------*/
1099 
1100 void
1101 cs_user_paramedmem_define_couplings(void);
1102 
1103 /*----------------------------------------------------------------------------*/
1107 /*----------------------------------------------------------------------------*/
1108 
1109 void
1110 cs_user_paramedmem_define_meshes(void);
1111 
1112 /*----------------------------------------------------------------------------*/
1116 /*----------------------------------------------------------------------------*/
1117 
1118 void
1119 cs_user_paramedmem_define_fields(void);
1120 
1121 /*----------------------------------------------------------------------------*/
1122 
1123 END_C_DECLS
1124 
1125 #endif /* __CS_PROTOTYPES_H__ */
cs_user_finalize_setup
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:180
cs_user_partition
void cs_user_partition(void)
Define advanced partitioning options.
Definition: cs_user_performance_tuning.c:87
cs_meg_initialization
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:70
cpthp1
void cpthp1(const int *mode, cs_real_t *eh, cs_real_t *xesp, cs_real_t *f1mc, cs_real_t *f2mc, cs_real_t *tp)
cs_user_internal_coupling_add_volumes
void cs_user_internal_coupling_add_volumes(cs_mesh_t *mesh)
Define volumes as internal coupling zones.
Definition: cs_internal_coupling.c:3147
cs_time_step_t
time step descriptor
Definition: cs_time_step.h:64
mesh::ncel
integer, save ncel
Definition: mesh.f90:50
restrict
#define restrict
Definition: cs_defs.h:142
cs_user_extra_operations_finalize
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:126
initi1
void initi1(void)
Definition: initi1.f90:29
cs_user_internal_coupling
void cs_user_internal_coupling(void)
Define internal coupling options.
Definition: cs_user_parameters.c:162
cs_user_physical_properties
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:81
cs_base.h
cs_user_paramedmem_define_meshes
void cs_user_paramedmem_define_meshes(void)
Define coupled meshes.
Definition: cs_user_paramedmem_coupling.c:95
cs_user_physical_properties_h_to_t
void cs_user_physical_properties_h_to_t(cs_domain_t *domain, const cs_zone_t *z, bool z_local, const cs_real_t h[restrict], cs_real_t t[restrict])
User definition of enthalpy to temperature conversion.
cs_user_periodicity
void cs_user_periodicity(void)
Define periodic faces.
Definition: cs_user_mesh.c:108
cs_user_extra_operations
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:108
cs_user_boundary_conditions_setup
void cs_user_boundary_conditions_setup(cs_domain_t *domain)
Set boundary conditions to be applied.
Definition: cs_user_boundary_conditions.c:70
cs_user_turbomachinery
void cs_user_turbomachinery(void)
Define rotor/stator model.
Definition: cs_user_turbomachinery.c:77
cs_field_t
Field descriptor.
Definition: cs_field.h:125
cs_user_rad_transfer_absorption
void cs_user_rad_transfer_absorption(const int bc_type[], cs_real_t ck[])
Absorption coefficient for radiative module.
Definition: cs_user_radiative_transfer.c:103
cs_user_mesh_cartesian_define
void cs_user_mesh_cartesian_define(void)
Define a cartesian mesh.
Definition: cs_user_mesh.c:233
cs_hydrostatic_pressure_compute
void cs_hydrostatic_pressure_compute(int *indhyd, int iterns, cs_real_t fext[][3], cs_real_t dfext[][3], cs_real_t phydr[], cs_real_t flumas[], cs_real_t flumab[], cs_real_t viscf[], cs_real_t viscb[], cs_real_t dam[], cs_real_t xam[], cs_real_t dpvar[], cs_real_t rhs[])
caltri
void caltri(void)
Definition: caltri.f90:36
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
cs_user_parameters
void cs_user_parameters(cs_domain_t *domain)
Define or modify general numerical and physical user parameters.
Definition: cs_user_parameters.c:107
cs_user_source_terms
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:155
cs_user_postprocess_activate
void cs_user_postprocess_activate(int nt_max_abs, int nt_cur_abs, double t_cur_abs)
Definition: cs_user_postprocess.c:177
haltyp
void haltyp(const int *ivoset)
cs_user_postprocess_meshes
void cs_user_postprocess_meshes(void)
Define post-processing meshes.
Definition: cs_user_postprocess.c:86
cs_user_model
void cs_user_model(void)
Select physical model options, including user fields.
Definition: cs_user_parameters.c:84
cs_tagms_s_metal
double cs_tagms_s_metal(void)
Definition: cs_tagms.f90:124
cs_user_rad_transfer_net_flux
void cs_user_rad_transfer_net_flux(const int itypfb[], 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:141
dvvpst
void dvvpst(const int *nummai, const int *numtyp, const int *nvar, const cs_lnum_t *ncelps, const cs_lnum_t *nfbrps, const cs_lnum_t lstcel[], const cs_lnum_t lstfbr[], cs_real_t tracel[], cs_real_t trafbr[])
cs_fuel_bt2h
void cs_fuel_bt2h(cs_lnum_t n_faces, const cs_lnum_t face_ids[], const cs_real_t t[], cs_real_t h[])
Convert temperature to enthalpy at boundary for fuel combustion.
cs_user_mesh_modify
void cs_user_mesh_modify(cs_mesh_t *mesh)
Modify geometry and mesh.
Definition: cs_user_mesh.c:151
cs_fuel_thfieldconv1
void cs_fuel_thfieldconv1(int location_id, const cs_real_t eh[], cs_real_t tp[])
Calculation of the gas temperature Function with the gas enthalpy and concentrations.
cs_user_join
void cs_user_join(void)
Define mesh joinings.
Definition: cs_user_mesh.c:95
cs_user_paramedmem_define_fields
void cs_user_paramedmem_define_fields(void)
Define fields to couple with ParaMEDMEM.
Definition: cs_user_paramedmem_coupling.c:108
cs_user_syrthes_coupling_volume_h
void cs_user_syrthes_coupling_volume_h(int coupling_id, const char *syrthes_name, cs_lnum_t n_elts, const cs_lnum_t elt_ids[], cs_real_t h_vol[])
Compute a volume exchange coefficient for SYRTHES couplings.
Definition: cs_user_coupling.c:114
cs_user_postprocess_values
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:134
cs_user_scaling_elec
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:75
cs_user_radiative_transfer_parameters
void cs_user_radiative_transfer_parameters(void)
User function for input of radiative transfer module options.
Definition: cs_user_radiative_transfer.c:77
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
cs_user_numbering
void cs_user_numbering(void)
Define advanced mesh numbering options.
Definition: cs_user_performance_tuning.c:74
cs_atmo_get_auto_flag
int * cs_atmo_get_auto_flag(void)
Return pointer to automatic face bc flag array.
Definition: atincl.f90:644
cs_probe.h
mesh::ncelet
integer, save ncelet
Definition: mesh.f90:46
cs_user_mesh_save
void cs_user_mesh_save(cs_mesh_t *mesh)
Enable or disable mesh saving.
Definition: cs_user_mesh.c:183
cs_mesh_t
Definition: cs_mesh.h:84
csinit
void csinit(const int *irgpar, const int *nrgpar)
cs_mesh_bad_cells.h
mesh::xyzcen
double precision, dimension(:,:), pointer xyzcen
Definition: mesh.f90:110
atimbr::v
double precision, dimension(:,:,:), allocatable v
Definition: atimbr.f90:114
cs_user_extra_operations_initialize
void cs_user_extra_operations_initialize(cs_domain_t *domain)
Initialize variables.
Definition: cs_user_extra_operations.c:90
cs_domain.h
cs_user_matrix_tuning
void cs_user_matrix_tuning(void)
Define sparse matrix tuning options.
Definition: cs_user_performance_tuning.c:113
cs_user_mesh_warping
void cs_user_mesh_warping(void)
Set options for cutting of warped faces.
Definition: cs_user_mesh.c:121
cs_mesh_quantities.h
cs_user_solver
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:92
cs_meg_immersed_boundaries_inout
void cs_meg_immersed_boundaries_inout(int *ipenal, const char *object_name, cs_real_t xyz[3], cs_real_t t)
cs_user_postprocess_probes
void cs_user_postprocess_probes(void)
Define monitoring probes and profiles.
Definition: cs_user_postprocess.c:101
cs_lagr_status
void cs_lagr_status(int *model_flag, int *restart_flag, int *frozen_flag)
cs_user_solver_set
int cs_user_solver_set(void)
Set user solver.
Definition: cs_user_solver.c:75
h
Definition: cs_field_pointer.h:91
dt
Definition: cs_field_pointer.h:65
cs_get_cavitation_gam
cs_real_t * cs_get_cavitation_gam(void)
Return pointer to cavitation "gamcav" array.
Definition: pointe.f90:741
cs_meg_fsi_struct
void cs_meg_fsi_struct(const char *object_type, const char *name, const cs_real_t fluid_f[], cs_real_t val[])
This function is used to query FSI internal coupling structure values for a given boundary and struct...
Definition: cs_meg_fsi_struct.c:70
cs_user_linear_solvers
void cs_user_linear_solvers(void)
Define linear solver options.
Definition: cs_user_parameters.c:130
cs_mesh_quantities_t
Definition: cs_mesh_quantities.h:89
cs_user_internal_coupling_from_disjoint_meshes
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:3166
pointe::itypfb
integer, dimension(:), pointer, save itypfb
Definition: pointe.f90:100
optcal::isuit1
integer, save isuit1
Definition: optcal.f90:297
cs_domain_t
Structure storing the main features of the computational domain and pointers to the main geometrical ...
Definition: cs_domain.h:140
dimens::nvar
integer, save nvar
number of solved variables (must be lower than nvarmx)
Definition: dimens.f90:42
cs_get_b_head_loss
cs_real_t * cs_get_b_head_loss(void)
Return pointer to boundary head losses array.
Definition: pointe.f90:713
cs_meg_boundary_function
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:71
cs_meg_post_profiles
void cs_meg_post_profiles(const char *name, int n_coords, cs_real_t coords[][3])
This function is used to define profile coordinates.
Definition: cs_meg_post_profile.c:68
cs_user_time_moments
void cs_user_time_moments(void)
Define time moments.
Definition: cs_user_parameters.c:147
cs_user_radiative_transfer_bcs
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[])
User definition of radiative transfer boundary conditions.
Definition: cs_user_radiative_transfer_bcs.c:130
xlam
Definition: cs_field_pointer.h:183
cs_user_mesh_input
void cs_user_mesh_input(void)
Define mesh files to read and optional associated transformations.
Definition: cs_user_mesh.c:82
cs_user_mesh_bad_cells_tag
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:199
cs_user_postprocess_writers
void cs_user_postprocess_writers(void)
Define post-processing writers.
Definition: cs_user_postprocess.c:69
cs_field.h
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
cs_mesh.h
cs_meg_source_terms
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:71
cs_coal_bt2h
void cs_coal_bt2h(cs_lnum_t n_faces, const cs_lnum_t face_ids[], const cs_real_t t[], cs_real_t h[])
Convert temperature to enthalpy at boundary for coal combustion.
cs_coal_thfieldconv1
void cs_coal_thfieldconv1(int location_id, const cs_real_t eh[], cs_real_t tp[])
Calculation of the gas temperature Function with the gas enthalpy and concentrations.
cs_add_model_field_indexes
int cs_add_model_field_indexes(int f_id)
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:511
cs_meg_volume_function
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:68
cs_meg_post_activate
void cs_meg_post_activate(void)
This function is used to activate postprocessing writers.
Definition: cs_meg_post_output.c:64
cs_user_turbomachinery_set_rotation_velocity
void cs_user_turbomachinery_set_rotation_velocity(void)
Define rotation velocity of rotor.
Definition: cs_user_turbomachinery.c:103
cs_probe_set_t
struct _cs_probe_set_t cs_probe_set_t
Definition: cs_probe.h:53
cs_user_paramedmem_define_couplings
void cs_user_paramedmem_define_couplings(void)
Define ParaMEDMEM coupling(s)
Definition: cs_user_paramedmem_coupling.c:82
cs_user_hgn_thermo_relax_time
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:82
CS_PROCF
#define CS_PROCF(x, y)
Definition: cs_defs.h:524
cs_user_mesh_boundary
void cs_user_mesh_boundary(cs_mesh_t *mesh)
Insert boundaries into a mesh.
Definition: cs_user_mesh.c:136
cs_user_syrthes_coupling
void cs_user_syrthes_coupling(void)
Define couplings with SYRTHES code.
Definition: cs_user_coupling.c:95
t
Definition: cs_field_pointer.h:92
cs_user_turbomachinery_rotor
void cs_user_turbomachinery_rotor(void)
Define rotor axes, associated cells, and rotor/stator faces.
Definition: cs_user_turbomachinery.c:90
findpt
void findpt(const cs_lnum_t *ncelet, const cs_lnum_t *ncel, const cs_real_t *xyzcen, const cs_real_t *xx, const cs_real_t *yy, const cs_real_t *zz, cs_lnum_t *node, int *ndrang)
cs_get_cavitation_dgdp_st
cs_real_t * cs_get_cavitation_dgdp_st(void)
Return pointer to cavitation "dgdpca" array.
Definition: pointe.f90:727
cs_user_physical_properties_t_to_h
void cs_user_physical_properties_t_to_h(cs_domain_t *domain, const cs_zone_t *z, bool z_local, const cs_real_t t[restrict], cs_real_t h[restrict])
User definition of temperature to enthalpy conversion.
cs_user_parallel_io
void cs_user_parallel_io(void)
Define parallel IO settings.
Definition: cs_user_performance_tuning.c:100
eps
Definition: cs_field_pointer.h:71
cs_user_head_losses
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:92
cs_volume_zone.h
cs_user_saturne_coupling
void cs_user_saturne_coupling(void)
Define couplings with other instances of Code_Saturne.
Definition: cs_user_coupling.c:79
cs_user_mesh_smoothe
void cs_user_mesh_smoothe(cs_mesh_t *mesh)
Mesh smoothing.
Definition: cs_user_mesh.c:166
cs_user_1d_wall_thermal
void cs_user_1d_wall_thermal(int iappel, int isuit1)
Definition: cs_user_1d_wall_thermal.c:88
cs_user_boundary_conditions
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:98
mesh
Definition: mesh.f90:26
cs_user_mesh_modify_partial
void cs_user_mesh_modify_partial(cs_mesh_t *mesh, cs_mesh_quantities_t *mesh_quantities)
Apply partial modifications to the mesh after the preprocessing and initial postprocessing mesh build...
Definition: cs_user_mesh.c:218
distpr
void distpr(const int *itypfb, cs_real_t *distpa)
cs_user_porosity
void cs_user_porosity(cs_domain_t *domain)
Compute the porosity (volume factor when the porosity model is activated. (cs_glob_porous_model > 0)...
Definition: cs_user_porosity.c:80
cs_user_initialization
void cs_user_initialization(cs_domain_t *domain)
This function is called one time step to initialize problem.
Definition: cs_user_initialization.c:88
epa
Definition: cs_field_pointer.h:184
cs_zone_t
Definition: cs_zone.h:55
cs_user_zones
void cs_user_zones(void)
Define volume and surface zones.
Definition: cs_user_zones.c:65