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-2019 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 /*----------------------------------------------------------------------------*/
416 /*----------------------------------------------------------------------------*/
417 
418 void
419 cs_user_source_terms(cs_domain_t *domain,
420  int f_id,
421  cs_real_t *st_exp,
422  cs_real_t *st_imp);
423 
424 /*----------------------------------------------------------------------------*/
432 /*----------------------------------------------------------------------------*/
433 
434 void
435 cs_user_porosity(void);
436 
437 /*----------------------------------------------------------------------------
438  * Define mesh joinings.
439  *----------------------------------------------------------------------------*/
440 
441 void
442 cs_user_join(void);
443 
444 /*----------------------------------------------------------------------------
445  * Define linear solver options.
446  *
447  * This function is called at the setup stage, once user and most model-based
448  * fields are defined.
449  *----------------------------------------------------------------------------*/
450 
451 void
452 cs_user_linear_solvers(void);
453 
454 /*----------------------------------------------------------------------------*/
460 /*----------------------------------------------------------------------------*/
461 
462 void
463 cs_user_finalize_setup(cs_domain_t *domain);
464 
465 /*----------------------------------------------------------------------------
466  * Tag bad cells within the mesh based on geometric criteria.
467  *----------------------------------------------------------------------------*/
468 
469 void
470 cs_user_mesh_bad_cells_tag(cs_mesh_t *mesh,
471  cs_mesh_quantities_t *mesh_quantities);
472 
473 /*----------------------------------------------------------------------------
474  * Define mesh files to read and optional associated transformations.
475  *----------------------------------------------------------------------------*/
476 
477 void
478 cs_user_mesh_input(void);
479 
480 /*----------------------------------------------------------------------------
481  * Modifiy geometry and mesh.
482  *----------------------------------------------------------------------------*/
483 
484 void
485 cs_user_mesh_modify(cs_mesh_t *mesh);
486 
487 /*----------------------------------------------------------------------------
488  * Insert boundary wall into a mesh.
489  *----------------------------------------------------------------------------*/
490 
491 void
492 cs_user_mesh_boundary(cs_mesh_t *mesh);
493 
494 /*----------------------------------------------------------------------------
495  * Mesh smoothing.
496  *
497  * parameters:
498  * mesh <-> pointer to mesh structure to smoothe
499  *----------------------------------------------------------------------------*/
500 
501 void
502 cs_user_mesh_smoothe(cs_mesh_t *mesh);
503 
504 /*----------------------------------------------------------------------------
505  * Enable or disable mesh saving.
506  *
507  * By default, mesh is saved when modified.
508  *
509  * parameters:
510  * mesh <-> pointer to mesh structure
511  *----------------------------------------------------------------------------*/
512 
513 void
514 cs_user_mesh_save(cs_mesh_t *mesh);
515 
516 /*----------------------------------------------------------------------------
517  * Set options for cutting of warped faces
518  *
519  * parameters:
520  * mesh <-> pointer to mesh structure to smoothe
521  *----------------------------------------------------------------------------*/
522 
523 void
524 cs_user_mesh_warping(void);
525 
526 /*----------------------------------------------------------------------------
527  * Select physical model options, including user fields.
528  *
529  * This function is called at the earliest stages of the data setup.
530  *----------------------------------------------------------------------------*/
531 
532 void
533 cs_user_model(void);
534 
535 /*----------------------------------------------------------------------------
536  * Define advanced mesh numbering options.
537  *----------------------------------------------------------------------------*/
538 
539 void
540 cs_user_numbering(void);
541 
542 /*----------------------------------------------------------------------------
543  * Define parallel IO settings.
544  *----------------------------------------------------------------------------*/
545 
546 void
547 cs_user_parallel_io(void);
548 
549 /*----------------------------------------------------------------------------
550  * Define advanced partitioning options.
551  *----------------------------------------------------------------------------*/
552 
553 void
554 cs_user_partition(void);
555 
556 /*----------------------------------------------------------------------------
557  * Define sparse matrix tuning options.
558  *----------------------------------------------------------------------------*/
559 
560 void
561 cs_user_matrix_tuning(void);
562 
563 /*----------------------------------------------------------------------------
564  * Define or modify general numerical and physical user parameters.
565  *
566  * At the calling point of this function, most model-related most variables
567  * and other fields have been defined, so specific settings related to those
568  * fields may be set here.
569  *----------------------------------------------------------------------------*/
570 
571 void
572 cs_user_parameters(cs_domain_t *domain);
573 
574 /*----------------------------------------------------------------------------
575  * User function for input of radiative transfer module options.
576  *----------------------------------------------------------------------------*/
577 
578 void
579 cs_user_radiative_transfer_parameters(void);
580 
581 /*-----------------------------------------------------------------------------
582  * User subroutine for input of radiative transfer boundary conditions
583  *----------------------------------------------------------------------------*/
584 
585 void
586 cs_user_radiative_transfer_bcs(int nvar,
587  const int bc_type[],
588  int icodcl[],
589  int isothp[],
590  cs_real_t *tmin,
591  cs_real_t *tmax,
592  cs_real_t *tx,
593  const cs_real_t dt[],
594  cs_real_t rcodcl[],
595  const cs_real_t thwall[],
596  const cs_real_t qincid[],
597  cs_real_t hfcnvp[],
598  cs_real_t flcnvp[],
599  cs_real_t xlamp[],
600  cs_real_t epap[],
601  cs_real_t epsp[],
602  cs_real_t textp[],
603  cs_real_t tintp[]);
604 
605 /*----------------------------------------------------------------------------
606  * Define periodic faces.
607  *----------------------------------------------------------------------------*/
608 
609 void
610 cs_user_periodicity(void);
611 
612 /*----------------------------------------------------------------------------
613  * Define post-processing writers.
614  *
615  * The default output format and frequency may be configured, and additional
616  * post-processing writers allowing outputs in different formats or with
617  * different format options and output frequency than the main writer may
618  * be defined.
619  *----------------------------------------------------------------------------*/
620 
621 void
622 cs_user_postprocess_writers(void);
623 
624 /*-----------------------------------------------------------------------------
625  * Define monitoring probes and profiles. A profile is seen as a set of probes.
626  *----------------------------------------------------------------------------*/
627 
628 void
629 cs_user_postprocess_probes(void);
630 
631 /*----------------------------------------------------------------------------
632  * Define post-processing meshes.
633  *
634  * The main post-processing meshes may be configured, and additional
635  * post-processing meshes may be defined as a subset of the main mesh's
636  * cells or faces (both interior and boundary).
637  *----------------------------------------------------------------------------*/
638 
639 void
640 cs_user_postprocess_meshes(void);
641 
642 /*----------------------------------------------------------------------------
643  * User function for output of values on a post-processing mesh.
644  *----------------------------------------------------------------------------*/
645 
646 void
647 cs_user_postprocess_values(const char *mesh_name,
648  int mesh_id,
649  int cat_id,
650  cs_probe_set_t *probes,
651  cs_lnum_t n_cells,
652  cs_lnum_t n_i_faces,
653  cs_lnum_t n_b_faces,
654  cs_lnum_t n_vertices,
655  const cs_lnum_t cell_list[],
656  const cs_lnum_t i_face_list[],
657  const cs_lnum_t b_face_list[],
658  const cs_lnum_t vertex_list[],
659  const cs_time_step_t *ts);
660 
661 /*----------------------------------------------------------------------------
662  * Override default frequency or calculation end based output.
663  *
664  * This allows fine-grained control of activation or deactivation,
665  *
666  * parameters:
667  * nt_max_abs <-- maximum time step number
668  * nt_cur_abs <-- current time step number
669  * t_cur_abs <-- absolute time at the current time step
670  *----------------------------------------------------------------------------*/
671 
672 void
673 cs_user_postprocess_activate(int nt_max_abs,
674  int nt_cur_abs,
675  double t_cur_abs);
676 
677 /*----------------------------------------------------------------------------
678  * Define couplings with other instances of Code_Saturne.
679  *----------------------------------------------------------------------------*/
680 
681 void
682 cs_user_saturne_coupling(void);
683 
684 /*----------------------------------------------------------------------------
685  * Set user solver.
686  *----------------------------------------------------------------------------*/
687 
688 int
689 cs_user_solver_set(void);
690 
691 /*----------------------------------------------------------------------------
692  * Main call to user solver.
693  *----------------------------------------------------------------------------*/
694 
695 void
696 cs_user_solver(const cs_mesh_t *mesh,
697  const cs_mesh_quantities_t *mesh_quantities);
698 
699 /*----------------------------------------------------------------------------
700  * Define couplings with SYRTHES code.
701  *----------------------------------------------------------------------------*/
702 
703 void
704 cs_user_syrthes_coupling(void);
705 
706 /*----------------------------------------------------------------------------
707  * Define time moments.
708  *----------------------------------------------------------------------------*/
709 
710 void
711 cs_user_time_moments(void);
712 
713 /*----------------------------------------------------------------------------
714  * Define rotor/stator model.
715  *----------------------------------------------------------------------------*/
716 
717 void
718 cs_user_turbomachinery(void);
719 
720 /*----------------------------------------------------------------------------
721  * Define rotor axes, associated cells, and rotor/stator faces.
722  *----------------------------------------------------------------------------*/
723 
724 void
725 cs_user_turbomachinery_rotor(void);
726 
727 /*----------------------------------------------------------------------------
728  * Define rotation velocity of rotor.
729  *----------------------------------------------------------------------------*/
730 
731 void
732 cs_user_turbomachinery_set_rotation_velocity(void);
733 
734 /*----------------------------------------------------------------------------*/
738 /*----------------------------------------------------------------------------*/
739 
740 void
741 cs_user_zones(void);
742 
743 /*----------------------------------------------------------------------------*/
747 /*----------------------------------------------------------------------------*/
748 
749 void
750 cs_user_scaling_elec(const cs_mesh_t *mesh,
751  const cs_mesh_quantities_t *mesh_quantities,
752  cs_real_t *dt);
753 
754 /*----------------------------------------------------------------------------
755  * Computation of the relaxation time-scale to equilibrium in the frame of
756  * the homogeneous two-phase model.
757  *----------------------------------------------------------------------------*/
758 
759 void
760 cs_user_hgn_thermo_relax_time(const cs_mesh_t *mesh,
761  const cs_real_t *alpha_eq,
762  const cs_real_t *y_eq,
763  const cs_real_t *z_eq,
764  const cs_real_t *ei,
765  const cs_real_t *v,
766  cs_real_t *relax_tau);
767 
768 /*============================================================================
769  * CDO User function prototypes
770  *============================================================================*/
771 
772 /*----------------------------------------------------------------------------*/
780 /*----------------------------------------------------------------------------*/
781 
782 void
783 cs_user_gwf_setup(cs_domain_t *domain);
784 
785 /*----------------------------------------------------------------------------*/
786 
787 /*============================================================================
788  * MEG function prototypes
789  *============================================================================*/
790 
791 /*----------------------------------------------------------------------------*/
804 /*----------------------------------------------------------------------------*/
805 
806 cs_real_t *
807 cs_meg_boundary_function(const cs_zone_t *zone,
808  const char *field_name,
809  const char *condition);
810 
811 /*----------------------------------------------------------------------------*/
819 /*----------------------------------------------------------------------------*/
820 
821 void
822 cs_meg_volume_function(const cs_zone_t *zone,
823  cs_field_t *f[]);
824 
825 /*----------------------------------------------------------------------------*/
834 /*----------------------------------------------------------------------------*/
835 
836 cs_real_t *
837 cs_meg_initialization(const cs_zone_t *zone,
838  const char *field_name);
839 
840 /*----------------------------------------------------------------------------*/
853 /*----------------------------------------------------------------------------*/
854 
855 cs_real_t *
856 cs_meg_source_terms(const cs_zone_t *zone,
857  const char *name,
858  const char *source_type);
859 
860 /*----------------------------------------------------------------------------*/
861 
862 END_C_DECLS
863 
864 #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)
Function called at each time step to define physical properties.
Definition: cs_user_source_terms.c:186
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:107
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 (iporos greater than 1 in c...
Definition: cs_user_porosity.c:109
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 Wed Dec 25 2019 16:44:10 for My Project by   doxygen 1.8.16