cs_reco_cw.h

Go to the documentation of this file.

#ifndef CS_RECO_CW_H
#define CS_RECO_CW_H
 
/*============================================================================
 * Functions to handle the cell-wise reconstruction of fields relying on the
 * cell mesh structure
 *============================================================================*/
 
/*
  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 "cdo/cs_cdo_local.h"
 
/*============================================================================
 * Macro definitions
 *============================================================================*/
 
/*============================================================================
 * Type definitions
 *============================================================================*/
 
/*============================================================================
 * Public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_reco_cw_stride_v2c(int                        stride,
                      const cs_cell_mesh_t      *cm,
                      const cs_real_t           *array,
                      cs_real_t                 *reco);
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
void
cs_reco_cw_stride_vbyc2c(int                        stride,
                         const cs_cell_mesh_t      *cm,
                         const cs_real_t           *array,
                         cs_real_t                 *reco);
 
/*============================================================================
 * Inline public function prototypes
 *============================================================================*/
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_reco_cw_scalar_v2f_fw(const cs_face_mesh_t    *fm,
                         const cs_real_t         *p_v)
{
  cs_real_t  p_f = 0.;
 
  if (p_v == NULL)
    return p_f;
 
  const cs_quant_t  pfq = fm->face;
 
  for (short int e = 0; e < fm->n_ef; e++)
    p_f += (p_v[fm->e2v_ids[2*e]] + p_v[fm->e2v_ids[2*e+1]]) * fm->tef[e];
  p_f *= 0.5 / pfq.meas;
 
  return p_f;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_reco_cw_scalar_v2f_loc(const short int          f,
                          const cs_cell_mesh_t    *cm,
                          const cs_real_t         *p_v)
{
  cs_real_t  p_f = 0.;
 
  if (p_v == NULL)
    return p_f;
 
  assert(cs_eflag_test(cm->flag,
                       CS_FLAG_COMP_PFQ | CS_FLAG_COMP_EV | CS_FLAG_COMP_FEQ |
                       CS_FLAG_COMP_FE));
 
  for (int ie = cm->f2e_idx[f]; ie < cm->f2e_idx[f+1]; ie++) {
    const short int  *v = cm->e2v_ids + 2*cm->f2e_ids[ie];
    p_f += (p_v[v[0]] + p_v[v[1]]) * cm->tef[ie];
  }
  p_f *= 0.5 / cm->face[f].meas;
 
  return p_f;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_reco_cw_scalar_v2c_loc(const cs_cell_mesh_t     *cm,
                          const cs_real_t          *p_v)
{
  cs_real_t  p_c = 0.;
 
  if (p_v == NULL || cm == NULL)
    return p_c;
 
  assert(cs_eflag_test(cm->flag, CS_FLAG_COMP_PVQ)); /* Sanity check */
 
  /* Reconstruct the value at the cell center */
 
  for (short int v = 0; v < cm->n_vc; v++)
    p_c += cm->wvc[v] * p_v[v];
 
  return p_c;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_reco_cw_scalar_v2c(const cs_cell_mesh_t      *cm,
                      const cs_real_t           *array)
{
  assert(cs_eflag_test(cm->flag, CS_FLAG_COMP_PVQ));
 
  cs_real_t  val_c = 0;
 
  if (array == NULL)
    return val_c;
 
  for (short int v = 0; v < cm->n_vc; v++)
    val_c += cm->wvc[v] * array[cm->v_ids[v]];
 
  return val_c;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_reco_cw_scalar_vbyc2c(const cs_cell_mesh_t      *cm,
                         const cs_real_t           *array)
{
  assert(cs_eflag_test(cm->flag, CS_FLAG_COMP_PVQ));
 
  cs_real_t  val_c = 0;
 
  if (array == NULL)
    return val_c;
 
  for (short int v = 0; v < cm->n_vc; v++)
    val_c += cm->wvc[v] * array[v];
 
  return val_c;
}
 
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
 
static inline cs_real_t
cs_reco_cw_scalar_ebyc2c(const cs_cell_mesh_t      *cm,
                         const cs_real_t           *array)
{
  assert(cs_eflag_test(cm->flag, CS_FLAG_COMP_PEC));
 
  cs_real_t  val_c = 0;
 
  if (array == NULL)
    return val_c;
 
  for (short int e = 0; e < cm->n_ec; e++)
    val_c += cm->pvol_e[e] * array[e];
  val_c /= cm->vol_c;
 
  return val_c;
}
 
#endif /* CS_RECO_CW_H */