cs_mesh_adjacencies.h

Go to the documentation of this file.

#ifndef __CS_MESH_ADJACENCIES_H__
#define __CS_MESH_ADJACENCIES_H__
 
/*============================================================================
 * Additional mesh adjacencies.
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2024 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_base.h"
#include "cs_base_accel.h"
#include "cs_halo.h"
#include "cs_mesh.h"
 
/*----------------------------------------------------------------------------*/
 
BEGIN_C_DECLS
 
/*=============================================================================
 * Macro definitions
 *============================================================================*/
 
#define  CS_ADJACENCY_SHARED    (1 << 0)
#define  CS_ADJACENCY_STRIDE    (1 << 1)
#define  CS_ADJACENCY_SIGNED    (1 << 2)
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
typedef struct {
 
  cs_flag_t    flag;    
  int          stride;  
  cs_lnum_t    n_elts;
  cs_lnum_t   *idx;     
  cs_lnum_t   *ids;     
  short int   *sgn;     
} cs_adjacency_t;
 
typedef struct {
 
  /* metadata */
 
  bool        single_faces_to_cells;   
  /* cells -> cells connectivity (standard) */
 
  cs_lnum_t  *cell_cells_idx;          
  cs_lnum_t  *cell_cells;              
  /* cells -> cells connectivity (extended) */
 
  const cs_lnum_t  *cell_cells_e_idx;  
  const cs_lnum_t  *cell_cells_e;      
  /* cells->interior faces connectivity
     (same index as cells->cells connectivity) */
 
  cs_lnum_t  *cell_i_faces;            
  short int  *cell_i_faces_sgn;        
  /* cells -> boundary faces connectivity */
 
  cs_lnum_t        *cell_b_faces_idx;  
  cs_lnum_t        *cell_b_faces;      
  /* cells -> hidden boundary faces connectivity, if present;
     "hidden" boundary faces are those whose ids are in the meshe's
     ] n_b_faces, n_b_faces_all ] range */
 
  cs_lnum_t        *cell_hb_faces_idx;  
  cs_lnum_t        *cell_hb_faces;      
  /* cells -> faces connectivity */
 
  const cs_adjacency_t  *c2f;          
  cs_adjacency_t        *_c2f;         
  /* cells -> vertices connectivity */
 
  const cs_adjacency_t  *c2v;          
  cs_adjacency_t        *_c2v;         
} cs_mesh_adjacencies_t;
 
/*============================================================================
 *  Global variables
 *============================================================================*/
 
/* Read-only pointer to global mesh additional adjacencies structure */
 
extern const cs_mesh_adjacencies_t  *cs_glob_mesh_adjacencies;
 
/*=============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_mesh_adjacencies_t *
cs_mesh_adjacencies_get_global(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_adjacencies_initialize(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_adjacencies_finalize(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_adjacencies_update_mesh(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_adjacencies_update_cell_cells_e(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_adjacencies_update_cell_i_faces(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_mesh_adjacencies_update_device(cs_alloc_mode_t  alloc_mode);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const cs_adjacency_t  *
cs_mesh_adjacencies_cell_faces(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
const cs_adjacency_t  *
cs_mesh_adjacencies_cell_vertices(void);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_adjacency_create(cs_flag_t    flag,
                    int          stride,
                    cs_lnum_t    n_elts);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_adjacency_create_from_s_arrays(cs_lnum_t    n_elts,
                                  int          stride,
                                  cs_lnum_t   *ids,
                                  short int   *sgn);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_adjacency_create_from_i_arrays(cs_lnum_t     n_elts,
                                  cs_lnum_t    *idx,
                                  cs_lnum_t    *ids,
                                  short int    *sgn);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_adjacency_destroy(cs_adjacency_t   **p_adj);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_adjacency_compose(int                      n_c_elts,
                     const cs_adjacency_t    *a2b,
                     const cs_adjacency_t    *b2c);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *cs_adjacency_concatenate(const cs_adjacency_t *a2b_1,
                                         const cs_adjacency_t *a2b_2);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *cs_adjacency_difference(const cs_adjacency_t *a2b_1,
                                        const cs_adjacency_t *a2b_2);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_adjacency_transpose(int                     n_b_elts,
                       const cs_adjacency_t   *a2b);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_adjacency_sort(cs_adjacency_t   *adj);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_adjacency_remove_self_entries(cs_adjacency_t   *adj);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_adjacency_dump(const char           *name,
                  FILE                 *_f,
                  cs_adjacency_t       *adj);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_mesh_adjacency_c2f(const cs_mesh_t  *m,
                      int               boundary_order);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_mesh_adjacency_c2f_lower(const cs_mesh_t  *m,
                            int               boundary_order);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_mesh_adjacency_c2f_boundary(const cs_mesh_t  *m);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_adjacency_t *
cs_mesh_adjacency_v2v(const cs_mesh_t  *m);
 
/*----------------------------------------------------------------------------*/
 
END_C_DECLS
 
#endif /* __CS_MESH_ADJACENCIES__ */