7.1
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-2021 EDF S.A.
12 
13  This program is free software; you can redistribute it and/or modify it under
14  the terms of the GNU General Public License as published by the Free Software
15  Foundation; either version 2 of the License, or (at your option) any later
16  version.
17 
18  This program is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
21  details.
22 
23  You should have received a copy of the GNU General Public License along with
24  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
25  Street, Fifth Floor, Boston, MA 02110-1301, USA.
26 */
27 
28 /*----------------------------------------------------------------------------*/
29 
30 /*----------------------------------------------------------------------------
31  * Local headers
32  *----------------------------------------------------------------------------*/
33 
34 #include "cs_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 
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 
60 #define CS_PROPERTY_POST_FOURIER (1 << 0)
61 
73 #define CS_PROPERTY_ISO (1 << 0)
74 
78 #define CS_PROPERTY_ORTHO (1 << 1)
79 
84 #define CS_PROPERTY_ANISO (1 << 2)
85 
89 #define CS_PROPERTY_ANISO_SYM (1 << 3)
90 
94 #define CS_PROPERTY_BY_PRODUCT (1 << 4)
95 
98 /*============================================================================
99  * Type definitions
100  *============================================================================*/
101 
103 
111 typedef enum {
112 
115 
117 
118 /* ======================================== */
119 /* Set of parameters attached to a property */
120 /* ======================================== */
121 
128 typedef struct _cs_property_t cs_property_t;
129 
131 
132  char *restrict name;
133  int id;
137 
138  /* Reference value wich is used as default when nothing else is set. This
139  * value can also be used to renormalized quantities related to this property
140  * By default, this is set to 1
141  */
143 
144  /* Property is up to now only defined on the whole domain (volume) */
145  int n_definitions; /* Current number of definitions used */
146  cs_xdef_t **defs; /* List of definitions */
147 
148  /* Store the definition id for each cell, NULL if there is only one
149  definition set */
150  short int *def_ids;
151 
152  /* Function pointers to handle generic tasks related to a property. There
153  is one function related to each definition. Some functions may not be
154  allocated according to the kind of property */
155 
156  /* Retrieve the evaluation of the property at the cell center for each
157  definition */
159 
160  /* Same thing as the previous one but now with the usage of cellwise algo.
161  relying on a cs_cell_mesh_t structure */
163 
164  /* For properties relying on other properties for their definition, one
165  * stores the pointers to these related properties */
168 
169 };
170 
171 
178 typedef struct {
179 
180  const cs_property_t *property; /* shared pointer */
181 
182  bool is_iso; /* Detect if this an easier case */
183  bool is_unity; /* Detect if this a simple case */
184 
188 
190  cs_real_t tensor[3][3];
192 
194 
195 /*============================================================================
196  * Global variables
197  *============================================================================*/
198 
199 /*============================================================================
200  * Static inline public function prototypes
201  *============================================================================*/
202 
203 /*----------------------------------------------------------------------------*/
211 /*----------------------------------------------------------------------------*/
212 
213 static inline bool
214 cs_property_is_constant(const cs_property_t *pty)
215 {
216  if (pty == NULL)
217  return true; /* Treated as the "unity" property */
218 
219  if (pty->state_flag & CS_FLAG_STATE_STEADY) {
220  if (pty->state_flag & CS_FLAG_STATE_UNIFORM)
221  return true;
222  else
223  return false;
224  }
225  else
226  return false;
227 }
228 
229 /*----------------------------------------------------------------------------*/
237 /*----------------------------------------------------------------------------*/
238 
239 static inline bool
240 cs_property_is_steady(const cs_property_t *pty)
241 {
242  if (pty == NULL)
243  return true; /* Treated as the "unity" property */
244 
245  if (pty->state_flag & CS_FLAG_STATE_STEADY)
246  return true;
247  else
248  return false;
249 }
250 
251 /*----------------------------------------------------------------------------*/
259 /*----------------------------------------------------------------------------*/
260 
261 static inline bool
262 cs_property_is_uniform(const cs_property_t *pty)
263 {
264  if (pty == NULL)
265  return true; /* Treated as the "unity" property */
266 
267  if (pty->state_flag & CS_FLAG_STATE_UNIFORM)
268  return true;
269  else
270  return false;
271 }
272 
273 /*----------------------------------------------------------------------------*/
281 /*----------------------------------------------------------------------------*/
282 
283 static inline bool
284 cs_property_is_isotropic(const cs_property_t *pty)
285 {
286  if (pty == NULL)
287  return false;
288 
289  if (pty->type & CS_PROPERTY_ISO)
290  return true;
291  else
292  return false;
293 }
294 
295 /*----------------------------------------------------------------------------*/
303 /*----------------------------------------------------------------------------*/
304 
305 static inline const char *
306 cs_property_get_name(const cs_property_t *pty)
307 {
308  if (pty == NULL)
309  return NULL;
310 
311  return pty->name;
312 }
313 
314 /*----------------------------------------------------------------------------*/
322 /*----------------------------------------------------------------------------*/
323 
324 static inline cs_property_type_t
325 cs_property_get_type(const cs_property_t *pty)
326 {
327  if (pty == NULL)
328  return 0; /* means undefined */
329 
330  return pty->type;
331 }
332 
333 /*----------------------------------------------------------------------------*/
341 /*----------------------------------------------------------------------------*/
342 
343 static inline int
344 cs_property_get_dim(const cs_property_t *pty)
345 {
346  if (pty == NULL)
347  return 0; /* means undefined */
348 
349  if (pty->type & CS_PROPERTY_ISO)
350  return 1;
351  else if (pty->type & CS_PROPERTY_ORTHO)
352  return 3;
353  else if (pty->type & CS_PROPERTY_ANISO_SYM)
354  return 6;
355  else if (pty->type & CS_PROPERTY_ANISO)
356  return 9;
357  else
358  return 0; /* means undefined */
359 }
360 
361 /*============================================================================
362  * Public function prototypes
363  *============================================================================*/
364 
365 /*----------------------------------------------------------------------------*/
372 /*----------------------------------------------------------------------------*/
373 
374 void
376  const cs_cdo_connect_t *connect);
377 
378 /*----------------------------------------------------------------------------*/
384 /*----------------------------------------------------------------------------*/
385 
386 int
388 
389 /*----------------------------------------------------------------------------*/
398 /*----------------------------------------------------------------------------*/
399 
401 cs_property_add(const char *name,
403 
404 /*----------------------------------------------------------------------------*/
418 /*----------------------------------------------------------------------------*/
419 
421 cs_property_add_as_product(const char *name,
422  const cs_property_t *pty_a,
423  const cs_property_t *pty_b);
424 
425 /*----------------------------------------------------------------------------*/
433 /*----------------------------------------------------------------------------*/
434 
436 cs_property_by_name(const char *name);
437 
438 /*----------------------------------------------------------------------------*/
446 /*----------------------------------------------------------------------------*/
447 
449 cs_property_by_id(int id);
450 
451 /*----------------------------------------------------------------------------*/
458 /*----------------------------------------------------------------------------*/
459 
460 void
462  cs_property_key_t key);
463 
464 /*----------------------------------------------------------------------------*/
472 /*----------------------------------------------------------------------------*/
473 
474 void
476  double refval);
477 
478 /*----------------------------------------------------------------------------*/
483 /*----------------------------------------------------------------------------*/
484 
485 void
487 
488 /*----------------------------------------------------------------------------*/
493 /*----------------------------------------------------------------------------*/
494 
495 void
497 
498 /*----------------------------------------------------------------------------*/
508 /*----------------------------------------------------------------------------*/
509 
510 void
511 cs_property_data_init(bool need_tensor,
512  bool need_eigen,
513  const cs_property_t *property,
514  cs_property_data_t *data);
515 
516 /*----------------------------------------------------------------------------*/
528 /*----------------------------------------------------------------------------*/
529 
530 cs_xdef_t *
532  double val);
533 
534 /*----------------------------------------------------------------------------*/
546 /*----------------------------------------------------------------------------*/
547 
548 cs_xdef_t *
550  const char *zname,
551  double val);
552 
553 /*----------------------------------------------------------------------------*/
565 /*----------------------------------------------------------------------------*/
566 
567 cs_xdef_t *
569  const char *zname,
570  double val[]);
571 
572 /*----------------------------------------------------------------------------*/
584 /*----------------------------------------------------------------------------*/
585 
586 cs_xdef_t *
588  const char *zname,
589  cs_real_t tens[3][3]);
590 
591 /*----------------------------------------------------------------------------*/
603 /*----------------------------------------------------------------------------*/
604 
605 cs_xdef_t *
607  const char *zname,
608  cs_real_t symtens[6]);
609 
610 /*----------------------------------------------------------------------------*/
623 /*----------------------------------------------------------------------------*/
624 
625 cs_xdef_t *
627  const char *zname,
628  cs_time_func_t *func,
629  void *input);
630 
631 /*----------------------------------------------------------------------------*/
644 /*----------------------------------------------------------------------------*/
645 
646 cs_xdef_t *
648  const char *zname,
649  cs_analytic_func_t *func,
650  void *input);
651 
652 /*----------------------------------------------------------------------------*/
667 /*----------------------------------------------------------------------------*/
668 
669 cs_xdef_t *
671  const char *zname,
672  void *context,
675 
676 /*----------------------------------------------------------------------------*/
689 /*----------------------------------------------------------------------------*/
690 
691 cs_xdef_t *
693  cs_flag_t loc,
694  cs_real_t *array,
695  bool is_owner,
696  cs_lnum_t *index);
697 
698 /*----------------------------------------------------------------------------*/
705 /*----------------------------------------------------------------------------*/
706 
707 void
709  cs_field_t *field);
710 
711 /*----------------------------------------------------------------------------*/
723 /*----------------------------------------------------------------------------*/
724 
725 void
727  const cs_property_t *pty,
728  int *pty_stride,
729  cs_real_t **p_pty_vals);
730 
731 /*----------------------------------------------------------------------------*/
740 /*----------------------------------------------------------------------------*/
741 
742 void
744  const cs_property_t *pty,
745  cs_real_t *array);
746 
747 /*----------------------------------------------------------------------------*/
758 /*----------------------------------------------------------------------------*/
759 
760 void
762  cs_real_t t_eval,
763  const cs_property_t *pty,
764  bool do_inversion,
765  cs_real_t tensor[3][3]);
766 
767 /*----------------------------------------------------------------------------*/
777 /*----------------------------------------------------------------------------*/
778 
779 cs_real_t
781  cs_real_t t_eval,
782  const cs_property_t *pty);
783 
784 /*----------------------------------------------------------------------------*/
796 /*----------------------------------------------------------------------------*/
797 
798 void
800  const cs_property_t *pty,
801  cs_real_t t_eval,
802  bool do_inversion,
803  cs_real_t tensor[3][3]);
804 
805 /*----------------------------------------------------------------------------*/
816 /*----------------------------------------------------------------------------*/
817 
818 cs_real_t
820  const cs_property_t *pty,
821  cs_real_t t_eval);
822 
823 /*----------------------------------------------------------------------------*/
832 /*----------------------------------------------------------------------------*/
833 
834 void
836  cs_real_t t_eval,
837  double dt,
838  cs_real_t fourier[]);
839 
840 /*----------------------------------------------------------------------------*/
845 /*----------------------------------------------------------------------------*/
846 
847 void
849 
850 /*----------------------------------------------------------------------------*/
851 
853 
854 #endif /* __CS_PROPERTY_H__ */
int id
Definition: cs_property.h:133
void cs_property_log_setup(void)
Print a summary of the settings for all defined cs_property_t structures.
Definition: cs_property.c:2221
cs_xdef_t * cs_property_def_by_array(cs_property_t *pty, cs_flag_t loc, cs_real_t *array, bool is_owner, cs_lnum_t *index)
Define a cs_property_t structure thanks to an array of values.
Definition: cs_property.c:1574
#define CS_PROPERTY_ORTHO
Definition: cs_property.h:78
#define restrict
Definition: cs_defs.h:142
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:709
cs_property_t * cs_property_by_name(const char *name)
Find the related property definition from its name.
Definition: cs_property.c:819
short int * def_ids
Definition: cs_property.h:150
cs_real_t eigen_ratio
Definition: cs_property.h:187
#define CS_FLAG_STATE_UNIFORM
Definition: cs_flag.h:87
void cs_property_set_shared_pointers(const cs_cdo_quantities_t *quant, const cs_cdo_connect_t *connect)
Set shared pointers to main domain members.
Definition: cs_property.c:675
cs_flag_t state_flag
Definition: cs_property.h:134
cs_real_t eigen_max
Definition: cs_property.h:186
Field descriptor.
Definition: cs_field.h:125
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:1293
bool is_iso
Definition: cs_property.h:182
Structure storing the evaluation of a property and its related data.
Definition: cs_property.h:178
char *restrict name
Definition: cs_property.h:132
#define BEGIN_C_DECLS
Definition: cs_defs.h:510
cs_flag_t process_flag
Definition: cs_property.h:135
cs_real_t ref_value
Definition: cs_property.h:142
Set of local quantities and connectivities related to a mesh cell.
Definition: cs_cdo_local.h:202
cs_real_t value
Definition: cs_property.h:191
cs_xdef_cw_eval_t ** get_eval_at_cell_cw
Definition: cs_property.h:162
void cs_property_destroy_all(void)
Free all cs_property_t structures and the array storing all the structures.
Definition: cs_property.c:916
Definition: cs_cdo_connect.h:79
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:1243
Definition: field.f90:27
#define CS_PROPERTY_ANISO_SYM
Definition: cs_property.h:89
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:958
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:899
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:1644
cs_property_type_t type
Definition: cs_property.h:136
cs_xdef_eval_t ** get_eval_at_cell
Definition: cs_property.h:158
double cs_real_t
Floating-point value.
Definition: cs_defs.h:322
Definition: cs_cdo_quantities.h:129
#define CS_PROPERTY_ISO
Definition: cs_property.h:73
Definition: cs_property.h:113
bool need_eigen
Definition: cs_property.h:185
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:1189
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:1528
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:100
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
Definition: cs_property.h:130
const cs_property_t ** related_properties
Definition: cs_property.h:167
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:1351
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:2112
cs_xdef_t ** defs
Definition: cs_property.h:146
Definition: cs_field_pointer.h:65
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:1707
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:1069
#define CS_FLAG_STATE_STEADY
Definition: cs_flag.h:90
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:2020
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:1754
Structure storing medata for defining a quantity in a very flexible way.
Definition: cs_xdef.h:154
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:1403
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
bool need_tensor
Definition: cs_property.h:189
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:866
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:1478
int cs_lnum_t
local mesh entity id
Definition: cs_defs.h:316
int n_definitions
Definition: cs_property.h:145
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:1980
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:2156
int n_related_properties
Definition: cs_property.h:166
#define END_C_DECLS
Definition: cs_defs.h:511
unsigned short int cs_flag_t
Definition: cs_defs.h:324
cs_property_t * cs_property_by_id(int id)
Find the related property definition from its id.
Definition: cs_property.c:846
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:145
bool is_unity
Definition: cs_property.h:183
const cs_property_t * property
Definition: cs_property.h:180
Definition: cs_property.h:114
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:2070
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:758
#define CS_PROPERTY_ANISO
Definition: cs_property.h:84
cs_flag_t cs_property_type_t
Definition: cs_property.h:102
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:1132
cs_property_key_t
List of available keys for setting options on a property.
Definition: cs_property.h:111
int cs_property_get_n_properties(void)
Retrieve the number of properties.
Definition: cs_property.c:692
Structure associated to the definition of a property relying on the cs_xdef_t structure.