My Project
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 
44 BEGIN_C_DECLS
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
204 cs_user_rad_transfer_net_flux(const int itypfb[],
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
253 cs_add_model_field_indexes(int f_id);
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
296 cs_user_boundary_conditions(int nvar,
297  int icodcl[],
298  int bc_type[],
299  cs_real_t rcodcl[]);
300 
301 /*----------------------------------------------------------------------------*/
313 /*----------------------------------------------------------------------------*/
314 
315 void
316 cs_user_extra_operations_initialize(cs_domain_t *domain);
317 
318 /*----------------------------------------------------------------------------*/
327 /*----------------------------------------------------------------------------*/
328 
329 void
330 cs_user_extra_operations(cs_domain_t *domain);
331 
332 /*----------------------------------------------------------------------------*/
341 /*----------------------------------------------------------------------------*/
342 
343 void
344 cs_user_extra_operations_finalize(cs_domain_t *domain);
345 
346 /*----------------------------------------------------------------------------*/
352 /*----------------------------------------------------------------------------*/
353 
354 void
355 cs_user_initialization(cs_domain_t *domain);
356 
357 /*----------------------------------------------------------------------------*/
363 /*----------------------------------------------------------------------------*/
364 
365 void
366 cs_user_internal_coupling(void);
367 
368 /*----------------------------------------------------------------------------*/
377 /*----------------------------------------------------------------------------*/
378 
379 void
380 cs_user_internal_coupling_add_volumes(cs_mesh_t *mesh);
381 
382 /*----------------------------------------------------------------------------*/
391 /*----------------------------------------------------------------------------*/
392 
393 void
394 cs_user_internal_coupling_from_disjoint_meshes(cs_mesh_t *mesh);
395 
396 /*----------------------------------------------------------------------------*/
402 /*----------------------------------------------------------------------------*/
403 
404 void
405 cs_user_physical_properties(cs_domain_t *domain);
406 
407 /*----------------------------------------------------------------------------*/
417 /*----------------------------------------------------------------------------*/
418 
419 void
420 cs_user_source_terms(cs_domain_t *domain,
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
453 cs_user_linear_solvers(void);
454 
455 /*----------------------------------------------------------------------------*/
461 /*----------------------------------------------------------------------------*/
462 
463 void
464 cs_user_finalize_setup(cs_domain_t *domain);
465 
466 /*----------------------------------------------------------------------------
467  * Tag bad cells within the mesh based on geometric criteria.
468  *----------------------------------------------------------------------------*/
469 
470 void
471 cs_user_mesh_bad_cells_tag(cs_mesh_t *mesh,
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
486 cs_user_mesh_modify(cs_mesh_t *mesh);
487 
488 /*----------------------------------------------------------------------------
489  * Insert boundary wall into a mesh.
490  *----------------------------------------------------------------------------*/
491 
492 void
493 cs_user_mesh_boundary(cs_mesh_t *mesh);
494 
495 /*----------------------------------------------------------------------------
496  * Mesh smoothing.
497  *
498  * parameters:
499  * mesh <-> pointer to mesh structure to smoothe
500  *----------------------------------------------------------------------------*/
501 
502 void
503 cs_user_mesh_smoothe(cs_mesh_t *mesh);
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
515 cs_user_mesh_save(cs_mesh_t *mesh);
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
525 cs_user_mesh_warping(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
562 cs_user_matrix_tuning(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
573 cs_user_parameters(cs_domain_t *domain);
574 
575 /*----------------------------------------------------------------------------
576  * User function for input of radiative transfer module options.
577  *----------------------------------------------------------------------------*/
578 
579 void
580 cs_user_radiative_transfer_parameters(void);
581 
582 /*-----------------------------------------------------------------------------
583  * User subroutine for input of radiative transfer boundary conditions
584  *----------------------------------------------------------------------------*/
585 
586 void
587 cs_user_radiative_transfer_bcs(int nvar,
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
623 cs_user_postprocess_writers(void);
624 
625 /*-----------------------------------------------------------------------------
626  * Define monitoring probes and profiles. A profile is seen as a set of probes.
627  *----------------------------------------------------------------------------*/
628 
629 void
630 cs_user_postprocess_probes(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
641 cs_user_postprocess_meshes(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
683 cs_user_saturne_coupling(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
697 cs_user_solver(const cs_mesh_t *mesh,
698  const cs_mesh_quantities_t *mesh_quantities);
699 
700 /*----------------------------------------------------------------------------
701  * Define couplings with SYRTHES code.
702  *----------------------------------------------------------------------------*/
703 
704 void
705 cs_user_syrthes_coupling(void);
706 
707 /*----------------------------------------------------------------------------
708  * Define time moments.
709  *----------------------------------------------------------------------------*/
710 
711 void
712 cs_user_time_moments(void);
713 
714 /*----------------------------------------------------------------------------
715  * Define rotor/stator model.
716  *----------------------------------------------------------------------------*/
717 
718 void
719 cs_user_turbomachinery(void);
720 
721 /*----------------------------------------------------------------------------
722  * Define rotor axes, associated cells, and rotor/stator faces.
723  *----------------------------------------------------------------------------*/
724 
725 void
726 cs_user_turbomachinery_rotor(void);
727 
728 /*----------------------------------------------------------------------------
729  * Define rotation velocity of rotor.
730  *----------------------------------------------------------------------------*/
731 
732 void
733 cs_user_turbomachinery_set_rotation_velocity(void);
734 
735 /*----------------------------------------------------------------------------*/
739 /*----------------------------------------------------------------------------*/
740 
741 void
742 cs_user_zones(void);
743 
744 /*----------------------------------------------------------------------------*/
748 /*----------------------------------------------------------------------------*/
749 
750 void
751 cs_user_scaling_elec(const cs_mesh_t *mesh,
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
761 cs_user_hgn_thermo_relax_time(const cs_mesh_t *mesh,
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
784 cs_user_gwf_setup(cs_domain_t *domain);
785 
786 /*----------------------------------------------------------------------------*/
787 
788 /*============================================================================
789  * MEG function prototypes
790  *============================================================================*/
791 
792 /*----------------------------------------------------------------------------*/
805 /*----------------------------------------------------------------------------*/
806 
807 cs_real_t *
808 cs_meg_boundary_function(const cs_zone_t *zone,
809  const char *field_name,
810  const char *condition);
811 
812 /*----------------------------------------------------------------------------*/
820 /*----------------------------------------------------------------------------*/
821 
822 void
823 cs_meg_volume_function(const cs_zone_t *zone,
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 
863 END_C_DECLS
864 
865 #endif /* __CS_PROTOTYPES_H__ */
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:182
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:3027
cs_user_numbering
void cs_user_numbering(void)
Define advanced mesh numbering options.
Definition: cs_user_performance_tuning.c:90
f_id
void const int * f_id
Definition: cs_gui.h:292
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:70
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:105
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:115
xlam
Definition: cs_field_pointer.h:189
cs_domain_t
Structure storing the main features of the computational domain and pointers to the main geometrical ...
Definition: cs_domain.h:87
trafbr
void const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t cs_real_t cs_real_t trafbr[]
Definition: cs_prototypes.h:104
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:93
xesp
void cs_real_t cs_real_t * xesp
Definition: cs_prototypes.h:70
cs_domain.h
cs_zone_t
Definition: cs_zone.h:55
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:80
itypfb
void const int const int const int const int int int int int int int int int int int int int * itypfb
Definition: cs_gui_boundary_conditions.h:64
cs_user_turbomachinery_rotor
void cs_user_turbomachinery_rotor(void)
Define rotor axes, associated cells, and rotor/stator faces.
Definition: cs_user_turbomachinery.c:101
cs_user_turbomachinery_set_rotation_velocity
void cs_user_turbomachinery_set_rotation_velocity(void)
Define rotation velocity of rotor.
Definition: cs_user_turbomachinery.c:113
h_b
void const cs_lnum_t const cs_real_t cs_real_t * h_b
Definition: cs_prototypes.h:225
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:167
t
void cs_real_t * t
Definition: cs_prototypes.h:239
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[], cs_real_t tintp[])
User definition of radiative transfer boundary conditions.
Definition: cs_user_radiative_transfer_bcs.c:190
cs_user_mesh_save
void cs_user_mesh_save(cs_mesh_t *mesh)
Enable or disable mesh saving.
Definition: cs_user_mesh.c:181
cs_user_model
void cs_user_model(void)
Select physical model options, including user fields.
Definition: cs_user_parameters.c:128
cs_user_postprocess_probes
void cs_user_postprocess_probes(void)
Define monitoring probes and profiles.
Definition: cs_user_postprocess.c:123
cs_user_saturne_coupling
void cs_user_saturne_coupling(void)
Define couplings with other instances of Code_Saturne.
Definition: cs_user_coupling.c:117
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:468
cs_mesh_bad_cells.h
cs_user_mesh_input
void cs_user_mesh_input(void)
Define mesh files to read and optional associated transformations.
Definition: cs_user_mesh.c:87
cs_user_mesh_boundary
void cs_user_mesh_boundary(cs_mesh_t *mesh)
Insert boundaries into a mesh.
Definition: cs_user_mesh.c:137
haltyp
subroutine haltyp(ivoset)
Definition: haltyp.f90:27
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:3046
cs_user_join
void cs_user_join(void)
Define mesh joinings.
Definition: cs_user_mesh.c:99
atimbr::v
double precision, dimension(:,:,:), allocatable v
Definition: atimbr.f90:114
numtyp
void const cs_int_t * numtyp
Definition: cs_prototypes.h:104
cs_user_turbomachinery
void cs_user_turbomachinery(void)
Define rotor/stator model.
Definition: cs_user_turbomachinery.c:89
cs_add_model_field_indexes
int cs_add_model_field_indexes(int f_id)
icodcl
void const int const int const int const int int int int int int int int int int int int int int int * icodcl
Definition: cs_gui_boundary_conditions.h:64
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:302
nfbrps
void const cs_int_t const cs_int_t const cs_int_t const cs_int_t * nfbrps
Definition: cs_prototypes.h:104
cofbfp
void const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_real_t *const const cs_real_t *const const cs_real_t *const cs_real_3_t cs_real_t const cs_real_t const cs_real_t const cs_real_t const cs_real_t cofbfp[]
Definition: cs_convection_diffusion.h:5386
lstfbr
void const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t lstfbr[]
Definition: cs_prototypes.h:104
eh
void cs_real_t * eh
Definition: cs_prototypes.h:70
cs_user_internal_coupling
void cs_user_internal_coupling(void)
Define internal coupling options.
Definition: cs_user_parameters.c:219
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:467
cs_user_solver_set
int cs_user_solver_set(void)
Set user solver.
Definition: cs_user_solver.c:89
b_t_to_h
subroutine b_t_to_h(nlst, lstfac, t_b, h_b)
Definition: b_t_to_h.f90:51
cs_user_postprocess_meshes
void cs_user_postprocess_meshes(void)
Define post-processing meshes.
Definition: cs_user_postprocess.c:109
findpt
subroutine findpt(ncelet, ncel, xyzcen, xx, yy, zz, node, ndrang)
Definition: findpt.f90:57
nvar
void const cs_int_t const cs_int_t * nvar
Definition: cs_prototypes.h:104
cs_mesh_quantities.h
cs_user_mesh_smoothe
void cs_user_mesh_smoothe(cs_mesh_t *mesh)
Mesh smoothing.
Definition: cs_user_mesh.c:165
epa
Definition: cs_field_pointer.h:190
cs_mesh_quantities_t
Definition: cs_mesh_quantities.h:90
f1mc
void cs_real_t cs_real_t cs_real_t * f1mc
Definition: cs_prototypes.h:70
cs_user_partition
void cs_user_partition(void)
Define advanced partitioning options.
Definition: cs_user_performance_tuning.c:102
cs_lagr_status
void cs_lagr_status(int *model_flag, int *restart_flag, int *frozen_flag)
distpa
void cs_real_t * distpa
Definition: cs_prototypes.h:95
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:101
f2mc
void cs_real_t cs_real_t cs_real_t cs_real_t * f2mc
Definition: cs_prototypes.h:70
mesh
Definition: mesh.f90:26
cs_user_mesh_warping
void cs_user_mesh_warping(void)
Set options for cutting of warped faces.
Definition: cs_user_mesh.c:123
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:116
cs_user_time_moments
void cs_user_time_moments(void)
Define time moments.
Definition: cs_user_parameters.c:205
cs_mesh.h
ndrang
void const cs_int_t const cs_real_t const cs_real_t const cs_real_t const cs_real_t cs_int_t cs_int_t * ndrang
Definition: cs_prototypes.h:122
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:90
cs_user_extra_operations_initialize
void cs_user_extra_operations_initialize(cs_domain_t *domain)
Initialize variables.
Definition: cs_user_extra_operations.c:96
coefap
void const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_real_t *const const cs_real_t *const const cs_real_t *const cs_real_3_t cs_real_t const cs_real_t coefap[]
Definition: cs_convection_diffusion.h:5386
optcal::isuit1
integer, save isuit1
Definition: optcal.f90:328
eps
Definition: cs_field_pointer.h:71
temper
void cs_real_t cs_real_t * temper
Definition: cs_prototypes.h:170
cs_volume_zone.h
nrgpar
void const cs_int_t * nrgpar
Definition: cs_prototypes.h:85
ncel
void const cs_int_t * ncel
Definition: cs_prototypes.h:122
dvvpst
subroutine dvvpst(nummai, numtyp, nvar, ncelps, nfbrps, lstcel, lstfbr, tracel, trafbr)
Definition: dvvpst.f90:54
cpthp1
subroutine cpthp1(mode, eh, xesp, f1mc, f2mc, tp)
Definition: cpthp1.f90:28
cs_user_mesh_modify
void cs_user_mesh_modify(cs_mesh_t *mesh)
Modify geometry and mesh.
Definition: cs_user_mesh.c:151
enthal
void cs_real_t * enthal
Definition: cs_prototypes.h:170
cs_user_1d_wall_thermal
void cs_user_1d_wall_thermal(int iappel, int isuit1)
Definition: cs_user_1d_wall_thermal.c:117
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:112
mode
void const cs_int_t * mode
Definition: cs_syr_coupling.h:132
mesh::ncelet
integer, save ncelet
Definition: mesh.f90:46
cs_time_step_t
time step descriptor
Definition: cs_time_step.h:51
cs_user_rad_transfer_absorption
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
cs_user_rad_transfer_net_flux
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
ts
void cs_int_t cs_int_t cs_int_t cs_real_t * ts
Definition: cs_at_plugin.h:63
initi1
subroutine initi1
Definition: initi1.f90:29
cs_user_periodicity
void cs_user_periodicity(void)
Define periodic faces.
Definition: cs_user_mesh.c:111
coefbp
void const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_real_t *const const cs_real_t *const const cs_real_t *const cs_real_3_t cs_real_t const cs_real_t const cs_real_t coefbp[]
Definition: cs_convection_diffusion.h:5386
zz
void const cs_int_t const cs_real_t const cs_real_t const cs_real_t const cs_real_t * zz
Definition: cs_prototypes.h:122
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:130
cs_user_syrthes_coupling
void cs_user_syrthes_coupling(void)
Define couplings with SYRTHES code.
Definition: cs_user_coupling.c:102
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:298
cs_probe_set_t
struct _cs_probe_set_t cs_probe_set_t
Definition: cs_probe.h:53
usthht
subroutine usthht(mode, enthal, temper)
Definition: usthht.f90:39
node
void const cs_int_t const cs_real_t const cs_real_t const cs_real_t const cs_real_t cs_int_t * node
Definition: cs_prototypes.h:122
cs_probe.h
csinit
subroutine csinit(irgpar, nrgpar)
Definition: csinit.f90:25
tp
void cs_real_t cs_real_t cs_real_t cs_real_t cs_real_t * tp
Definition: cs_prototypes.h:70
cs_user_matrix_tuning
void cs_user_matrix_tuning(void)
Define sparse matrix tuning options.
Definition: cs_user_performance_tuning.c:126
cs_user_porosity
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
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:113
xyzcen
void const cs_int_t const cs_real_t * xyzcen
Definition: cs_prototypes.h:122
cs_user_postprocess_writers
void cs_user_postprocess_writers(void)
Define post-processing writers.
Definition: cs_user_postprocess.c:93
cofafp
void const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_int_t *const const cs_real_t *const const cs_real_t *const const cs_real_t *const cs_real_3_t cs_real_t const cs_real_t const cs_real_t const cs_real_t cofafp[]
Definition: cs_convection_diffusion.h:5386
cs_user_parallel_io
void cs_user_parallel_io(void)
Define parallel IO settings.
Definition: cs_user_performance_tuning.c:114
caltri
subroutine caltri
Definition: caltri.f90:36
cs_int_t
int cs_int_t
Fortran-compatible integer.
Definition: cs_defs.h:301
cs_user_coupling
void cs_user_coupling(void)
Define global options for couplings.
Definition: cs_user_coupling.c:87
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:150
c_h_to_t
subroutine c_h_to_t(h, t)
Definition: c_h_to_t.f90:46
lstcel
void const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t lstcel[]
Definition: cs_prototypes.h:104
yy
void const cs_int_t const cs_real_t const cs_real_t const cs_real_t * yy
Definition: cs_prototypes.h:122
dt
Definition: cs_field_pointer.h:65
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:185
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:67
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:70
tracel
void const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t const cs_int_t cs_real_t tracel[]
Definition: cs_prototypes.h:104
ncelps
void const cs_int_t const cs_int_t const cs_int_t * ncelps
Definition: cs_prototypes.h:104
distpr
subroutine distpr(itypfb)
Definition: distpr.f90:47
cs_user_zones
void cs_user_zones(void)
Define volume and surface zones.
Definition: cs_user_zones.c:82
cs_user_linear_solvers
void cs_user_linear_solvers(void)
Define linear solver options.
Definition: cs_user_parameters.c:189
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:155
h
Definition: cs_field_pointer.h:97
xx
void const cs_int_t const cs_real_t const cs_real_t * xx
Definition: cs_prototypes.h:122
cs_field_t
Field descriptor.
Definition: cs_field.h:124
t_b
void const cs_lnum_t const cs_real_t * t_b
Definition: cs_prototypes.h:225
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:196
lstfac
void const cs_lnum_t * lstfac
Definition: cs_prototypes.h:225
cs_mesh_t
Definition: cs_mesh.h:63
cs_base.h
set_cdo_mode
subroutine set_cdo_mode(icdoval)
Definition: cdomod.f90:88
rcodcl
void const int const int const int const int int int int int int int int int int int int int int int double double double double double double double double double double int double * rcodcl
Definition: cs_gui_boundary_conditions.h:64
CS_PROCF
void CS_PROCF(caltri, CALTRI)(void)
cs_user_gwf_setup
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....
Definition: cs_user_gwf.c:96
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:71
Generated on Thu Apr 9 2020 17:26:56 for My Project by   doxygen 1.8.16