cs_property.h

Go to the documentation of this file.

#ifndef __CS_PROPERTY_H__
#define __CS_PROPERTY_H__
 
/*============================================================================
 * Manage the definition/setting of properties
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2023 EDF S.A.
 
  This program is free software; you can redistribute it and/or modify it under
  the terms of the GNU General Public License as published by the Free Software
  Foundation; either version 2 of the License, or (at your option) any later
  version.
 
  This program is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  details.
 
  You should have received a copy of the GNU General Public License along with
  this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
  Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "cs_field.h"
#include "cs_flag.h"
#include "cs_param_types.h"
#include "cs_xdef.h"
#include "cs_xdef_cw_eval.h"
#include "cs_xdef_eval.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/* Common property names (property which is shared between different module) */
 
#define CS_PROPERTY_MASS_DENSITY   "mass_density"
 
#define CS_PROPERTY_POST_FOURIER  (1 << 0)
 
#define CS_PROPERTY_ISO           (1 << 0)
 
#define CS_PROPERTY_ORTHO                    (1 << 1)
 
#define CS_PROPERTY_ANISO                    (1 << 2)
 
#define CS_PROPERTY_ANISO_SYM                (1 << 3)
 
#define CS_PROPERTY_BY_PRODUCT               (1 << 4)
 
#define CS_PROPERTY_SUBCELL_DEFINITION       (1 << 5)
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef cs_flag_t cs_property_type_t;
 
typedef enum {
 
  CS_PTYKEY_POST_FOURIER,
  CS_PTYKEY_N_KEYS
 
} cs_property_key_t;
 
/* ======================================== */
/* Set of parameters attached to a property */
/* ======================================== */
 
typedef struct _cs_property_t cs_property_t;
 
struct _cs_property_t {
 
  char *restrict       name;
  int                  id;
  cs_flag_t            state_flag;
  cs_flag_t            process_flag;
  cs_property_type_t   type;
 
  /* Reference value wich is used as default when nothing else is set. This
   * value can also be used to renormalized quantities related to this property
   * By default, this is set to 1
   */
 
  cs_real_t            ref_value;
 
  /* Property is up to now only defined on the whole domain (volume) */
 
  int                  n_definitions;  /* Current number of definitions used */
  cs_xdef_t          **defs;           /* List of definitions */
 
  /* Store the definition id for each cell, NULL if there is only one
     definition set */
 
  short int           *def_ids;
 
  /* Function pointers to handle generic tasks related to a property. There
     is one function related to each definition. Some functions may not be
     allocated according to the kind of property */
 
  /* Retrieve the evaluation of the property at the cell center for each
     definition */
 
  cs_xdef_eval_t     **get_eval_at_cell;
 
  /* Same thing as the previous one but now with the usage of cellwise algo.
     relying on a cs_cell_mesh_t structure */
 
  cs_xdef_cw_eval_t  **get_eval_at_cell_cw;
 
  /* For properties relying on other properties for their definition, one
   * stores the pointers to these related properties */
 
  int                     n_related_properties;
  const cs_property_t   **related_properties;
 
  /* Optional: Definition(s) of the property at the boundary. If nothing is
     set, then one uses the definition on the volume to get information on the
     boundary. This is the default behavior. */
 
  int                     n_b_definitions;
  cs_xdef_t             **b_defs;
 
  /* Store the definition id for each boundary face, NULL if there is only one
     boundary definition set */
 
  short int              *b_def_ids;
 
};
 
 
typedef struct {
 
  const cs_property_t   *property; /* shared pointer */
 
  bool                   is_iso;   /* Detect if this an easier case */
  bool                   is_unity; /* Detect if this a simple case */
 
  bool                   need_eigen;
  cs_real_t              eigen_max;
  cs_real_t              eigen_ratio;
 
  bool                   need_tensor;
  cs_real_t              tensor[3][3];
  cs_real_t              value;
 
} cs_property_data_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*============================================================================
 * Static inline public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_property_is_constant(const cs_property_t   *pty)
{
  if (pty == NULL)
    return true; /* Treated as the "unity" property */
 
  if (pty->state_flag & CS_FLAG_STATE_STEADY) {
    if (pty->state_flag & CS_FLAG_STATE_UNIFORM)
      return true;
    else
      return false;
  }
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_property_is_steady(const cs_property_t   *pty)
{
  if (pty == NULL)
    return true; /* Treated as the "unity" property */
 
  if (pty->state_flag & CS_FLAG_STATE_STEADY)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_property_is_uniform(const cs_property_t   *pty)
{
  if (pty == NULL)
    return true; /* Treated as the "unity" property */
 
  if (pty->state_flag & CS_FLAG_STATE_UNIFORM)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_property_is_isotropic(const cs_property_t   *pty)
{
  if (pty == NULL)
    return false;
 
  if (pty->type & CS_PROPERTY_ISO)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_property_is_subcell(const cs_property_t   *pty)
{
  if (pty == NULL)
    return false;
 
  if (pty->type & CS_PROPERTY_SUBCELL_DEFINITION)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline const char *
cs_property_get_name(const cs_property_t   *pty)
{
  if (pty == NULL)
    return NULL;
 
  return pty->name;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_property_type_t
cs_property_get_type(const cs_property_t   *pty)
{
  if (pty == NULL)
    return 0; /* means undefined */
 
  return pty->type;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline int
cs_property_get_dim(const cs_property_t   *pty)
{
  if (pty == NULL)
    return 0; /* means undefined */
 
  if (pty->type & CS_PROPERTY_ISO)
    return 1;
  else if (pty->type & CS_PROPERTY_ORTHO)
    return 3;
  else if (pty->type & CS_PROPERTY_ANISO_SYM)
    return 6;
  else if (pty->type & CS_PROPERTY_ANISO)
    return 9;
  else
    return 0; /* means undefined */
}
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_init_sharing(const cs_mesh_t              *mesh,
                         const cs_cdo_quantities_t    *quant,
                         const cs_cdo_connect_t       *connect);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_property_get_n_properties(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_property_t *
cs_property_add(const char            *name,
                cs_property_type_t     type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_property_t *
cs_property_subcell_add(const char            *name,
                        cs_property_type_t     type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_property_t *
cs_property_add_as_product(const char             *name,
                           const cs_property_t    *pty_a,
                           const cs_property_t    *pty_b);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_property_t *
cs_property_by_name(const char   *name);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_property_t *
cs_property_by_id(int         id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_set_option(cs_property_t       *pty,
                       cs_property_key_t    key);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_set_reference_value(cs_property_t    *pty,
                                double            refval);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_destroy_all(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_finalize_setup(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_property_data_t
cs_property_data_define(bool                     need_tensor,
                        bool                     need_eigen,
                        const cs_property_t     *property);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_data_init(bool                     need_tensor,
                      bool                     need_eigen,
                      const cs_property_t     *property,
                      cs_property_data_t      *data);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_constant_value(cs_property_t    *pty,
                               double            val);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_iso_by_value(cs_property_t    *pty,
                             const char       *zname,
                             double            val);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_iso_by_value(cs_property_t    *pty,
                                      const char       *zname,
                                      double            val);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_ortho_by_value(cs_property_t    *pty,
                               const char       *zname,
                               double            val[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_ortho_by_value(cs_property_t    *pty,
                                        const char       *zname,
                                        double            vals[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_aniso_by_value(cs_property_t    *pty,
                               const char       *zname,
                               cs_real_t         tens[3][3]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_aniso_by_value(cs_property_t    *pty,
                                        const char       *zname,
                                        double            tens[3][3]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_aniso_sym_by_value(cs_property_t    *pty,
                                   const char       *zname,
                                   cs_real_t         symtens[6]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_aniso_sym_by_value(cs_property_t    *pty,
                                            const char       *zname,
                                            double            tens[6]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_by_time_func(cs_property_t      *pty,
                             const char         *zname,
                             cs_time_func_t     *func,
                             void               *input);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_by_time_func(cs_property_t      *pty,
                                      const char         *zname,
                                      cs_time_func_t     *func,
                                      void               *input);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_by_analytic(cs_property_t        *pty,
                            const char           *zname,
                            cs_analytic_func_t   *func,
                            void                 *input);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_by_analytic(cs_property_t        *pty,
                                     const char           *zname,
                                     cs_analytic_func_t   *func,
                                     void                 *input);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_by_array(cs_property_t      *pty,
                         const char         *zname,
                         cs_flag_t           val_location,
                         cs_real_t          *array,
                         bool                is_owner,
                         bool                full_length);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_by_array(cs_property_t      *pty,
                                  const char         *zname,
                                  cs_flag_t           val_loc,
                                  cs_real_t          *array,
                                  bool                is_owner,
                                  bool                full_length);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_def_by_field(cs_property_t    *pty,
                         cs_field_t       *field);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_property_boundary_def_by_field(cs_property_t    *pty,
                                  cs_field_t       *field);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_evaluate_def(const cs_property_t    *pty,
                         int                     def_id,
                         bool                    dense_output,
                         double                  t_eval,
                         cs_real_t              *eval);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_evaluate_boundary_def(const cs_property_t  *pty,
                                  int                   def_id,
                                  bool                  dense_output,
                                  double                t_eval,
                                  cs_real_t            *array);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_eval_at_cells(cs_real_t               t_eval,
                          const cs_property_t    *pty,
                          cs_real_t              *array);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_eval_at_boundary_faces(cs_real_t               t_eval,
                                   const cs_property_t    *pty,
                                   cs_real_t              *array);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_real_t
cs_property_get_cell_value(cs_lnum_t              c_id,
                           cs_real_t              t_eval,
                           const cs_property_t   *pty);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_real_t
cs_property_value_in_cell(const cs_cell_mesh_t   *cm,
                          const cs_property_t    *pty,
                          cs_real_t               t_eval);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
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);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_get_fourier(const cs_property_t    *pty,
                        cs_real_t               t_eval,
                        double                  dt,
                        cs_real_t               fourier[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_property_log_setup(void);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_PROPERTY_H__ */