cs_xdef.h

Go to the documentation of this file.

#ifndef __CS_XDEF_H__
#define __CS_XDEF_H__
 
/*============================================================================
 * Functions to handle extended definitions of quantities
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2025 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.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 * Standard C library headers
 *----------------------------------------------------------------------------*/
 
#include <string.h>
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "base/cs_base.h"
#include "base/cs_boundary_zone.h"
#include "base/cs_field.h"
#include "base/cs_param_types.h"
#include "base/cs_volume_zone.h"
#include "cdo/cs_quadrature.h"
#include "mesh/cs_mesh_adjacencies.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
typedef void *
(cs_xdef_free_input_t)(void   *input);

 
typedef enum {
 
  CS_XDEF_BY_ANALYTIC_FUNCTION,
  CS_XDEF_BY_ARRAY,
  CS_XDEF_BY_DOF_FUNCTION,
  CS_XDEF_BY_FIELD,
  CS_XDEF_BY_FUNCTION,
  CS_XDEF_BY_QOV,
  CS_XDEF_BY_SUB_DEFINITIONS,
  CS_XDEF_BY_TIME_FUNCTION,
  CS_XDEF_BY_VALUE,
 
  CS_N_XDEF_TYPES
 
} cs_xdef_type_t;

 
typedef enum {
 
  CS_XDEF_SUPPORT_TIME,      /* support for time step description */
  CS_XDEF_SUPPORT_BOUNDARY,  /* zones attached to boundary faces */
  CS_XDEF_SUPPORT_VOLUME,
 
  CS_N_XDEF_SUPPORTS
 
} cs_xdef_support_t;

 
typedef struct {

 
  int                    dim;
  cs_xdef_type_t         type;
  int                    z_id;
  cs_xdef_support_t      support;
 
  cs_flag_t              state;
  cs_flag_t              meta;
 
  cs_quadrature_type_t   qtype;
 
  void                  *context;
 
} cs_xdef_t;

 
typedef struct {

 
  int                     z_id;
  int                     stride;
  cs_flag_t               value_location;
  bool                    is_owner;
  bool                    full_length;
 
  cs_real_t              *values;
 
  /* Automatic parameter */
 
  cs_lnum_t              *full2subset;
 
  /* Optional parameters */
 
  cs_lnum_t               n_list_elts;
  const cs_lnum_t        *elt_ids;
  const cs_adjacency_t   *adjacency;
 
} cs_xdef_array_context_t;

 
typedef struct {

 
  int                    z_id;

 
  cs_analytic_func_t    *func;

 
  void                  *input;

 
  cs_xdef_free_input_t  *free_input;
 
} cs_xdef_analytic_context_t;

 
typedef struct {

 
  int                    z_id;

 
  cs_flag_t              dof_location;

 
  cs_dof_func_t         *func;

 
  void                  *input;

 
  cs_xdef_free_input_t  *free_input;
 
} cs_xdef_dof_context_t;

 
typedef struct {

 
  int                    z_id;

 
  cs_time_func_t        *func;

 
  void                  *input;

 
  cs_xdef_free_input_t  *free_input;
 
} cs_xdef_time_func_context_t;
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_xdef_get_scalar_value(cs_xdef_t *def)
{
  assert(def != NULL);
  assert(def->dim == 1);
  assert(def->type == CS_XDEF_BY_VALUE);
 
  cs_real_t  *value = (cs_real_t *)def->context;
 
  return value[0];
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline void
cs_xdef_set_scalar_value(cs_xdef_t *def,
                         cs_real_t  val)
{
  assert(def != NULL);
  assert(def->dim == 1);
  assert(def->type == CS_XDEF_BY_VALUE);
 
  cs_real_t *values = (cs_real_t *)def->context;
 
  values[0] = val;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t *
cs_xdef_array_get_values(const cs_xdef_t     *def)
{
  if (def == NULL)
    return NULL;
 
  assert(def->type == CS_XDEF_BY_ARRAY);
 
  cs_xdef_array_context_t  *ai = (cs_xdef_array_context_t *)def->context;
 
  return ai->values;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_field_t *
cs_xdef_field_get(cs_xdef_t     *def)
{
  if (def == NULL)
    return NULL;
 
  assert(def->type == CS_XDEF_BY_FIELD);
 
  return (cs_field_t *)def->context;
}
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_xdef_volume_create(cs_xdef_type_t           type,
                      int                      dim,
                      int                      z_id,
                      cs_flag_t                state,
                      cs_flag_t                meta,
                      void                    *context);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_xdef_boundary_create(cs_xdef_type_t    type,
                        int               dim,
                        int               z_id,
                        cs_flag_t         state,
                        cs_flag_t         meta,
                        void             *context);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_xdef_timestep_create(cs_xdef_type_t       type,
                        cs_flag_t            state,
                        cs_flag_t            meta,
                        void                *context);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_xdef_free(cs_xdef_t     *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_t *
cs_xdef_copy(cs_xdef_t     *src);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_set_input_context(cs_xdef_t       *d,
                          void            *input);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_set_free_input_function(cs_xdef_t               *d,
                                cs_xdef_free_input_t    *free_input);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_set_quadrature(cs_xdef_t              *d,
                       cs_quadrature_type_t    qtype);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_quadrature_type_t
cs_xdef_get_quadrature(cs_xdef_t     *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_xdef_type_t
cs_xdef_get_type(const cs_xdef_t     *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_flag_t
cs_xdef_get_state_flag(const cs_xdef_t     *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_log_setup(const char          *prefix,
                  const cs_xdef_t     *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_log(cs_log_t             log_type,
            const char          *prefix,
            const cs_xdef_t     *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const char *
cs_xdef_type_get_name(cs_xdef_type_t  xdef_type);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_array_set_values(cs_xdef_t     *d,
                         bool           is_owner,
                         cs_real_t     *values);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_array_set_zone_id(cs_xdef_t     *d,
                          int            z_id);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_array_build_full2subset(const cs_xdef_t         *d);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_array_set_adjacency(cs_xdef_t             *d,
                            const cs_adjacency_t  *adj);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_xdef_array_set_sublist(cs_xdef_t         *d,
                          cs_lnum_t          n_elts,
                          const cs_lnum_t    elt_ids[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_real_t *
cs_xdef_field_get_values(cs_xdef_t     *def);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_XDEF_H__ */