cs_cdo_local.h

Go to the documentation of this file.

#ifndef __CS_CDO_LOCAL_H__
#define __CS_CDO_LOCAL_H__

/*============================================================================
 * Routines to handle low-level routines related to CDO local quantities:
 * - local matrices (stored in dense format),
 * - local quantities related to a cell.
 *============================================================================*/

/*
  This file is part of Code_Saturne, a general-purpose CFD tool.

  Copyright (C) 1998-2018 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_cdo_connect.h"
#include "cs_cdo_quantities.h"
#include "cs_flag.h"
#include "cs_param_cdo.h"
#include "cs_sdm.h"

/*----------------------------------------------------------------------------*/

BEGIN_C_DECLS

/*============================================================================
 * Macro definitions
 *============================================================================*/

/* According to the flag which are set, different quantities or connectivities
   are built on-the-fly and stored in a local cache structure (cell/base) */

#define CS_CDO_LOCAL_PV   (1 <<  0) //     1: local info. for vertices
#define CS_CDO_LOCAL_PVQ  (1 <<  1) //     2: local quant. on vertices
#define CS_CDO_LOCAL_PE   (1 <<  2) //     4: local info. for edges
#define CS_CDO_LOCAL_PEQ  (1 <<  3) //     8: local quant. on edges
#define CS_CDO_LOCAL_DFQ  (1 <<  4) //    16: local quant. on dual faces
#define CS_CDO_LOCAL_PF   (1 <<  5) //    32: local info. for faces
#define CS_CDO_LOCAL_PFQ  (1 <<  6) //    64: local quant. on faces
#define CS_CDO_LOCAL_DEQ  (1 <<  7) //   128: local quant. on dual edges
#define CS_CDO_LOCAL_EV   (1 <<  8) //   256: local e2v connectivity
#define CS_CDO_LOCAL_FE   (1 <<  9) //   512: local f2e connectivity
#define CS_CDO_LOCAL_FEQ  (1 << 10) //  1024: local f2e quantities
#define CS_CDO_LOCAL_EF   (1 << 11) //  2048: local e2f connectivity
#define CS_CDO_LOCAL_EFQ  (1 << 12) //  4096: local e2f quantities
#define CS_CDO_LOCAL_HFQ  (1 << 13) //  8192: local quant. on face pyramids
#define CS_CDO_LOCAL_DIAM (1 << 14) // 16384: local diameters on faces/cell

/*============================================================================
 * Type definitions
 *============================================================================*/

typedef struct {

  /* Specific members for the weakly enforcement of Dirichlet BCs (diffusion) */
  double     eig_ratio; 
  double     eig_max;   
  /* Store the cellwise value for the diffusion, time and reaction properties */
  cs_real_33_t  dpty_mat; 
  double        dpty_val; 
  double        tpty_val; 
  double        rpty_vals[CS_CDO_N_MAX_REACTIONS];
  double        rpty_val; 
  /* Advection-related values */
  double       *adv_fluxes;

  /* Temporary buffers (erase and updated several times during the system
     build */
  short int    *ids;     
  double       *values;  
  cs_real_3_t  *vectors; 
  /* Structures used to build specific terms composing the algebraic system */
  cs_sdm_t     *hdg;   
  cs_sdm_t     *loc;   
  cs_sdm_t     *aux;   
} cs_cell_builder_t;

typedef struct {

  cs_lnum_t   c_id;       
  cs_flag_t   cell_flag;  
  int         n_dofs;   
  cs_lnum_t  *dof_ids;  
  cs_flag_t  *dof_flag; 
  cs_sdm_t   *mat;      
  double     *rhs;      
  double     *source;   
  double     *val_n;    
  /* Boundary conditions for the local system */
  cs_lnum_t   face_shift;  
  short int   n_bc_faces;  
  short int  *_f_ids;      
  cs_lnum_t  *bf_ids;      
  cs_flag_t  *bf_flag;     
  /* Dirichlet BCs */
  bool        has_dirichlet; 
  double     *dir_values;    
  /* Neumann BCs */
  bool        has_nhmg_neumann; 
  double     *neu_values;       
  /* Robin BCs */
  bool        has_robin;
  double     *rob_values;    
  /* Internal enforcement of DoFs */
  bool        has_internal_enforcement;  
  cs_lnum_t  *intern_forced_ids;         
} cs_cell_sys_t;

typedef struct {

  cs_flag_t      flag;    
  fvm_element_t  type;    
  /* Sizes used to allocate buffers */
  short int      n_max_vbyc;
  short int      n_max_ebyc;
  short int      n_max_fbyc;

  /* Cell information */
  cs_lnum_t      c_id;    
  cs_real_3_t    xc;      
  double         vol_c;   
  double         diam_c;  
  /* Vertex information */
  short int    n_vc;  
  cs_lnum_t   *v_ids; 
  double      *xv;    
  double      *wvc;   
  /* Edge information */
  short int    n_ec;  
  cs_lnum_t   *e_ids; 
  cs_quant_t  *edge;  
  cs_nvec3_t  *dface; 
  /* Face information */
  short int    n_fc;    
  cs_lnum_t   *f_ids;   
  short int   *f_sgn;   
  double      *f_diam;  
  double      *hfc;     
  double      *pfc;     
  cs_quant_t  *face;    
  cs_nvec3_t  *dedge;   
  /* Local e2v connectivity: size 2*n_ec (allocated to 2*n_max_ebyc) */
  short int   *e2v_ids; 
  short int   *e2v_sgn; 
  /* Local f2e connectivity: size = 2*n_max_ebyc */
  short int   *f2e_idx; 
  short int   *f2e_ids; 
  double      *tef;     
  /* Local e2f connectivity: size 2*n_ec (allocated to 2*n_max_ebyc) */
  short int   *e2f_ids; 
  cs_nvec3_t  *sefc;    
} cs_cell_mesh_t;

typedef struct {

  short int    n_max_vbyf; 
  cs_lnum_t    c_id;    
  cs_real_3_t  xc;      
  /* Face information */
  cs_lnum_t    f_id;   
  short int    f_sgn;  
  cs_quant_t   face;   
  cs_nvec3_t   dedge;  
  /* Vertex information */
  short int    n_vf;    
  cs_lnum_t   *v_ids;   
  double      *xv;      
  double      *wvf;     
  /* Edge information */
  short int    n_ef;    
  cs_lnum_t   *e_ids;   
  cs_quant_t  *edge;    
  double      *tef;     
  /* Local e2v connectivity: size 2*n_ec (allocated to 2*n_max_ebyf) */
  short int   *e2v_ids;  
} cs_face_mesh_t;

/*
   A cs_face_mesh_light_t structure is close to a cs_face_mesh_t structure
   There are less members to be buildt quicker.
   Such structure is always associated to a cs_cell_mesh_t structure
*/

typedef struct {

  short int    n_max_vbyf;  /* Max number of vertices belonging to a face
                               (= n_max_ebyf) */

  cs_lnum_t    c_id;    /* id of related cell in the mesh numbering */
  short int    f;       /* id of the face in the cell mesh numbering */

  /* Vertex information */
  short int    n_vf;    /* local number of vertices on this face */
  short int   *v_ids;   /* vertex ids in the cellwise numbering */
  double      *wvf;     /* weights related to each vertex */

  /* Edge information */
  short int    n_ef;    /* local number of edges on this face (= n_vf) */
  short int   *e_ids;   /* edge ids in the cellwise numbering */
  double      *tef;     /* area of the triangle of base e and apex xf */

} cs_face_mesh_light_t;

/*============================================================================
 *  Global variables
 *============================================================================*/

extern cs_cell_mesh_t        **cs_cdo_local_cell_meshes;
extern cs_face_mesh_t        **cs_cdo_local_face_meshes;
extern cs_face_mesh_light_t  **cs_cdo_local_face_meshes_light;

/*============================================================================
 * Public function prototypes
 *============================================================================*/

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cdo_local_initialize(const cs_cdo_connect_t     *connect);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cdo_local_finalize(void);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_cell_sys_t *
cs_cell_sys_create(int          n_max_dofbyc,
                   int          n_max_fbyc,
                   short int    n_blocks,
                   short int   *block_sizes);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_sys_reset(int              n_fbyc,
                  cs_cell_sys_t   *csys);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_sys_free(cs_cell_sys_t     **p_csys);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_sys_dump(const char              msg[],
                 const cs_cell_sys_t    *csys);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_cell_builder_t *
cs_cell_builder_create(void);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_builder_free(cs_cell_builder_t     **p_cb);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_cell_mesh_t *
cs_cell_mesh_create(const cs_cdo_connect_t   *connect);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_cell_mesh_t *
cs_cdo_local_get_cell_mesh(int    mesh_id);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_mesh_reset(cs_cell_mesh_t   *cm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_mesh_dump(const cs_cell_mesh_t     *cm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_mesh_free(cs_cell_mesh_t     **p_cm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_cell_mesh_build(cs_lnum_t                    c_id,
                   cs_flag_t                    build_flag,
                   const cs_cdo_connect_t      *connect,
                   const cs_cdo_quantities_t   *quant,
                   cs_cell_mesh_t              *cm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

static inline void
cs_cell_mesh_get_f2v(short int                    f,
                     const cs_cell_mesh_t        *cm,
                     short int                   *n_vf,
                     short int                   *v_ids)
{
  /* Reset */
  *n_vf = 0;
  for (short int v = 0; v < cm->n_vc; v++) v_ids[v] = -1;

  /* Tag vertices belonging to the current face f */
  for (short int i = cm->f2e_idx[f]; i < cm->f2e_idx[f+1]; i++) {

    const short int  shift_e = (short int)2*cm->f2e_ids[i];
    v_ids[cm->e2v_ids[shift_e]] = 1;
    v_ids[cm->e2v_ids[shift_e+1]] = 1;

  } // Loop on face edges

  for (short int v = 0; v < cm->n_vc; v++) {
    if (v_ids[v] > 0)
      v_ids[*n_vf] = v, *n_vf += 1;
  }

}

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

static inline void
cs_cell_mesh_get_next_3_vertices(const short int   *f2e_ids,
                                 const short int   *e2v_ids,
                                 short int         *v0,
                                 short int         *v1,
                                 short int         *v2)
{
  const short int e0  = f2e_ids[0];
  const short int e1  = f2e_ids[1];
  const short int tmp = e2v_ids[2*e1];

  *v0 = e2v_ids[2*e0];
  *v1 = e2v_ids[2*e0+1];
  *v2 = ((tmp != *v0) && (tmp != *v1)) ? tmp : e2v_ids[2*e1+1];
}

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_face_mesh_t *
cs_face_mesh_create(short int   n_max_vbyf);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_face_mesh_t *
cs_cdo_local_get_face_mesh(int    mesh_id);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_face_mesh_free(cs_face_mesh_t     **p_fm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_face_mesh_build(cs_lnum_t                    c_id,
                   cs_lnum_t                    f_id,
                   const cs_cdo_connect_t      *connect,
                   const cs_cdo_quantities_t   *quant,
                   cs_face_mesh_t              *fm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_face_mesh_build_from_cell_mesh(const cs_cell_mesh_t    *cm,
                                  short int                f,
                                  cs_face_mesh_t          *fm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_face_mesh_light_t *
cs_face_mesh_light_create(short int   n_max_vbyf,
                          short int   n_max_vbyc);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

cs_face_mesh_light_t *
cs_cdo_local_get_face_mesh_light(int    mesh_id);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_face_mesh_light_free(cs_face_mesh_light_t     **p_fm);

/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/

void
cs_face_mesh_light_build(const cs_cell_mesh_t    *cm,
                         short int                f,
                         cs_face_mesh_light_t    *fm);

/*----------------------------------------------------------------------------*/

END_C_DECLS

#endif /* __CS_CDO_LOCAL_H__ */