7.2
general documentation
cs_property.h
Go to the documentation of this file.
1 #ifndef __CS_PROPERTY_H__
2 #define __CS_PROPERTY_H__
3 
4 /*============================================================================
5  * Manage the definition/setting of properties
6  *============================================================================*/
7 
8 /*
9  This file is part of code_saturne, a general-purpose CFD tool.
10 
11  Copyright (C) 1998-2022 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_field.h"
35 #include "cs_flag.h"
36 #include "cs_param_types.h"
37 #include "cs_xdef.h"
38 #include "cs_xdef_cw_eval.h"
39 #include "cs_xdef_eval.h"
40 
41 /*----------------------------------------------------------------------------*/
42 
43 BEGIN_C_DECLS
44 
45 /*============================================================================
46  * Macro definitions
47  *============================================================================*/
48 
49 /* Common property names (property which is shared between different module) */
50 
51 #define CS_PROPERTY_MASS_DENSITY "mass_density"
52 
61 #define CS_PROPERTY_POST_FOURIER (1 << 0)
62 
75 #define CS_PROPERTY_ISO (1 << 0)
76 
81 #define CS_PROPERTY_ORTHO (1 << 1)
82 
88 #define CS_PROPERTY_ANISO (1 << 2)
89 
94 #define CS_PROPERTY_ANISO_SYM (1 << 3)
95 
100 #define CS_PROPERTY_BY_PRODUCT (1 << 4)
101 
109 #define CS_PROPERTY_SUBCELL_DEFINITION (1 << 5)
110 
113 /*============================================================================
114  * Type definitions
115  *============================================================================*/
116 
117 typedef cs_flag_t cs_property_type_t;
118 
126 typedef enum {
127 
128  CS_PTYKEY_POST_FOURIER,
129  CS_PTYKEY_N_KEYS
130 
131 } cs_property_key_t;
132 
133 /* ======================================== */
134 /* Set of parameters attached to a property */
135 /* ======================================== */
136 
143 typedef struct _cs_property_t cs_property_t;
144 
145 struct _cs_property_t {
146 
147  char *restrict name;
148  int id;
149  cs_flag_t state_flag;
150  cs_flag_t process_flag;
151  cs_property_type_t type;
152 
153  /* Reference value wich is used as default when nothing else is set. This
154  * value can also be used to renormalized quantities related to this property
155  * By default, this is set to 1
156  */
157 
158  cs_real_t ref_value;
159 
160  /* Property is up to now only defined on the whole domain (volume) */
161 
162  int n_definitions; /* Current number of definitions used */
163  cs_xdef_t **defs; /* List of definitions */
164 
165  /* Store the definition id for each cell, NULL if there is only one
166  definition set */
167 
168  short int *def_ids;
169 
170  /* Function pointers to handle generic tasks related to a property. There
171  is one function related to each definition. Some functions may not be
172  allocated according to the kind of property */
173 
174  /* Retrieve the evaluation of the property at the cell center for each
175  definition */
176 
177  cs_xdef_eval_t **get_eval_at_cell;
178 
179  /* Same thing as the previous one but now with the usage of cellwise algo.
180  relying on a cs_cell_mesh_t structure */
181 
182  cs_xdef_cw_eval_t **get_eval_at_cell_cw;
183 
184  /* For properties relying on other properties for their definition, one
185  * stores the pointers to these related properties */
186 
187  int n_related_properties;
188  const cs_property_t **related_properties;
189 
190 };
191 
192 
199 typedef struct {
200 
201  const cs_property_t *property; /* shared pointer */
202 
203  bool is_iso; /* Detect if this an easier case */
204  bool is_unity; /* Detect if this a simple case */
205 
206  bool need_eigen;
207  cs_real_t eigen_max;
208  cs_real_t eigen_ratio;
209 
210  bool need_tensor;
211  cs_real_t tensor[3][3];
212  cs_real_t value;
213 
214 } cs_property_data_t;
215 
216 /*============================================================================
217  * Global variables
218  *============================================================================*/
219 
220 /*============================================================================
221  * Static inline public function prototypes
222  *============================================================================*/
223 
224 /*----------------------------------------------------------------------------*/
232 /*----------------------------------------------------------------------------*/
233 
234 static inline bool
235 cs_property_is_constant(const cs_property_t *pty)
236 {
237  if (pty == NULL)
238  return true; /* Treated as the "unity" property */
239 
240  if (pty->state_flag & CS_FLAG_STATE_STEADY) {
241  if (pty->state_flag & CS_FLAG_STATE_UNIFORM)
242  return true;
243  else
244  return false;
245  }
246  else
247  return false;
248 }
249 
250 /*----------------------------------------------------------------------------*/
258 /*----------------------------------------------------------------------------*/
259 
260 static inline bool
261 cs_property_is_steady(const cs_property_t *pty)
262 {
263  if (pty == NULL)
264  return true; /* Treated as the "unity" property */
265 
266  if (pty->state_flag & CS_FLAG_STATE_STEADY)
267  return true;
268  else
269  return false;
270 }
271 
272 /*----------------------------------------------------------------------------*/
280 /*----------------------------------------------------------------------------*/
281 
282 static inline bool
283 cs_property_is_uniform(const cs_property_t *pty)
284 {
285  if (pty == NULL)
286  return true; /* Treated as the "unity" property */
287 
288  if (pty->state_flag & CS_FLAG_STATE_UNIFORM)
289  return true;
290  else
291  return false;
292 }
293 
294 /*----------------------------------------------------------------------------*/
302 /*----------------------------------------------------------------------------*/
303 
304 static inline bool
305 cs_property_is_isotropic(const cs_property_t *pty)
306 {
307  if (pty == NULL)
308  return false;
309 
310  if (pty->type & CS_PROPERTY_ISO)
311  return true;
312  else
313  return false;
314 }
315 
316 /*----------------------------------------------------------------------------*/
325 /*----------------------------------------------------------------------------*/
326 
327 static inline bool
328 cs_property_is_subcell(const cs_property_t *pty)
329 {
330  if (pty == NULL)
331  return false;
332 
333  if (pty->type & CS_PROPERTY_SUBCELL_DEFINITION)
334  return true;
335  else
336  return false;
337 }
338 
339 /*----------------------------------------------------------------------------*/
347 /*----------------------------------------------------------------------------*/
348 
349 static inline const char *
350 cs_property_get_name(const cs_property_t *pty)
351 {
352  if (pty == NULL)
353  return NULL;
354 
355  return pty->name;
356 }
357 
358 /*----------------------------------------------------------------------------*/
366 /*----------------------------------------------------------------------------*/
367 
368 static inline cs_property_type_t
369 cs_property_get_type(const cs_property_t *pty)
370 {
371  if (pty == NULL)
372  return 0; /* means undefined */
373 
374  return pty->type;
375 }
376 
377 /*----------------------------------------------------------------------------*/
385 /*----------------------------------------------------------------------------*/
386 
387 static inline int
388 cs_property_get_dim(const cs_property_t *pty)
389 {
390  if (pty == NULL)
391  return 0; /* means undefined */
392 
393  if (pty->type & CS_PROPERTY_ISO)
394  return 1;
395  else if (pty->type & CS_PROPERTY_ORTHO)
396  return 3;
397  else if (pty->type & CS_PROPERTY_ANISO_SYM)
398  return 6;
399  else if (pty->type & CS_PROPERTY_ANISO)
400  return 9;
401  else
402  return 0; /* means undefined */
403 }
404 
405 /*============================================================================
406  * Public function prototypes
407  *============================================================================*/
408 
409 /*----------------------------------------------------------------------------*/
416 /*----------------------------------------------------------------------------*/
417 
418 void
419 cs_property_init_sharing(const cs_cdo_quantities_t *quant,
420  const cs_cdo_connect_t *connect);
421 
422 /*----------------------------------------------------------------------------*/
428 /*----------------------------------------------------------------------------*/
429 
430 int
431 cs_property_get_n_properties(void);
432 
433 /*----------------------------------------------------------------------------*/
442 /*----------------------------------------------------------------------------*/
443 
444 cs_property_t *
445 cs_property_add(const char *name,
446  cs_property_type_t type);
447 
448 /*----------------------------------------------------------------------------*/
460 /*----------------------------------------------------------------------------*/
461 
462 cs_property_t *
463 cs_property_subcell_add(const char *name,
464  cs_property_type_t type);
465 
466 /*----------------------------------------------------------------------------*/
480 /*----------------------------------------------------------------------------*/
481 
482 cs_property_t *
483 cs_property_add_as_product(const char *name,
484  const cs_property_t *pty_a,
485  const cs_property_t *pty_b);
486 
487 /*----------------------------------------------------------------------------*/
495 /*----------------------------------------------------------------------------*/
496 
497 cs_property_t *
498 cs_property_by_name(const char *name);
499 
500 /*----------------------------------------------------------------------------*/
508 /*----------------------------------------------------------------------------*/
509 
510 cs_property_t *
511 cs_property_by_id(int id);
512 
513 /*----------------------------------------------------------------------------*/
520 /*----------------------------------------------------------------------------*/
521 
522 void
523 cs_property_set_option(cs_property_t *pty,
524  cs_property_key_t key);
525 
526 /*----------------------------------------------------------------------------*/
534 /*----------------------------------------------------------------------------*/
535 
536 void
537 cs_property_set_reference_value(cs_property_t *pty,
538  double refval);
539 
540 /*----------------------------------------------------------------------------*/
545 /*----------------------------------------------------------------------------*/
546 
547 void
548 cs_property_destroy_all(void);
549 
550 /*----------------------------------------------------------------------------*/
555 /*----------------------------------------------------------------------------*/
556 
557 void
558 cs_property_finalize_setup(void);
559 
560 /*----------------------------------------------------------------------------*/
572 /*----------------------------------------------------------------------------*/
573 
574 cs_property_data_t
575 cs_property_data_define(bool need_tensor,
576  bool need_eigen,
577  const cs_property_t *property);
578 
579 /*----------------------------------------------------------------------------*/
589 /*----------------------------------------------------------------------------*/
590 
591 void
592 cs_property_data_init(bool need_tensor,
593  bool need_eigen,
594  const cs_property_t *property,
595  cs_property_data_t *data);
596 
597 /*----------------------------------------------------------------------------*/
609 /*----------------------------------------------------------------------------*/
610 
611 cs_xdef_t *
612 cs_property_def_constant_value(cs_property_t *pty,
613  double val);
614 
615 /*----------------------------------------------------------------------------*/
627 /*----------------------------------------------------------------------------*/
628 
629 cs_xdef_t *
630 cs_property_def_iso_by_value(cs_property_t *pty,
631  const char *zname,
632  double val);
633 
634 /*----------------------------------------------------------------------------*/
646 /*----------------------------------------------------------------------------*/
647 
648 cs_xdef_t *
649 cs_property_def_ortho_by_value(cs_property_t *pty,
650  const char *zname,
651  double val[]);
652 
653 /*----------------------------------------------------------------------------*/
665 /*----------------------------------------------------------------------------*/
666 
667 cs_xdef_t *
668 cs_property_def_aniso_by_value(cs_property_t *pty,
669  const char *zname,
670  cs_real_t tens[3][3]);
671 
672 /*----------------------------------------------------------------------------*/
684 /*----------------------------------------------------------------------------*/
685 
686 cs_xdef_t *
687 cs_property_def_aniso_sym_by_value(cs_property_t *pty,
688  const char *zname,
689  cs_real_t symtens[6]);
690 
691 /*----------------------------------------------------------------------------*/
704 /*----------------------------------------------------------------------------*/
705 
706 cs_xdef_t *
707 cs_property_def_by_time_func(cs_property_t *pty,
708  const char *zname,
709  cs_time_func_t *func,
710  void *input);
711 
712 /*----------------------------------------------------------------------------*/
725 /*----------------------------------------------------------------------------*/
726 
727 cs_xdef_t *
728 cs_property_def_by_analytic(cs_property_t *pty,
729  const char *zname,
730  cs_analytic_func_t *func,
731  void *input);
732 
733 /*----------------------------------------------------------------------------*/
748 /*----------------------------------------------------------------------------*/
749 
750 cs_xdef_t *
751 cs_property_def_by_func(cs_property_t *pty,
752  const char *zname,
753  void *context,
754  cs_xdef_eval_t *get_eval_at_cell,
755  cs_xdef_cw_eval_t *get_eval_at_cell_cw);
756 
757 /*----------------------------------------------------------------------------*/
771 /*----------------------------------------------------------------------------*/
772 
773 cs_xdef_t *
774 cs_property_def_by_array(cs_property_t *pty,
775  cs_flag_t loc,
776  cs_real_t *array,
777  bool is_owner,
778  const cs_lnum_t *index,
779  const cs_lnum_t *ids);
780 
781 /*----------------------------------------------------------------------------*/
788 /*----------------------------------------------------------------------------*/
789 
790 void
791 cs_property_def_by_field(cs_property_t *pty,
792  cs_field_t *field);
793 
794 /*----------------------------------------------------------------------------*/
806 /*----------------------------------------------------------------------------*/
807 
808 void
809 cs_property_iso_get_cell_values(cs_real_t t_eval,
810  const cs_property_t *pty,
811  int *pty_stride,
812  cs_real_t **p_pty_vals);
813 
814 /*----------------------------------------------------------------------------*/
823 /*----------------------------------------------------------------------------*/
824 
825 void
826 cs_property_eval_at_cells(cs_real_t t_eval,
827  const cs_property_t *pty,
828  cs_real_t *array);
829 
830 /*----------------------------------------------------------------------------*/
841 /*----------------------------------------------------------------------------*/
842 
843 void
844 cs_property_get_cell_tensor(cs_lnum_t c_id,
845  cs_real_t t_eval,
846  const cs_property_t *pty,
847  bool do_inversion,
848  cs_real_t tensor[3][3]);
849 
850 /*----------------------------------------------------------------------------*/
860 /*----------------------------------------------------------------------------*/
861 
862 cs_real_t
863 cs_property_get_cell_value(cs_lnum_t c_id,
864  cs_real_t t_eval,
865  const cs_property_t *pty);
866 
867 /*----------------------------------------------------------------------------*/
879 /*----------------------------------------------------------------------------*/
880 
881 void
882 cs_property_tensor_in_cell(const cs_cell_mesh_t *cm,
883  const cs_property_t *pty,
884  cs_real_t t_eval,
885  bool do_inversion,
886  cs_real_t tensor[3][3]);
887 
888 /*----------------------------------------------------------------------------*/
899 /*----------------------------------------------------------------------------*/
900 
901 cs_real_t
902 cs_property_value_in_cell(const cs_cell_mesh_t *cm,
903  const cs_property_t *pty,
904  cs_real_t t_eval);
905 
906 /*----------------------------------------------------------------------------*/
916 /*----------------------------------------------------------------------------*/
917 
918 void
919 cs_property_c2v_values(const cs_cell_mesh_t *cm,
920  const cs_property_t *pty,
921  cs_real_t t_eval,
922  cs_real_t *eval);
923 
924 /*----------------------------------------------------------------------------*/
933 /*----------------------------------------------------------------------------*/
934 
935 void
936 cs_property_get_fourier(const cs_property_t *pty,
937  cs_real_t t_eval,
938  double dt,
939  cs_real_t fourier[]);
940 
941 /*----------------------------------------------------------------------------*/
946 /*----------------------------------------------------------------------------*/
947 
948 void
949 cs_property_log_setup(void);
950 
951 /*----------------------------------------------------------------------------*/
952 
953 END_C_DECLS
954 
955 #endif /* __CS_PROPERTY_H__ */
_cs_property_t::id
int id
Definition: cs_property.h:148
cs_property_log_setup
void cs_property_log_setup(void)
Print a summary of the settings for all defined cs_property_t structures.
Definition: cs_property.c:2466
CS_PROPERTY_ORTHO
#define CS_PROPERTY_ORTHO
Definition: cs_property.h:81
restrict
#define restrict
Definition: cs_defs.h:142
cs_property_add
cs_property_t * cs_property_add(const char *name, cs_property_type_t type)
Create and initialize a new property structure.
Definition: cs_property.c:724
cs_property_by_name
cs_property_t * cs_property_by_name(const char *name)
Find the related property definition from its name.
Definition: cs_property.c:856
_cs_property_t::def_ids
short int * def_ids
Definition: cs_property.h:168
cs_property_data_t::eigen_ratio
cs_real_t eigen_ratio
Definition: cs_property.h:208
CS_FLAG_STATE_UNIFORM
#define CS_FLAG_STATE_UNIFORM
Definition: cs_flag.h:103
_cs_property_t::state_flag
cs_flag_t state_flag
Definition: cs_property.h:149
cs_property_subcell_add
cs_property_t * cs_property_subcell_add(const char *name, cs_property_type_t type)
Create and initialize a new property structure with an evaluation which can be called on a sub-partit...
Definition: cs_property.c:771
cs_property_get_dim
static int cs_property_get_dim(const cs_property_t *pty)
Retrieve the dimension of the property.
Definition: cs_property.h:388
cs_property_data_t::eigen_max
cs_real_t eigen_max
Definition: cs_property.h:207
cs_field_t
Field descriptor.
Definition: cs_field.h:125
cs_property_def_aniso_by_value
cs_xdef_t * cs_property_def_aniso_by_value(cs_property_t *pty, const char *zname, cs_real_t tens[3][3])
Define an anisotropic cs_property_t structure by value for entities related to a volume zone...
Definition: cs_property.c:1391
cs_property_data_t::is_iso
bool is_iso
Definition: cs_property.h:203
cs_property_data_t
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:199
_cs_property_t::name
char *restrict name
Definition: cs_property.h:147
cs_param_types.h
BEGIN_C_DECLS
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
_cs_property_t::process_flag
cs_flag_t process_flag
Definition: cs_property.h:150
cs_property_init_sharing
void cs_property_init_sharing(const cs_cdo_quantities_t *quant, const cs_cdo_connect_t *connect)
Set shared pointers to main domain members.
Definition: cs_property.c:691
_cs_property_t::ref_value
cs_real_t ref_value
Definition: cs_property.h:158
cs_cell_mesh_t
Set of local quantities and connectivities related to a mesh cell.
Definition: cs_cdo_local.h:203
cs_property_data_t::value
cs_real_t value
Definition: cs_property.h:212
_cs_property_t::get_eval_at_cell_cw
cs_xdef_cw_eval_t ** get_eval_at_cell_cw
Definition: cs_property.h:182
cs_property_destroy_all
void cs_property_destroy_all(void)
Free all cs_property_t structures and the array storing all the structures.
Definition: cs_property.c:951
cs_cdo_connect_t
Definition: cs_cdo_connect.h:61
cs_property_def_ortho_by_value
cs_xdef_t * cs_property_def_ortho_by_value(cs_property_t *pty, const char *zname, double val[])
Define an orthotropic cs_property_t structure by value for entities related to a volume zone...
Definition: cs_property.c:1340
cs_property_get_type
static cs_property_type_t cs_property_get_type(const cs_property_t *pty)
Retrieve the type of a property.
Definition: cs_property.h:369
field
Definition: field.f90:27
CS_PROPERTY_ANISO_SYM
#define CS_PROPERTY_ANISO_SYM
Definition: cs_property.h:94
cs_property_finalize_setup
void cs_property_finalize_setup(void)
Last stage of the definition of a property based on several definitions (i.e. definition by subdomain...
Definition: cs_property.c:993
cs_property_set_reference_value
void cs_property_set_reference_value(cs_property_t *pty, double refval)
Set the reference value associated to a cs_property_t structure This is a real number even whatever t...
Definition: cs_property.c:934
cs_property_def_by_field
void cs_property_def_by_field(cs_property_t *pty, cs_field_t *field)
Define a cs_property_t structure thanks to a field structure.
Definition: cs_property.c:1753
_cs_property_t::type
cs_property_type_t type
Definition: cs_property.h:151
_cs_property_t::get_eval_at_cell
cs_xdef_eval_t ** get_eval_at_cell
Definition: cs_property.h:177
cs_real_t
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
cs_cdo_quantities_t
Definition: cs_cdo_quantities.h:132
CS_PROPERTY_ISO
#define CS_PROPERTY_ISO
Definition: cs_property.h:75
CS_PTYKEY_POST_FOURIER
Definition: cs_property.h:128
cs_property_data_t::need_eigen
bool need_eigen
Definition: cs_property.h:206
cs_property_def_iso_by_value
cs_xdef_t * cs_property_def_iso_by_value(cs_property_t *pty, const char *zname, double val)
Define an isotropic cs_property_t structure by value for entities related to a volume zone...
Definition: cs_property.c:1284
cs_property_def_by_func
cs_xdef_t * cs_property_def_by_func(cs_property_t *pty, const char *zname, void *context, cs_xdef_eval_t *get_eval_at_cell, cs_xdef_cw_eval_t *get_eval_at_cell_cw)
Define a cs_property_t structure thanks to law depending on one scalar variable in a subdomain attach...
Definition: cs_property.c:1630
cs_xdef.h
CS_PROPERTY_SUBCELL_DEFINITION
#define CS_PROPERTY_SUBCELL_DEFINITION
Definition: cs_property.h:109
cs_analytic_func_t
void() cs_analytic_func_t(cs_real_t time, cs_lnum_t n_elts, const cs_lnum_t *elt_ids, const cs_real_t *coords, bool dense_output, void *input, cs_real_t *retval)
Generic function pointer for an evaluation relying on an analytic function.
Definition: cs_param_types.h:127
cs_xdef_eval_t
void() cs_xdef_eval_t(cs_lnum_t n_elts, const cs_lnum_t *elt_ids, bool dense_output, const cs_mesh_t *mesh, const cs_cdo_connect_t *connect, const cs_cdo_quantities_t *quant, cs_real_t time_eval, void *context, cs_real_t *eval)
Function pointer for evaluating a quantity defined through a descriptor (cs_xdef_t structure) ...
Definition: cs_xdef_eval.h:66
_cs_property_t
Definition: cs_property.h:145
_cs_property_t::related_properties
const cs_property_t ** related_properties
Definition: cs_property.h:188
cs_property_def_aniso_sym_by_value
cs_xdef_t * cs_property_def_aniso_sym_by_value(cs_property_t *pty, const char *zname, cs_real_t symtens[6])
Define an anisotropic cs_property_t structure by value for entities related to a volume zone...
Definition: cs_property.c:1451
cs_property_value_in_cell
cs_real_t cs_property_value_in_cell(const cs_cell_mesh_t *cm, const cs_property_t *pty, cs_real_t t_eval)
Compute the value of a property at the cell center Version using a cs_cell_mesh_t structure...
Definition: cs_property.c:2229
cs_flag.h
_cs_property_t::defs
cs_xdef_t ** defs
Definition: cs_property.h:163
dt
Definition: cs_field_pointer.h:65
cs_property_iso_get_cell_values
void cs_property_iso_get_cell_values(cs_real_t t_eval, const cs_property_t *pty, int *pty_stride, cs_real_t **p_pty_vals)
Evaluate the value of the property at each cell. Store the evaluation in the given array...
Definition: cs_property.c:1815
cs_property_data_init
void cs_property_data_init(bool need_tensor, bool need_eigen, const cs_property_t *property, cs_property_data_t *data)
Initialize a cs_property_data_t structure. If property is NULL then one considers that this is a unit...
Definition: cs_property.c:1163
CS_FLAG_STATE_STEADY
#define CS_FLAG_STATE_STEADY
Definition: cs_flag.h:106
cs_property_get_name
static const char * cs_property_get_name(const cs_property_t *pty)
Retrieve the name of a property.
Definition: cs_property.h:350
cs_property_is_steady
static bool cs_property_is_steady(const cs_property_t *pty)
returns true if the property is steady, otherwise false
Definition: cs_property.h:261
cs_property_get_cell_value
cs_real_t cs_property_get_cell_value(cs_lnum_t c_id, cs_real_t t_eval, const cs_property_t *pty)
Compute the value of a property at the cell center.
Definition: cs_property.c:2136
cs_property_eval_at_cells
void cs_property_eval_at_cells(cs_real_t t_eval, const cs_property_t *pty, cs_real_t *array)
Evaluate the value of the property at each cell. Store the evaluation in the given array...
Definition: cs_property.c:1863
cs_xdef_t
Structure storing medata for defining a quantity in a very flexible way.
Definition: cs_xdef.h:154
cs_property_def_by_time_func
cs_xdef_t * cs_property_def_by_time_func(cs_property_t *pty, const char *zname, cs_time_func_t *func, void *input)
Define a cs_property_t structure thanks to an analytic function in a subdomain attached to the mesh l...
Definition: cs_property.c:1504
cs_xdef_cw_eval_t
void() cs_xdef_cw_eval_t(const cs_cell_mesh_t *cm, cs_real_t time_eval, void *input, cs_real_t *eval)
Function pointer for evaluating a quantity defined through a descriptor (cs_xdef_t structure) by a ce...
Definition: cs_xdef_cw_eval.h:70
cs_property_c2v_values
void cs_property_c2v_values(const cs_cell_mesh_t *cm, const cs_property_t *pty, cs_real_t t_eval, cs_real_t *eval)
Compute the values of an isotropic property in each portion of dual cell in a (primal) cell...
Definition: cs_property.c:2274
cs_property_data_t::need_tensor
bool need_tensor
Definition: cs_property.h:210
cs_property_set_option
void cs_property_set_option(cs_property_t *pty, cs_property_key_t key)
Set optional parameters related to a cs_property_t structure.
Definition: cs_property.c:903
cs_property_def_by_analytic
cs_xdef_t * cs_property_def_by_analytic(cs_property_t *pty, const char *zname, cs_analytic_func_t *func, void *input)
Define a cs_property_t structure thanks to an analytic function in a subdomain attached to the mesh l...
Definition: cs_property.c:1580
cs_field.h
cs_lnum_t
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
_cs_property_t::n_definitions
int n_definitions
Definition: cs_property.h:162
cs_property_get_cell_tensor
void cs_property_get_cell_tensor(cs_lnum_t c_id, cs_real_t t_eval, const cs_property_t *pty, bool do_inversion, cs_real_t tensor[3][3])
Compute the value of the tensor attached to a property at the cell center.
Definition: cs_property.c:2095
cs_property_data_define
cs_property_data_t cs_property_data_define(bool need_tensor, bool need_eigen, const cs_property_t *property)
Define a cs_property_data_t structure (not a pointer to this structure). If property is NULL then one...
Definition: cs_property.c:1106
cs_property_get_fourier
void cs_property_get_fourier(const cs_property_t *pty, cs_real_t t_eval, double dt, cs_real_t fourier[])
Compute the Fourier number in each cell.
Definition: cs_property.c:2400
_cs_property_t::n_related_properties
int n_related_properties
Definition: cs_property.h:187
END_C_DECLS
#define END_C_DECLS
Definition: cs_defs.h:511
cs_flag_t
unsigned short int cs_flag_t
Definition: cs_defs.h:324
cs_property_by_id
cs_property_t * cs_property_by_id(int id)
Find the related property definition from its id.
Definition: cs_property.c:883
cs_time_func_t
void() cs_time_func_t(double time, void *input, cs_real_t *retval)
Function which defines the evolution of a quantity according to the current time and any structure gi...
Definition: cs_param_types.h:172
cs_property_data_t::is_unity
bool is_unity
Definition: cs_property.h:204
cs_property_data_t::property
const cs_property_t * property
Definition: cs_property.h:201
CS_PTYKEY_N_KEYS
Definition: cs_property.h:129
cs_property_is_constant
static bool cs_property_is_constant(const cs_property_t *pty)
returns true if the property is steady and uniform, otherwise false
Definition: cs_property.h:235
cs_property_tensor_in_cell
void cs_property_tensor_in_cell(const cs_cell_mesh_t *cm, const cs_property_t *pty, cs_real_t t_eval, bool do_inversion, cs_real_t tensor[3][3])
Compute the value of the tensor attached to a property at the cell center Version using a cs_cell_mes...
Definition: cs_property.c:2186
cs_property_add_as_product
cs_property_t * cs_property_add_as_product(const char *name, const cs_property_t *pty_a, const cs_property_t *pty_b)
Define a cs_property_t structure thanks to the product of two properties The type is infered from tha...
Definition: cs_property.c:794
CS_PROPERTY_ANISO
#define CS_PROPERTY_ANISO
Definition: cs_property.h:88
cs_property_is_subcell
static bool cs_property_is_subcell(const cs_property_t *pty)
returns true if the property is allowed to be evaluated on a sub-partition of a cell ...
Definition: cs_property.h:328
cs_xdef_cw_eval.h
cs_property_type_t
cs_flag_t cs_property_type_t
Definition: cs_property.h:117
cs_property_is_isotropic
static bool cs_property_is_isotropic(const cs_property_t *pty)
returns true if the property is isotropic, otherwise false
Definition: cs_property.h:305
cs_property_def_constant_value
cs_xdef_t * cs_property_def_constant_value(cs_property_t *pty, double val)
Define a single uniform and steady isotropic definition for the given cs_property_t structure...
Definition: cs_property.c:1225
cs_property_key_t
cs_property_key_t
List of available keys for setting options on a property.
Definition: cs_property.h:126
cs_property_is_uniform
static bool cs_property_is_uniform(const cs_property_t *pty)
returns true if the property is uniform, otherwise false
Definition: cs_property.h:283
cs_property_get_n_properties
int cs_property_get_n_properties(void)
Retrieve the number of properties.
Definition: cs_property.c:707
cs_property_t
Structure associated to the definition of a property relying on the cs_xdef_t structure.
cs_xdef_eval.h
cs_property_def_by_array
cs_xdef_t * cs_property_def_by_array(cs_property_t *pty, cs_flag_t loc, cs_real_t *array, bool is_owner, const cs_lnum_t *index, const cs_lnum_t *ids)
Define a cs_property_t structure thanks to an array of values.
Definition: cs_property.c:1677