cs_cdo_bc.h

Go to the documentation of this file.

#ifndef CS_CDO_BC_H
#define CS_CDO_BC_H
 
/*============================================================================
 * Manage the low-level structure dedicated to boundary conditions
 *============================================================================*/
 
/*
  This file is part of code_saturne, a general-purpose CFD tool.
 
  Copyright (C) 1998-2026 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 "base/cs_param_types.h"
#include "base/cs_time_step.h"
#include "cdo/cs_cdo_quantities.h"
#include "cdo/cs_xdef.h"
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
#define CS_CDO_BC_DEFAULT_DEF    -1
 
#define CS_CDO_BC_NEUMANN               (1 << 0)
 
#define CS_CDO_BC_FULL_NEUMANN          (1 << 1)
 
#define CS_CDO_BC_HMG_NEUMANN           (1 << 2)
 
#define CS_CDO_BC_DIRICHLET             (1 << 3)
 
#define CS_CDO_BC_HMG_DIRICHLET         (1 << 4)
 
#define CS_CDO_BC_ROBIN                 (1 << 5)
 
#define CS_CDO_BC_TANGENTIAL_DIRICHLET  (1 << 6)
 
#define CS_CDO_BC_WALL_PRESCRIBED       (1 << 7)
 
#define CS_CDO_BC_SYMMETRY              (1 << 8)
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/* Structure specific to store data related to the definition of boundary
 * conditions on boundary faces.
 *
 * For of scalar-valued equations, only some the classical (Dirichlet, Neumann
 * and Robin types are available. Other types of boundary conditions are
 * possible for vector-valued equations.
 */
 
typedef struct {
 
  bool         is_steady;    /* Do we need to update BC faces during the
                                computation */
  cs_lnum_t    n_b_faces;    /* Number of boundary faces */
 
  /* Type of boundary conditions associated to a face. Size: n_b_faces */
 
  cs_flag_t   *flag;
 
  /* Id of the boundary condition definition or CS_BC_DEFAULT (=-1) if this face
     is related to the default boundary condition. Size = n_b_faces */
 
  short int   *def_ids;
 
  /* List of face ids by type of boundary conditions. Homogeneous types don't
   * need to rely on a definition since it can be the default bc. Moreover, some
   * optimizations can be performed that's why they are stored separately
   */
 
  /* Dirichlet */
 
  cs_lnum_t    n_hmg_dir_faces;
  cs_lnum_t   *hmg_dir_ids;
  cs_lnum_t    n_nhmg_dir_faces;
  cs_lnum_t   *nhmg_dir_ids;
 
  /* Neumann */
 
  cs_lnum_t    n_hmg_neu_faces;
  cs_lnum_t   *hmg_neu_ids;
  cs_lnum_t    n_nhmg_neu_faces;
  cs_lnum_t   *nhmg_neu_ids;
 
  /* Robin */
 
  cs_lnum_t    n_robin_faces;
  cs_lnum_t   *robin_ids;
 
  /* Sliding wall */
 
  cs_lnum_t    n_sliding_faces;
  cs_lnum_t   *sliding_ids;
 
  /* Circulation */
 
  cs_lnum_t    n_circulation_faces;
  cs_lnum_t   *circulation_ids;
 
} cs_cdo_bc_face_t;
 
/*============================================================================
 * Global variables
 *============================================================================*/
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline void
cs_cdo_bc_get_desc(cs_flag_t   bc_flag,
                   char       *desc)
{
  if (desc == NULL)
    bft_error(__FILE__, __LINE__, 0,
              " %s: Empty desciption buffer.", __func__);
 
  switch (bc_flag) {
 
  case CS_CDO_BC_HMG_DIRICHLET:
    sprintf(desc, "%s", "Homogenous Dirichlet");
    break;
  case CS_CDO_BC_DIRICHLET:
    sprintf(desc, "%s", "Dirichlet");
    break;
  case CS_CDO_BC_SYMMETRY:
    sprintf(desc, "%s", "Sliding for vectors");
    break;
  case CS_CDO_BC_HMG_NEUMANN:
    sprintf(desc, "%s", "Homogeneous Neumann");
    break;
  case CS_CDO_BC_NEUMANN:
    sprintf(desc, "%s", "Neumann");
    break;
  case CS_CDO_BC_FULL_NEUMANN:
    sprintf(desc, "%s", "Full Neumann");
    break;
  case CS_CDO_BC_ROBIN:
    sprintf(desc, "%s", "Robin");
    break;
  case CS_CDO_BC_TANGENTIAL_DIRICHLET:
    sprintf(desc, "%s", "Dirichlet on the tangential component");
    break;
  case CS_CDO_BC_WALL_PRESCRIBED:
    sprintf(desc, "%s", "Prescribed wall with wall functions");
    break;
 
  default:
    bft_error(__FILE__, __LINE__, 0,
              "%s: Invalid case. Please contact the support.\n", __func__);
    break;
  }
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_flag_t
cs_cdo_bc_get_flag(cs_param_bc_type_t   bc_type)
{
  cs_flag_t  ret_flag;
 
  switch (bc_type) {
 
  case CS_BC_HMG_DIRICHLET:
    ret_flag = CS_CDO_BC_HMG_DIRICHLET;
    break;
  case CS_BC_DIRICHLET:
    ret_flag = CS_CDO_BC_DIRICHLET;
    break;
  case CS_BC_SYMMETRY:
    ret_flag = CS_CDO_BC_SYMMETRY;
    break;
  case CS_BC_NEUMANN:
    ret_flag = CS_CDO_BC_NEUMANN;
    break;
  case CS_BC_NEUMANN_FULL:
    ret_flag = CS_CDO_BC_FULL_NEUMANN;
    break;
  case CS_BC_HMG_NEUMANN:
    ret_flag = CS_CDO_BC_HMG_NEUMANN;
    break;
  case CS_BC_GENERALIZED_SYM:
    bft_error(__FILE__, __LINE__, 0,
              _("invalid boundary condition CS_BC_GENERALIZED_SYM for CDO"));
    ret_flag = 0;
    break;
  case CS_BC_ROBIN:
    ret_flag = CS_CDO_BC_ROBIN;
    break;
  case CS_BC_CIRCULATION:
    ret_flag = CS_CDO_BC_TANGENTIAL_DIRICHLET;
    break;
  case CS_BC_WALL_MODELLED:
    ret_flag = CS_CDO_BC_WALL_PRESCRIBED; /* TO BE CHECKED */
    break;
 
  default:
    ret_flag = 0;               /* Not handle automatically */
    break;
  }
 
  return ret_flag;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_cdo_bc_is_dirichlet(cs_flag_t    flag)
{
  if (flag & CS_CDO_BC_DIRICHLET)
    return true;
  else if (flag & CS_CDO_BC_HMG_DIRICHLET)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_cdo_bc_is_neumann(cs_flag_t    flag)
{
  if (flag & CS_CDO_BC_NEUMANN)
    return true;
  else if (flag & CS_CDO_BC_HMG_NEUMANN)
    return true;
  else if (flag & CS_CDO_BC_FULL_NEUMANN)
    return true;
 
  return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_cdo_bc_is_sliding(cs_flag_t    flag)
{
  if (flag & CS_CDO_BC_SYMMETRY)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline bool
cs_cdo_bc_is_circulation(cs_flag_t    flag)
{
  if (flag & CS_CDO_BC_DIRICHLET)
    return true;
  else if (flag & CS_CDO_BC_HMG_DIRICHLET)
    return true;
  else if (flag & CS_CDO_BC_TANGENTIAL_DIRICHLET)
    return true;
  else
    return false;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_bc_face_t *
cs_cdo_bc_face_define(cs_param_bc_type_t    default_bc,
                      bool                  is_steady,
                      int                   dim,
                      int                   n_defs,
                      cs_xdef_t           **defs,
                      cs_lnum_t             n_b_faces);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
cs_cdo_bc_face_t *
cs_cdo_bc_free(cs_cdo_bc_face_t   *face_bc);
 
#endif /* CS_CDO_BC_H */