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 
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  * Developer function for output of variables on a post-processing mesh
108  *----------------------------------------------------------------------------*/
109 
110 extern void CS_PROCF (dvvpst, DVVPST)
111 (
112  const int *nummai, /* <-- number or post-processing mesh */
113  const int *numtyp, /* <-- number or post-processing type
114  * (-1 as volume, -2 as boundary, or nummai) */
115  const int *nvar, /* <-- number of variables */
116  const cs_lnum_t *ncelps, /* <-- number of post-processed cells */
117  const cs_lnum_t *nfbrps, /* <-- number of post processed boundary faces */
118  const cs_lnum_t lstcel[], /* <-- list of post-processed cells */
119  const cs_lnum_t lstfbr[], /* <-- list of post-processed boundary faces */
120  cs_real_t tracel[], /* --- work array for output cells */
121  cs_real_t trafbr[] /* --- work array for output boundary faces */
122 );
123 
124 /*----------------------------------------------------------------------------
125  * Find the nearest cell's center from a node
126  *----------------------------------------------------------------------------*/
127 
128 extern void CS_PROCF (findpt, FINDPT)
129 (
130  const cs_lnum_t *ncelet, /* <-- number of extended (real + ghost) cells */
131  const cs_lnum_t *ncel, /* <-- number of cells */
132  const cs_real_t *xyzcen, /* <-- cell centers */
133  const cs_real_t *xx, /* <-- node coordinate X */
134  const cs_real_t *yy, /* <-- node coordinate Y */
135  const cs_real_t *zz, /* <-- node coordinate Z */
136  cs_lnum_t *node, /* --> node we are looking for, zero if error */
137  int *ndrang /* --> rank of associated process */
138 );
139 
140 /*----------------------------------------------------------------------------
141  * Check necessity of extended mesh from FORTRAN options.
142  *
143  * Interface Fortran :
144  *
145  * SUBROUTINE HALTYP (IVOSET)
146  * *****************
147  *
148  * INTEGER IVOSET : <-- : Indicator of necessity of extended mesh
149  *----------------------------------------------------------------------------*/
150 
151 extern void
152 CS_PROCF (haltyp, HALTYP)(const int *ivoset);
153 
154 /*----------------------------------------------------------------------------
155  * Main Fortran options initialization
156  *----------------------------------------------------------------------------*/
157 
158 extern void CS_PROCF (initi1, INITI1)
159 (
160  void
161 );
162 
163 /*----------------------------------------------------------------------------*/
169 /*----------------------------------------------------------------------------*/
170 
171 int *
173 
174 /*----------------------------------------------------------------------------
175  * Add field indexes associated with a new non-user solved variable,
176  * with default options
177  *
178  * parameters:
179  * f_id <-- field id
180  *
181  * returns:
182  * scalar number for defined field
183  *----------------------------------------------------------------------------*/
184 
185 int
187 
188 /*----------------------------------------------------------------------------*/
198 /*----------------------------------------------------------------------------*/
199 
200 void
201 cs_coal_bt2h(cs_lnum_t n_faces,
202  const cs_lnum_t face_ids[],
203  const cs_real_t t[],
204  cs_real_t h[]);
205 
206 /*----------------------------------------------------------------------------*/
216 /*----------------------------------------------------------------------------*/
217 
218 void
219 cs_coal_thfieldconv1(int location_id,
220  const cs_real_t eh[],
221  cs_real_t tp[]);
222 
223 /*----------------------------------------------------------------------------*/
229 /*----------------------------------------------------------------------------*/
230 
231 cs_real_t *
232 cs_get_b_head_loss(void);
233 
234 /*----------------------------------------------------------------------------*/
240 /*----------------------------------------------------------------------------*/
241 
242 cs_real_t *
244 
245 /*----------------------------------------------------------------------------*/
251 /*----------------------------------------------------------------------------*/
252 
253 cs_real_t *
255 
256 /*----------------------------------------------------------------------------*/
266 /*----------------------------------------------------------------------------*/
267 
268 void
269 cs_fuel_bt2h(cs_lnum_t n_faces,
270  const cs_lnum_t face_ids[],
271  const cs_real_t t[],
272  cs_real_t h[]);
273 
274 /*----------------------------------------------------------------------------*/
284 /*----------------------------------------------------------------------------*/
285 
286 void
287 cs_fuel_thfieldconv1(int location_id,
288  const cs_real_t eh[],
289  cs_real_t tp[]);
290 
291 /*----------------------------------------------------------------------------
292  * Return Lagrangian model status.
293  *
294  * parameters:
295  * model_flag --> 0 without Lagrangian, 1 or 2 with Lagrangian
296  * restart_flag --> 1 for Lagrangian restart, 0 otherwise
297  * frozen_flag --> 1 for frozen Eulerian flow, 0 otherwise
298  *----------------------------------------------------------------------------*/
299 
300 void
301 cs_lagr_status(int *model_flag,
302  int *restart_flag,
303  int *frozen_flag);
304 
305 /*----------------------------------------------------------------------------
306  * Return condensation model metal structures metal surface.
307  *
308  * return:
309  * metal structures surface
310  *----------------------------------------------------------------------------*/
311 
312 double
313 cs_tagms_s_metal(void);
314 
315 /*============================================================================
316  * User function prototypes
317  *============================================================================*/
318 
319 /*----------------------------------------------------------------------------
320  * Data Entry of the 1D wall thermal module.
321  *----------------------------------------------------------------------------*/
322 
323 void
324 cs_user_1d_wall_thermal(int iappel,
325  int isuit1);
326 
327 /*----------------------------------------------------------------------------
328  * Setup boundary conditions to be applied.
329  *----------------------------------------------------------------------------*/
330 
331 void
333 
334 /*----------------------------------------------------------------------------
335  * This function is called at each time step for boundary conditions.
336  *----------------------------------------------------------------------------*/
337 
338 void
340  int icodcl[],
341  int bc_type[],
342  cs_real_t rcodcl[]);
343 
344 /*----------------------------------------------------------------------------*/
356 /*----------------------------------------------------------------------------*/
357 
358 void
360 
361 /*----------------------------------------------------------------------------*/
370 /*----------------------------------------------------------------------------*/
371 
372 void
374 
375 /*----------------------------------------------------------------------------*/
384 /*----------------------------------------------------------------------------*/
385 
386 void
388 
389 /*----------------------------------------------------------------------------*/
399 /*----------------------------------------------------------------------------*/
400 
401 void
402 cs_user_head_losses(const cs_zone_t *zone,
403  cs_real_t cku[][6]);
404 
405 /*----------------------------------------------------------------------------*/
411 /*----------------------------------------------------------------------------*/
412 
413 void
415 
416 /*----------------------------------------------------------------------------*/
422 /*----------------------------------------------------------------------------*/
423 
424 void
426 
427 /*----------------------------------------------------------------------------*/
436 /*----------------------------------------------------------------------------*/
437 
438 void
440 
441 /*----------------------------------------------------------------------------*/
450 /*----------------------------------------------------------------------------*/
451 
452 void
454 
455 /*----------------------------------------------------------------------------*/
461 /*----------------------------------------------------------------------------*/
462 
463 void
465 
466 /*----------------------------------------------------------------------------*/
484 /*----------------------------------------------------------------------------*/
485 
486 void
488  const cs_zone_t *z,
489  bool z_local,
490  const cs_real_t h[restrict],
491  cs_real_t t[restrict]);
492 
493 /*----------------------------------------------------------------------------*/
511 /*----------------------------------------------------------------------------*/
512 
513 void
515  const cs_zone_t *z,
516  bool z_local,
517  const cs_real_t t[restrict],
518  cs_real_t h[restrict]);
519 
520 /*----------------------------------------------------------------------------*/
530 /*----------------------------------------------------------------------------*/
531 
532 void
534  int f_id,
535  cs_real_t *st_exp,
536  cs_real_t *st_imp);
537 
538 /*----------------------------------------------------------------------------*/
548 /*----------------------------------------------------------------------------*/
549 
550 void
552 
553 /*----------------------------------------------------------------------------
554  * Define mesh joinings.
555  *----------------------------------------------------------------------------*/
556 
557 void
558 cs_user_join(void);
559 
560 /*----------------------------------------------------------------------------
561  * Define linear solver options.
562  *
563  * This function is called at the setup stage, once user and most model-based
564  * fields are defined.
565  *----------------------------------------------------------------------------*/
566 
567 void
569 
570 /*----------------------------------------------------------------------------*/
576 /*----------------------------------------------------------------------------*/
577 
578 void
580 
581 /*----------------------------------------------------------------------------
582  * Tag bad cells within the mesh based on geometric criteria.
583  *----------------------------------------------------------------------------*/
584 
585 void
587  cs_mesh_quantities_t *mesh_quantities);
588 
589 /*----------------------------------------------------------------------------
590  * Define mesh files to read and optional associated transformations.
591  *----------------------------------------------------------------------------*/
592 
593 void
594 cs_user_mesh_input(void);
595 
596 /*----------------------------------------------------------------------------
597  * Modifiy geometry and mesh.
598  *----------------------------------------------------------------------------*/
599 
600 void
602 
603 /*----------------------------------------------------------------------------
604  * Insert boundary wall into a mesh.
605  *----------------------------------------------------------------------------*/
606 
607 void
609 
610 /*----------------------------------------------------------------------------
611  * Mesh smoothing.
612  *
613  * parameters:
614  * mesh <-> pointer to mesh structure to smoothe
615  *----------------------------------------------------------------------------*/
616 
617 void
619 
620 /*----------------------------------------------------------------------------
621  * Enable or disable mesh saving.
622  *
623  * By default, mesh is saved when modified.
624  *
625  * parameters:
626  * mesh <-> pointer to mesh structure
627  *----------------------------------------------------------------------------*/
628 
629 void
631 
632 /*----------------------------------------------------------------------------
633  * Set options for cutting of warped faces
634  *
635  * parameters:
636  * mesh <-> pointer to mesh structure to smoothe
637  *----------------------------------------------------------------------------*/
638 
639 void
641 
642 /*----------------------------------------------------------------------------*/
650 /*----------------------------------------------------------------------------*/
651 
652 void
654  cs_mesh_quantities_t *mesh_quantities);
655 
656 /*----------------------------------------------------------------------------*/
660 /*----------------------------------------------------------------------------*/
661 
662 void
664 
665 /*----------------------------------------------------------------------------
666  * Select physical model options, including user fields.
667  *
668  * This function is called at the earliest stages of the data setup.
669  *----------------------------------------------------------------------------*/
670 
671 void
672 cs_user_model(void);
673 
674 /*----------------------------------------------------------------------------
675  * Define advanced mesh numbering options.
676  *----------------------------------------------------------------------------*/
677 
678 void
679 cs_user_numbering(void);
680 
681 /*----------------------------------------------------------------------------
682  * Define parallel IO settings.
683  *----------------------------------------------------------------------------*/
684 
685 void
686 cs_user_parallel_io(void);
687 
688 /*----------------------------------------------------------------------------
689  * Define advanced partitioning options.
690  *----------------------------------------------------------------------------*/
691 
692 void
693 cs_user_partition(void);
694 
695 /*----------------------------------------------------------------------------
696  * Define sparse matrix tuning options.
697  *----------------------------------------------------------------------------*/
698 
699 void
701 
702 /*----------------------------------------------------------------------------
703  * Define or modify general numerical and physical user parameters.
704  *
705  * At the calling point of this function, most model-related most variables
706  * and other fields have been defined, so specific settings related to those
707  * fields may be set here.
708  *----------------------------------------------------------------------------*/
709 
710 void
712 
713 /*----------------------------------------------------------------------------
714  * User function for input of radiative transfer module options.
715  *----------------------------------------------------------------------------*/
716 
717 void
719 
720 /*-----------------------------------------------------------------------------
721  * User subroutine for input of radiative transfer boundary conditions
722  *----------------------------------------------------------------------------*/
723 
724 void
726  const int bc_type[],
727  int icodcl[],
728  int isothp[],
729  cs_real_t *tmin,
730  cs_real_t *tmax,
731  cs_real_t *tx,
732  const cs_real_t dt[],
733  cs_real_t rcodcl[],
734  const cs_real_t thwall[],
735  const cs_real_t qincid[],
736  cs_real_t hfcnvp[],
737  cs_real_t flcnvp[],
738  cs_real_t xlamp[],
739  cs_real_t epap[],
740  cs_real_t epsp[],
741  cs_real_t textp[]);
742 
743 /*----------------------------------------------------------------------------
744  * Define periodic faces.
745  *----------------------------------------------------------------------------*/
746 
747 void
748 cs_user_periodicity(void);
749 
750 /*----------------------------------------------------------------------------
751  * Define post-processing writers.
752  *
753  * The default output format and frequency may be configured, and additional
754  * post-processing writers allowing outputs in different formats or with
755  * different format options and output frequency than the main writer may
756  * be defined.
757  *----------------------------------------------------------------------------*/
758 
759 void
761 
762 /*-----------------------------------------------------------------------------
763  * Define monitoring probes and profiles. A profile is seen as a set of probes.
764  *----------------------------------------------------------------------------*/
765 
766 void
768 
769 /*----------------------------------------------------------------------------
770  * Define post-processing meshes.
771  *
772  * The main post-processing meshes may be configured, and additional
773  * post-processing meshes may be defined as a subset of the main mesh's
774  * cells or faces (both interior and boundary).
775  *----------------------------------------------------------------------------*/
776 
777 void
779 
780 /*----------------------------------------------------------------------------
781  * User function for output of values on a post-processing mesh.
782  *----------------------------------------------------------------------------*/
783 
784 void
785 cs_user_postprocess_values(const char *mesh_name,
786  int mesh_id,
787  int cat_id,
788  cs_probe_set_t *probes,
789  cs_lnum_t n_cells,
790  cs_lnum_t n_i_faces,
791  cs_lnum_t n_b_faces,
792  cs_lnum_t n_vertices,
793  const cs_lnum_t cell_list[],
794  const cs_lnum_t i_face_list[],
795  const cs_lnum_t b_face_list[],
796  const cs_lnum_t vertex_list[],
797  const cs_time_step_t *ts);
798 
799 /*----------------------------------------------------------------------------
800  * Override default frequency or calculation end based output.
801  *
802  * This allows fine-grained control of activation or deactivation,
803  *
804  * parameters:
805  * nt_max_abs <-- maximum time step number
806  * nt_cur_abs <-- current time step number
807  * t_cur_abs <-- absolute time at the current time step
808  *----------------------------------------------------------------------------*/
809 
810 void
811 cs_user_postprocess_activate(int nt_max_abs,
812  int nt_cur_abs,
813  double t_cur_abs);
814 
815 /*----------------------------------------------------------------------------
816  * Absorption coefficient for radiative module
817  *----------------------------------------------------------------------------*/
818 
819 void
820 cs_user_rad_transfer_absorption(const int bc_type[],
821  cs_real_t ck[]);
822 
823 /*----------------------------------------------------------------------------
824  * Compute the net radiation flux
825  *----------------------------------------------------------------------------*/
826 
827 void
829  const cs_real_t coefap[],
830  const cs_real_t coefbp[],
831  const cs_real_t cofafp[],
832  const cs_real_t cofbfp[],
833  const cs_real_t twall[],
834  const cs_real_t qincid[],
835  const cs_real_t xlam[],
836  const cs_real_t epa[],
837  const cs_real_t eps[],
838  const cs_real_t ck[],
839  cs_real_t net_flux[]);
840 
841 /*----------------------------------------------------------------------------
842  * Set user solver.
843  *----------------------------------------------------------------------------*/
844 
845 int
846 cs_user_solver_set(void);
847 
848 /*----------------------------------------------------------------------------
849  * Main call to user solver.
850  *----------------------------------------------------------------------------*/
851 
852 void
854  const cs_mesh_quantities_t *mesh_quantities);
855 
856 /*----------------------------------------------------------------------------
857  * Define couplings with other instances of Code_Saturne.
858  *----------------------------------------------------------------------------*/
859 
860 void
862 
863 /*----------------------------------------------------------------------------
864  * Define couplings with SYRTHES code.
865  *----------------------------------------------------------------------------*/
866 
867 void
869 
870 /*----------------------------------------------------------------------------*/
880 /*----------------------------------------------------------------------------*/
881 
882 void
883 cs_user_syrthes_coupling_volume_h(int coupling_id,
884  const char *syrthes_name,
885  cs_lnum_t n_elts,
886  const cs_lnum_t elt_ids[],
887  cs_real_t h_vol[]);
888 
889 /*----------------------------------------------------------------------------
890  * Define time moments.
891  *----------------------------------------------------------------------------*/
892 
893 void
895 
896 /*----------------------------------------------------------------------------
897  * Define rotor/stator model.
898  *----------------------------------------------------------------------------*/
899 
900 void
902 
903 /*----------------------------------------------------------------------------
904  * Define rotor axes, associated cells, and rotor/stator faces.
905  *----------------------------------------------------------------------------*/
906 
907 void
909 
910 /*----------------------------------------------------------------------------
911  * Define rotation velocity of rotor.
912  *----------------------------------------------------------------------------*/
913 
914 void
916 
917 /*----------------------------------------------------------------------------*/
921 /*----------------------------------------------------------------------------*/
922 
923 void
924 cs_user_zones(void);
925 
926 /*----------------------------------------------------------------------------*/
930 /*----------------------------------------------------------------------------*/
931 
932 void
934  const cs_mesh_quantities_t *mesh_quantities,
935  cs_real_t *dt);
936 
937 /*----------------------------------------------------------------------------
938  * Computation of the relaxation time-scale to equilibrium in the frame of
939  * the homogeneous two-phase model.
940  *----------------------------------------------------------------------------*/
941 
942 void
944  const cs_real_t *alpha_eq,
945  const cs_real_t *y_eq,
946  const cs_real_t *z_eq,
947  const cs_real_t *ei,
948  const cs_real_t *v,
949  cs_real_t *relax_tau);
950 
951 /*============================================================================
952  * MEG function prototypes
953  *============================================================================*/
954 
955 /*----------------------------------------------------------------------------*/
968 /*----------------------------------------------------------------------------*/
969 
970 cs_real_t *
972  const char *field_name,
973  const char *condition);
974 
975 /*----------------------------------------------------------------------------*/
983 /*----------------------------------------------------------------------------*/
984 
985 void
987  cs_field_t *f[]);
988 
989 /*----------------------------------------------------------------------------*/
997 /*----------------------------------------------------------------------------*/
998 
999 cs_real_t *
1000 cs_meg_initialization(const cs_zone_t *zone,
1001  const char *field_name);
1002 
1003 /*----------------------------------------------------------------------------*/
1015 /*----------------------------------------------------------------------------*/
1016 
1017 cs_real_t *
1018 cs_meg_source_terms(const cs_zone_t *zone,
1019  const char *name,
1020  const char *source_type);
1021 
1022 /*----------------------------------------------------------------------------*/
1034 /*----------------------------------------------------------------------------*/
1035 
1036 void
1038  const char *object_name,
1039  cs_real_t xyz[3],
1040  cs_real_t t);
1041 
1042 /*----------------------------------------------------------------------------*/
1052 /*----------------------------------------------------------------------------*/
1053 
1054 void
1055 cs_meg_fsi_struct(const char *object_type,
1056  const char *name,
1057  const cs_real_t fluid_f[],
1058  cs_real_t val[]);
1059 
1060 /*----------------------------------------------------------------------------*/
1064 /*----------------------------------------------------------------------------*/
1065 
1066 void
1067 cs_meg_post_activate(void);
1068 
1069 /*----------------------------------------------------------------------------*/
1077 /*----------------------------------------------------------------------------*/
1078 
1079 void
1080 cs_meg_post_profiles(const char *name,
1081  int n_coords,
1082  cs_real_t coords[][3]);
1083 
1084 /*----------------------------------------------------------------------------*/
1088 /*----------------------------------------------------------------------------*/
1089 
1090 void
1092 
1093 /*----------------------------------------------------------------------------*/
1097 /*----------------------------------------------------------------------------*/
1098 
1099 void
1101 
1102 /*----------------------------------------------------------------------------*/
1106 /*----------------------------------------------------------------------------*/
1107 
1108 void
1110 
1111 /*----------------------------------------------------------------------------*/
1112 
1114 
1115 #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:180
void cs_user_partition(void)
Define advanced partitioning options.
Definition: cs_user_performance_tuning.c:87
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
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)
void cs_user_internal_coupling_add_volumes(cs_mesh_t *mesh)
Define volumes as internal coupling zones.
Definition: cs_internal_coupling.c:3147
time step descriptor
Definition: cs_time_step.h:64
integer, save ncel
Definition: mesh.f90:50
#define restrict
Definition: cs_defs.h:142
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
void initi1(void)
Definition: initi1.f90:29
void cs_user_internal_coupling(void)
Define internal coupling options.
Definition: cs_user_parameters.c:162
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
void cs_user_paramedmem_define_meshes(void)
Define coupled meshes.
Definition: cs_user_paramedmem_coupling.c:95
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.
void cs_user_periodicity(void)
Define periodic faces.
Definition: cs_user_mesh.c:108
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
void cs_user_boundary_conditions_setup(cs_domain_t *domain)
Set boundary conditions to be applied.
Definition: cs_user_boundary_conditions.c:70
void cs_user_turbomachinery(void)
Define rotor/stator model.
Definition: cs_user_turbomachinery.c:77
Field descriptor.
Definition: cs_field.h:125
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
void cs_user_mesh_cartesian_define(void)
Define a cartesian mesh.
Definition: cs_user_mesh.c:233
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[])
void caltri(void)
Definition: caltri.f90:36
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
void cs_user_parameters(cs_domain_t *domain)
Define or modify general numerical and physical user parameters.
Definition: cs_user_parameters.c:107
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
void cs_user_postprocess_activate(int nt_max_abs, int nt_cur_abs, double t_cur_abs)
Definition: cs_user_postprocess.c:177
void haltyp(const int *ivoset)
void cs_user_postprocess_meshes(void)
Define post-processing meshes.
Definition: cs_user_postprocess.c:86
void cs_user_model(void)
Select physical model options, including user fields.
Definition: cs_user_parameters.c:84
double cs_tagms_s_metal(void)
Definition: cs_tagms.f90:124
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
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[])
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.
void cs_user_mesh_modify(cs_mesh_t *mesh)
Modify geometry and mesh.
Definition: cs_user_mesh.c:151
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.
void cs_user_join(void)
Define mesh joinings.
Definition: cs_user_mesh.c:95
void cs_user_paramedmem_define_fields(void)
Define fields to couple with ParaMEDMEM.
Definition: cs_user_paramedmem_coupling.c:108
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
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
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
void cs_user_radiative_transfer_parameters(void)
User function for input of radiative transfer module options.
Definition: cs_user_radiative_transfer.c:77
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
void cs_user_numbering(void)
Define advanced mesh numbering options.
Definition: cs_user_performance_tuning.c:74
int * cs_atmo_get_auto_flag(void)
Return pointer to automatic face bc flag array.
Definition: atincl.f90:644
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:183
Definition: cs_mesh.h:84
void csinit(const int *irgpar, const int *nrgpar)
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:90
void cs_user_matrix_tuning(void)
Define sparse matrix tuning options.
Definition: cs_user_performance_tuning.c:113
void cs_user_mesh_warping(void)
Set options for cutting of warped faces.
Definition: cs_user_mesh.c:121
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
void cs_meg_immersed_boundaries_inout(int *ipenal, const char *object_name, cs_real_t xyz[3], cs_real_t t)
void cs_user_postprocess_probes(void)
Define monitoring probes and profiles.
Definition: cs_user_postprocess.c:101
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:75
Definition: cs_field_pointer.h:91
Definition: cs_field_pointer.h:65
cs_real_t * cs_get_cavitation_gam(void)
Return pointer to cavitation "gamcav" array.
Definition: pointe.f90:741
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
void cs_user_linear_solvers(void)
Define linear solver options.
Definition: cs_user_parameters.c:130
Definition: cs_mesh_quantities.h:89
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
integer, dimension(:), pointer, save itypfb
Definition: pointe.f90:100
integer, save isuit1
Definition: optcal.f90:297
Structure storing the main features of the computational domain and pointers to the main geometrical ...
Definition: cs_domain.h:140
integer, save nvar
number of solved variables (must be lower than nvarmx)
Definition: dimens.f90:42
cs_real_t * cs_get_b_head_loss(void)
Return pointer to boundary head losses array.
Definition: pointe.f90:713
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
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
void cs_user_time_moments(void)
Define time moments.
Definition: cs_user_parameters.c:147
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
Definition: cs_field_pointer.h:183
void cs_user_mesh_input(void)
Define mesh files to read and optional associated transformations.
Definition: cs_user_mesh.c:82
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
void cs_user_postprocess_writers(void)
Define post-processing writers.
Definition: cs_user_postprocess.c:69
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
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
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.
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.
int cs_add_model_field_indexes(int f_id)
#define END_C_DECLS
Definition: cs_defs.h:511
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
void cs_meg_post_activate(void)
This function is used to activate postprocessing writers.
Definition: cs_meg_post_output.c:64
void cs_user_turbomachinery_set_rotation_velocity(void)
Define rotation velocity of rotor.
Definition: cs_user_turbomachinery.c:103
struct _cs_probe_set_t cs_probe_set_t
Definition: cs_probe.h:53
void cs_user_paramedmem_define_couplings(void)
Define ParaMEDMEM coupling(s)
Definition: cs_user_paramedmem_coupling.c:82
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
#define CS_PROCF(x, y)
Definition: cs_defs.h:524
void cs_user_mesh_boundary(cs_mesh_t *mesh)
Insert boundaries into a mesh.
Definition: cs_user_mesh.c:136
void cs_user_syrthes_coupling(void)
Define couplings with SYRTHES code.
Definition: cs_user_coupling.c:95
Definition: cs_field_pointer.h:92
void cs_user_turbomachinery_rotor(void)
Define rotor axes, associated cells, and rotor/stator faces.
Definition: cs_user_turbomachinery.c:90
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_real_t * cs_get_cavitation_dgdp_st(void)
Return pointer to cavitation "dgdpca" array.
Definition: pointe.f90:727
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.
void cs_user_parallel_io(void)
Define parallel IO settings.
Definition: cs_user_performance_tuning.c:100
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:92
void cs_user_saturne_coupling(void)
Define couplings with other instances of Code_Saturne.
Definition: cs_user_coupling.c:79
void cs_user_mesh_smoothe(cs_mesh_t *mesh)
Mesh smoothing.
Definition: cs_user_mesh.c:166
void cs_user_1d_wall_thermal(int iappel, int isuit1)
Definition: cs_user_1d_wall_thermal.c:88
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
Definition: mesh.f90:26
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
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
void cs_user_initialization(cs_domain_t *domain)
This function is called one time step to initialize problem.
Definition: cs_user_initialization.c:88
Definition: cs_field_pointer.h:184
Definition: cs_zone.h:55
void cs_user_zones(void)
Define volume and surface zones.
Definition: cs_user_zones.c:65