cs_mesh_quantities.h

Go to the documentation of this file.

#ifndef CS_MESH_QUANTITIES_H
#define CS_MESH_QUANTITIES_H
 
/*============================================================================
 * Management of mesh 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.
*/
 
/*----------------------------------------------------------------------------*/
 
/*----------------------------------------------------------------------------
 *  Local headers
 *----------------------------------------------------------------------------*/
 
#include "base/cs_base.h"
#include "mesh/cs_mesh.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
/*
 * Cell quantities correction types
 */
 
#define CS_BAD_CELLS_WARPED_CORRECTION (1 << 0)
 
#define CS_BAD_CELLS_REGULARISATION (1 << 1)
 
#define CS_CELL_FACE_CENTER_CORRECTION (1 << 2)
 
#define CS_CELL_CENTER_CORRECTION (1 << 3)
 
#define CS_FACE_DISTANCE_CLIP (1 << 4)
 
#define CS_FACE_RECONSTRUCTION_CLIP (1 << 5)
 
#define CS_CELL_VOLUME_RATIO_CORRECTION (1 << 6)
 
#define CS_FACE_CENTER_REFINE (1 << 7)
 
#define CS_FACE_NULL_SURFACE (1 << 8)
 
/*============================================================================
 * Type definition
 *============================================================================*/
 
/* Structure associated to mesh quantities management */
 
typedef struct {
 
  cs_real_3_t   *cell_cen;       /* Cell center coordinates */
  cs_real_3_t   *cell_s_cen;     /* Cell solid center coordinates  */
 
  cs_real_t     *cell_vol;       /* Pointer to cell volume */
  cs_real_t     *_cell_vol;      /* Cell volume, if owner */
 
  cs_real_t     *i_face_normal;   /* Surface normal of interior faces.
                                     (L2 norm equals area of the face) */
  cs_real_t     *b_face_normal;   /* Surface normal of border faces.
                                     (L2 norm equals area of the face) */
  cs_real_t     *c_w_face_normal; /* Solid surface normal immersed in the cells.
                                     (L2 norm equals area of the face) */
  cs_real_3_t   *i_face_cog;     /* Center of gravity of interior faces */
  cs_real_3_t   *b_face_cog;     /* Center of gravity of border faces */
 
  cs_real_t     *c_w_face_cog;   /* Center of gravity of solid face
                                    immersed in the cells */
 
  cs_real_t     *i_face_surf;    /* Surface of interior faces. */
  cs_real_t     *b_face_surf;    /* Surface of boundary faces. */
 
  cs_real_t     *c_w_face_surf;  /* Solid surface of cells. */
 
  cs_nreal_3_t  *i_face_u_normal;  /* Unit normal of interior faces. */
  cs_nreal_3_t  *b_face_u_normal;  /* Unit normal of boundary faces. */
 
  cs_real_2_t   *i_f_face_factor; /* Fluid surface factor of interior faces. */
  cs_real_t     *b_f_face_factor; /* Fluid surface factor of boundary faces. */
 
  cs_real_3_t   *dijpf;          /* Vector I'J' for interior faces */
  cs_rreal_3_t  *diipb;          /* Vector II'  for border faces */
  cs_real_3_t   *dofij;          /* Vector OF   for interior faces */
  cs_rreal_3_t  *diipf;          /* Vector II'  for interior faces */
  cs_rreal_3_t  *djjpf;          /* Vector JJ'  for interior faces */
 
  cs_real_t     *i_dist;         /* Distance between the centers of the two
                                    cells sharing an interior face */
  cs_real_t     *b_dist;         /* Distance between the cell center and
                                    the center of gravity of border faces */
  cs_real_t     *c_w_dist_inv;   /* Distance between the centers of the cell
                                    and the solid face */
 
  cs_real_t     *weight;         /* Interior faces weighting factor */
 
  cs_real_t      min_vol;        /* Minimum cell volume */
  cs_real_t      max_vol;        /* Maximum cell volume */
  cs_real_t      tot_vol;        /* Total volume */
 
  cs_real_t     *corr_grad_lin_det; /* Determinant of geometrical matrix
                                       linear gradient correction */
  cs_real_33_t  *corr_grad_lin;     /* Geometrical matrix
                                       linear gradient correction */
 
  int          *b_sym_flag;         /* Symmetry flag for boundary faces */
  int           has_disable_flag;   /* Is the cell disabled?
                                       0: unactivated
                                       1: activated */
  int          *c_disable_flag;     /* Is the cell disabled?
                                       used for fluid solid and porous models */
  unsigned     *bad_cell_flag;      /* Flag (mask) for bad cells detected */
 
} cs_mesh_quantities_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/* Pointers to mesh quantities structure associated to the main mesh */
extern cs_mesh_quantities_t  *cs_glob_mesh_quantities_g;
extern cs_mesh_quantities_t  *cs_glob_mesh_quantities;
 
/* Flag (mask) to activate bad cells correction */
extern unsigned cs_glob_mesh_quantities_flag;
 
/*=============================================================================
 * Templated inline functions
 *============================================================================*/
 
END_C_DECLS
 
#if defined(__cplusplus)
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
CS_F_HOST_DEVICE inline cs_real_t
cs_mq_cell_vol_inv(cs_lnum_t         c_id,
                   const int        *c_disable_flag,
                   const cs_real_t   c_vol[])
{
  cs_real_t dvol;
 
  if (c_disable_flag == nullptr)
    dvol = 1. / c_vol[c_id];
  else if (c_disable_flag[c_id] == 0)
    dvol = 1. / c_vol[c_id];
  else
    dvol = 0.;
 
  return dvol;
}
 
#endif // defined(__cplusplus)
 
BEGIN_C_DECLS
 
/*=============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline int
cs_mesh_quantities_cell_is_active(const cs_mesh_quantities_t  *mq,
                                  cs_lnum_t                    cell_id)
{
  return (1 - (mq->has_disable_flag
              *mq->c_disable_flag[mq->has_disable_flag * cell_id]));
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_mesh_quantities_cell_cen_choice(int  algo_choice);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
int
cs_mesh_quantities_face_cog_choice(int  algo_choice);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_mesh_quantities_t *
cs_mesh_quantities_create(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_mesh_quantities_t *
cs_mesh_quantities_destroy(cs_mesh_quantities_t  *mq);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_free_all(cs_mesh_quantities_t  *mq);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_compute_preprocess(const cs_mesh_t       *m,
                                      cs_mesh_quantities_t  *mq);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_compute(const cs_mesh_t       *m,
                           cs_mesh_quantities_t  *mq);
 
/*----------------------------------------------------------------------------
 * Compute the total, min, and max volumes of cells
 *
 * parameters:
 *   mesh            <-- pointer to mesh structure
 *   mesh_quantities <-> pointer to a mesh quantities structure
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_vol_reductions(const cs_mesh_t       *mesh,
                                  cs_mesh_quantities_t  *mesh_quantities);
 
/*----------------------------------------------------------------------------
 * Compute fluid section mesh quantities at the initial step
 *
 * parameters:
 *   mesh            <-- pointer to a cs_mesh_t structure
 *   mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_init_fluid_sections(const cs_mesh_t       *mesh,
                            cs_mesh_quantities_t  *mesh_quantities);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_solid_compute(const cs_mesh_t       *m,
                                 cs_real_3_t           *cen_points,
                                 cs_mesh_quantities_t  *mq);
 
/*----------------------------------------------------------------------------
 * Compute mesh quantities
 *
 * parameters:
 *   mesh            <-- pointer to a cs_mesh_t structure
 *   mesh_quantities <-> pointer to a cs_mesh_quantities_t structure
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_sup_vectors(const cs_mesh_t       *mesh,
                               cs_mesh_quantities_t  *mesh_quantities);
 
/*----------------------------------------------------------------------------
 * Compute internal and border face normal.
 *
 * parameters:
 *   mesh            <-- pointer to a cs_mesh_t structure
 *   p_i_face_normal <-> pointer to the internal face normal array
 *   p_b_face_normal <-> pointer to the border face normal array
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_face_normal(const cs_mesh_t   *mesh,
                               cs_real_t         *p_i_face_normal[],
                               cs_real_t         *p_b_face_normal[]);
 
/*----------------------------------------------------------------------------
 * Compute center of gravity and surface normal associated to a set of faces
 *
 * parameters:
 *   n_faces         <--  number of faces
 *   vtx_coord       <--  vertex coordinates
 *   face_vtx_idx    <--  "face -> vertices" connectivity index
 *   face_vtx        <--  "face -> vertices" connectivity
 *   face_cog        -->  coordinates of the center of gravity of the faces
 *   face_normal     -->  face surface normals
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_compute_face_cog_sn(cs_lnum_t        n_faces,
                                       const cs_real_t  vtx_coord[][3],
                                       const cs_lnum_t  face_vtx_idx[],
                                       const cs_lnum_t  face_vtx[],
                                       cs_real_t        face_cog[][3],
                                       cs_real_t        face_normal[][3]);
 
/*----------------------------------------------------------------------------
 * Compute center of gravity and unit normal associated to a set of faces
 *
 * parameters:
 *   n_faces         <--  number of faces
 *   vtx_coord       <--  vertex coordinates
 *   face_vtx_idx    <--  "face -> vertices" connectivity index
 *   face_vtx        <--  "face -> vertices" connectivity
 *   face_cog        -->  coordinates of the center of gravity of the faces
 *   face_u_normal   -->  face unit normals
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_compute_face_cog_un(cs_lnum_t        n_faces,
                                       const cs_real_t  vtx_coord[][3],
                                       const cs_lnum_t  face_vtx_idx[],
                                       const cs_lnum_t  face_vtx[],
                                       cs_real_t        face_cog[][3],
                                       cs_nreal_t       face_u_normal[][3]);
 
/*----------------------------------------------------------------------------
 * Compute border face centers and normals.
 *
 * Deprecated: use cs_mesh_quantities_compute_face_cog_sn or
 * cs_mesh_quantities_compute_face_cog_un instead.
 *
 * The corresponding arrays are allocated by this function, and it is the
 * caller's responsibility to free them when they are no longer needed.
 *
 * parameters:
 *   mesh            <-- pointer to a cs_mesh_t structure
 *   p_b_face_cog    <-> pointer to the border face center array
 *   p_b_face_normal <-> pointer to the border face normal array
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_b_faces(const cs_mesh_t   *mesh,
                           cs_real_t         *p_b_face_cog[],
                           cs_real_t         *p_b_face_normal[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_cell_faces_cog(const cs_mesh_t    *mesh,
                                  const cs_real_3_t   i_face_norm[],
                                  const cs_real_3_t   i_face_cog[],
                                  const cs_real_3_t   b_face_norm[],
                                  const cs_real_3_t   b_face_cog[],
                                  cs_real_3_t         cell_cen[]);
 
/*----------------------------------------------------------------------------
 * Compute cell volumes.
 *
 * The corresponding array is allocated by this function, and it is the
 * caller's responsability to free it when they are no longer needed.
 *
 * parameters:
 *   mesh     <-- pointer to a cs_mesh_t structure
 *
 * return:
 *   pointer to newly allocated cell volumes array
 *----------------------------------------------------------------------------*/
 
cs_real_t *
cs_mesh_quantities_cell_volume(const cs_mesh_t  *mesh);
 
/*----------------------------------------------------------------------------
 * Check that no negative volumes are present, and exit on error otherwise.
 *
 * parameters:
 *   mesh            <-- pointer to mesh structure
 *   mesh_quantities <-- pointer to mesh quantities structure
 *   allow_error     <-- 1 if errors are allowed, 0 otherwise
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_check_vol(const cs_mesh_t             *mesh,
                             const cs_mesh_quantities_t  *mesh_quantities,
                             int                          allow_error);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_real_6_t *
cs_mesh_quantities_cell_extents(const cs_mesh_t  *m,
                                cs_real_t         tolerance);
 
/*----------------------------------------------------------------------------
 * Return the number of times mesh quantities have been computed.
 *
 * returns:
 *   number of times mesh quantities have been computed
 *----------------------------------------------------------------------------*/
 
int
cs_mesh_quantities_compute_count(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_b_thickness_v(const cs_mesh_t             *m,
                                 const cs_mesh_quantities_t  *mq,
                                 int                          n_passes,
                                 cs_real_t                    b_thickness[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_b_thickness_f(const cs_mesh_t             *m,
                                 const cs_mesh_quantities_t  *mq,
                                 int                          n_passes,
                                 cs_real_t                    b_thickness[]);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_log_setup(void);
 
/*----------------------------------------------------------------------------
 * Dump a cs_mesh_quantities_t structure
 *
 * parameters:
 *   mesh            <-- pointer to a cs_mesh_t structure
 *   mesh_quantities <-- pointer to a cs_mesh_quantities_t structure
 *----------------------------------------------------------------------------*/
 
void
cs_mesh_quantities_dump(const cs_mesh_t             *mesh,
                        const cs_mesh_quantities_t  *mesh_quantities);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* CS_MESH_QUANTITIES_H */