My Project
programmer's documentation
Typedefs | Functions
cs_cdo_diffusion.h File Reference
#include "cs_cdo_bc.h"
#include "cs_cdo_connect.h"
#include "cs_cdo_local.h"
#include "cs_cdo_quantities.h"
#include "cs_equation_param.h"
#include "cs_hodge.h"
#include "cs_param.h"
Include dependency graph for cs_cdo_diffusion.h:

Go to the source code of this file.

Typedefs

typedef void() cs_cdo_diffusion_cw_flux_t(const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flx)
 Cellwise computation of the diffusive flux. More...
 

Functions

void cs_cdo_diffusion_pena_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement by a penalization technique with a huge value. More...
 
void cs_cdo_diffusion_pena_block_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement by a penalization technique with a huge value. Case of a cellwise system defined by block. More...
 
void cs_cdo_diffusion_alge_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by keeping the DoFs related to Dirichlet BCs in the algebraic system (i.e. a weak enforcement) The corresponding DoFs are algebraically "removed" of the system. More...
 
void cs_cdo_diffusion_alge_block_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by keeping the DoFs related to Dirichlet BCs in the algebraic system (i.e. a weak enforcement) The corresponding DoFs are algebraically "removed" of the system Block version. More...
 
void cs_cdo_diffusion_sfb_weak_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of scalar-valued CDO Face-based schemes. More...
 
void cs_cdo_diffusion_vfb_weak_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of vector-valued CDO Face-based schemes The idea is to compute the scalar version and dispatch it three times, one for each Cartesian components. More...
 
void cs_cdo_diffusion_sfb_wsym_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment - Face-based version Case of scalar-valued CDO Face-based schemes. More...
 
void cs_cdo_diffusion_vfb_wsym_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of vector-valued CDO Face-based schemes The idea is to compute the scalar version and dispatch it three times, one for each Cartesian components. More...
 
void cs_cdo_diffusion_vfb_wsym_sliding (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account sliding BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of vector-valued CDO Face-based schemes. More...
 
void cs_cdo_diffusion_svb_cost_robin (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Robin BCs. Case of scalar-valued CDO-Vb schemes with a CO+ST algorithm. More...
 
void cs_cdo_diffusion_svb_wbs_robin (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Robin BCs. Case of scalar-valued CDO-Vb schemes with a WBS algorithm. More...
 
void cs_cdo_diffusion_svb_cost_generic (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account generic BCs by a weak enforcement using Nitsche technique. According to the settings one can apply Neumann BCs if alpha = 0, Dirichlet BCs if alpha >> 1 or Robin BCs Case of scalar-valued CDO-Vb schemes with a CO+ST algorithm. More...
 
void cs_cdo_diffusion_svb_cost_weak_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of CDO-Vb schemes with a CO+ST algorithm. More...
 
void cs_cdo_diffusion_vvb_cost_weak_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. A Dirichlet is set for the three components of the vector. Case of vector-valued CDO-Vb schemes with a CO+ST algorithm. More...
 
void cs_cdo_diffusion_vvb_cost_sliding (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account a sliding BCs. Case of vector-valued CDO-Vb schemes with a CO+ST algorithm. More...
 
void cs_cdo_diffusion_svb_cost_wsym_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of CDO-Vb schemes with a CO+ST algorithm. More...
 
void cs_cdo_diffusion_svb_wbs_weak_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of CDO-Vb schemes with a WBS algorithm. More...
 
void cs_cdo_diffusion_svb_wbs_wsym_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of CDO-Vb schemes with a WBS algorithm. More...
 
void cs_cdo_diffusion_vcb_weak_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of CDO-VCb schemes with a WBS algorithm. More...
 
void cs_cdo_diffusion_vcb_wsym_dirichlet (const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, cs_face_mesh_t *fm, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
 Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of CDO-VCb schemes with a WBS algorithm. More...
 
void cs_cdo_diffusion_svb_cost_get_dfbyc_flux (const cs_cell_mesh_t *cm, const double *pot, cs_cell_builder_t *cb, double *flx)
 Compute the diffusive flux across dual faces for a given cell The discrete Hodge operator has been previously computed using a COST algorithm. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot) More...
 
void cs_cdo_diffusion_svb_cost_get_cell_flux (const cs_cell_mesh_t *cm, const double *pot, cs_cell_builder_t *cb, double *flx)
 Compute the constant approximation of the diffusive flux inside a (primal) cell. Use the CO+ST algo. for computing the discrete Hodge op. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot) More...
 
void cs_cdo_diffusion_svb_cost_vbyf_flux (short int f, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flux)
 Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices. CO+ST algorithm is used for reconstructing the normal flux from the degrees of freedom. More...
 
void cs_cdo_diffusion_wbs_get_dfbyc_flux (const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flx)
 Compute the diffusive flux across dual faces for a given cell Use the WBS algo. for approximating the gradient The computation takes into account a subdivision into tetrahedra of the current cell based on p_{ef,c}. More...
 
void cs_cdo_diffusion_wbs_get_cell_flux (const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flx)
 Compute the diffusive flux inside a given primal cell Use the WBS algo. for approximating the gradient The computation takes into account a subdivision into tetrahedra of the current cell based on p_{ef,c}. More...
 
void cs_cdo_diffusion_wbs_vbyf_flux (short int f, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flux)
 Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices (and at cell center). WBS algorithm is used for reconstructing the normal flux from the degrees of freedom. More...
 
double cs_cdo_diffusion_wbs_face_flux (const cs_face_mesh_t *fm, const cs_real_t pty_tens[3][3], const double *p_v, const double p_f, const double p_c, cs_cell_builder_t *cb)
 Compute the diffusive flux across a face (based on a subdivision into tetrahedra of the volume p_{f,c}) More...
 
void cs_cdo_diffusion_sfb_cost_flux (short int f, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flux)
 Compute the normal diffusive flux for a face assuming only the knowledge of the potential at faces and cell. CO+ST algorithm is used for reconstructing the normal flux from the degrees of freedom. More...
 
void cs_cdovb_diffusion_p0_face_flux (const short int f, const cs_cell_mesh_t *cm, const cs_real_3_t *diff_tensor, const cs_real_t *pot_values, cs_real_t *fluxes)
 Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices. COST algorithm is used for reconstructing a piecewise constant gradient from the degrees of freedom. More...
 

Typedef Documentation

◆ cs_cdo_diffusion_cw_flux_t

typedef void() cs_cdo_diffusion_cw_flux_t(const cs_cell_mesh_t *cm, const cs_real_t *pot, cs_cell_builder_t *cb, cs_real_t *flx)

Cellwise computation of the diffusive flux.

Parameters
[in]cmpointer to a cs_face_mesh_t structure
[in]potvalues of the potential fields at vertices
[in,out]cbauxiliary structure for computing the flux
[in,out]flxflux across dual faces inside this cell

Function Documentation

◆ cs_cdo_diffusion_alge_block_dirichlet()

void cs_cdo_diffusion_alge_block_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by keeping the DoFs related to Dirichlet BCs in the algebraic system (i.e. a weak enforcement) The corresponding DoFs are algebraically "removed" of the system Block version.

| | | | | | | | | | | Aii | Aid | | Aii | 0 | |bi| |bi-Aid.xd | |---------—| --> |---------—| and |–| --> |-------—| | | | | | | | | | | | Adi | Add | | 0 | Id | |bd| | xd |

where xd is the value of the Dirichlet BC

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cell-wise system

◆ cs_cdo_diffusion_alge_dirichlet()

void cs_cdo_diffusion_alge_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by keeping the DoFs related to Dirichlet BCs in the algebraic system (i.e. a weak enforcement) The corresponding DoFs are algebraically "removed" of the system.

| | | | | | | | | | | Aii | Aid | | Aii | 0 | |bi| |bi-Aid.bd | |---------—| --> |---------—| and |–| --> |-------—| | | | | | | | | | | | Adi | Add | | 0 | Id | |bd| | xd |

where xd is the value of the Dirichlet BC

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cell-wise system

◆ cs_cdo_diffusion_pena_block_dirichlet()

void cs_cdo_diffusion_pena_block_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement by a penalization technique with a huge value. Case of a cellwise system defined by block.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cell-wise system

◆ cs_cdo_diffusion_pena_dirichlet()

void cs_cdo_diffusion_pena_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement by a penalization technique with a huge value.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cell-wise system

◆ cs_cdo_diffusion_sfb_cost_flux()

void cs_cdo_diffusion_sfb_cost_flux ( short int  f,
const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
const cs_real_t pot,
cs_cell_builder_t cb,
cs_real_t flux 
)

Compute the normal diffusive flux for a face assuming only the knowledge of the potential at faces and cell. CO+ST algorithm is used for reconstructing the normal flux from the degrees of freedom.

Parameters
[in]fface id in the cell mesh
[in]eqppointer to a cs_equation_param_t structure
[in]cmpointer to a cs_cell_mesh_t structure
[in]potarray of values of the potential (all the mesh)
[in,out]cbauxiliary structure dedicated to diffusion
[out]fluxpointer to the value to set

◆ cs_cdo_diffusion_sfb_weak_dirichlet()

void cs_cdo_diffusion_sfb_weak_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of scalar-valued CDO Face-based schemes.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_sfb_wsym_dirichlet()

void cs_cdo_diffusion_sfb_wsym_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment - Face-based version Case of scalar-valued CDO Face-based schemes.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment - Face-based version Case of scalar-valued CDO Face-based schemes.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_cost_generic()

void cs_cdo_diffusion_svb_cost_generic ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account generic BCs by a weak enforcement using Nitsche technique. According to the settings one can apply Neumann BCs if alpha = 0, Dirichlet BCs if alpha >> 1 or Robin BCs Case of scalar-valued CDO-Vb schemes with a CO+ST algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_cost_get_cell_flux()

void cs_cdo_diffusion_svb_cost_get_cell_flux ( const cs_cell_mesh_t cm,
const double *  pot,
cs_cell_builder_t cb,
double *  flx 
)

Compute the constant approximation of the diffusive flux inside a (primal) cell. Use the CO+ST algo. for computing the discrete Hodge op. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot)

Parameters
[in]cmpointer to a cs_cell_mesh_t structure
[in]potvalues of the potential fields at specific locations
[in,out]cbauxiliary structure for computing the flux
[in,out]flxvalues of the flux inside the cell

Compute the constant approximation of the diffusive flux inside a (primal) cell. Use the CO+ST algo. for computing the discrete Hodge op. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot)

Parameters
[in]cmpointer to a cs_cell_mesh_t structure
[in]potvalues of the potential fields at specific locations
[in,out]cbauxiliary structure for computing the flux
[in,out]flxvalues of the flux inside the cell

◆ cs_cdo_diffusion_svb_cost_get_dfbyc_flux()

void cs_cdo_diffusion_svb_cost_get_dfbyc_flux ( const cs_cell_mesh_t cm,
const double *  pot,
cs_cell_builder_t cb,
double *  flx 
)

Compute the diffusive flux across dual faces for a given cell The discrete Hodge operator has been previously computed using a COST algorithm. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot)

Parameters
[in]cmpointer to a cs_cell_mesh_t structure
[in]potvalues of the potential fields at specific locations
[in,out]cbauxiliary structure for computing the flux
[in,out]flxvalues of the flux across specific entities

◆ cs_cdo_diffusion_svb_cost_robin()

void cs_cdo_diffusion_svb_cost_robin ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Robin BCs. Case of scalar-valued CDO-Vb schemes with a CO+ST algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_cost_vbyf_flux()

void cs_cdo_diffusion_svb_cost_vbyf_flux ( short int  f,
const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
const cs_real_t pot,
cs_cell_builder_t cb,
cs_real_t flux 
)

Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices. CO+ST algorithm is used for reconstructing the normal flux from the degrees of freedom.

Parameters
[in]fface id in the cell mesh
[in]eqppointer to a cs_equation_param_t structure
[in]cmpointer to a cs_cell_mesh_t structure
[in]potarray of values of the potential (all the mesh)
[in,out]cbauxiliary structure dedicated to diffusion
[in,out]vf_fluxarray of values to set (size: n_vc)

◆ cs_cdo_diffusion_svb_cost_weak_dirichlet()

void cs_cdo_diffusion_svb_cost_weak_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of CDO-Vb schemes with a CO+ST algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_cost_wsym_dirichlet()

void cs_cdo_diffusion_svb_cost_wsym_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of CDO-Vb schemes with a CO+ST algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_wbs_robin()

void cs_cdo_diffusion_svb_wbs_robin ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Robin BCs. Case of scalar-valued CDO-Vb schemes with a WBS algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_wbs_weak_dirichlet()

void cs_cdo_diffusion_svb_wbs_weak_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of CDO-Vb schemes with a WBS algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_svb_wbs_wsym_dirichlet()

void cs_cdo_diffusion_svb_wbs_wsym_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of CDO-Vb schemes with a WBS algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vcb_weak_dirichlet()

void cs_cdo_diffusion_vcb_weak_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of CDO-VCb schemes with a WBS algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vcb_wsym_dirichlet()

void cs_cdo_diffusion_vcb_wsym_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of CDO-VCb schemes with a WBS algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vfb_weak_dirichlet()

void cs_cdo_diffusion_vfb_weak_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. Case of vector-valued CDO Face-based schemes The idea is to compute the scalar version and dispatch it three times, one for each Cartesian components.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vfb_wsym_dirichlet()

void cs_cdo_diffusion_vfb_wsym_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of vector-valued CDO Face-based schemes The idea is to compute the scalar version and dispatch it three times, one for each Cartesian components.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vfb_wsym_sliding()

void cs_cdo_diffusion_vfb_wsym_sliding ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account sliding BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. Case of vector-valued CDO Face-based schemes.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vvb_cost_sliding()

void cs_cdo_diffusion_vvb_cost_sliding ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account a sliding BCs. Case of vector-valued CDO-Vb schemes with a CO+ST algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_vvb_cost_weak_dirichlet()

void cs_cdo_diffusion_vvb_cost_weak_dirichlet ( const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
cs_face_mesh_t fm,
cs_cell_builder_t cb,
cs_cell_sys_t csys 
)

Take into account Dirichlet BCs by a weak enforcement using Nitsche technique. A Dirichlet is set for the three components of the vector. Case of vector-valued CDO-Vb schemes with a CO+ST algorithm.

Parameters
[in]eqppointer to a cs_equation_param_t struct.
[in]cmpointer to a cs_cell_mesh_t structure
[in,out]fmpointer to a cs_face_mesh_t structure
[in,out]cbpointer to a cs_cell_builder_t structure
[in,out]csysstructure storing the cellwise system

◆ cs_cdo_diffusion_wbs_face_flux()

double cs_cdo_diffusion_wbs_face_flux ( const cs_face_mesh_t fm,
const cs_real_t  pty_tens[3][3],
const double *  p_v,
const double  p_f,
const double  p_c,
cs_cell_builder_t cb 
)

Compute the diffusive flux across a face (based on a subdivision into tetrahedra of the volume p_{f,c})

Parameters
[in]fmpointer to a cs_face_mesh_t structure
[in]pty_tens3x3 matrix related to the diffusion property
[in]p_varray of values attached to face vertices
[in]p_fvalue attached to the face
[in]p_cvalue attached to the cell
[in,out]cbauxiliary structure dedicated to diffusion
Returns
the value of the diffusive flux across the current face

◆ cs_cdo_diffusion_wbs_get_cell_flux()

void cs_cdo_diffusion_wbs_get_cell_flux ( const cs_cell_mesh_t cm,
const cs_real_t pot,
cs_cell_builder_t cb,
cs_real_t flx 
)

Compute the diffusive flux inside a given primal cell Use the WBS algo. for approximating the gradient The computation takes into account a subdivision into tetrahedra of the current cell based on p_{ef,c}.

Parameters
[in]cmpointer to a cs_cell_mesh_t structure
[in]potvalues of the potential fields at vertices
[in,out]cbauxiliary structure for computing the flux
[in,out]flxflux vector inside this cell

◆ cs_cdo_diffusion_wbs_get_dfbyc_flux()

void cs_cdo_diffusion_wbs_get_dfbyc_flux ( const cs_cell_mesh_t cm,
const cs_real_t pot,
cs_cell_builder_t cb,
cs_real_t flx 
)

Compute the diffusive flux across dual faces for a given cell Use the WBS algo. for approximating the gradient The computation takes into account a subdivision into tetrahedra of the current cell based on p_{ef,c}.

Parameters
[in]cmpointer to a cs_cell_mesh_t structure
[in]potvalues of the potential fields at vertices
[in,out]cbauxiliary structure for computing the flux
[in,out]flxflux across dual faces inside this cell

◆ cs_cdo_diffusion_wbs_vbyf_flux()

void cs_cdo_diffusion_wbs_vbyf_flux ( short int  f,
const cs_equation_param_t eqp,
const cs_cell_mesh_t cm,
const cs_real_t pot,
cs_cell_builder_t cb,
cs_real_t flux 
)

Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices (and at cell center). WBS algorithm is used for reconstructing the normal flux from the degrees of freedom.

Parameters
[in]fface id in the cell mesh
[in]eqppointer to a cs_equation_param_t structure
[in]cmpointer to a cs_cell_mesh_t structure
[in]potarray of values of the potential (all the mesh)
[in,out]cbauxiliary structure dedicated to diffusion
[in,out]vf_fluxarray of values to set (size: n_vc)

◆ cs_cdovb_diffusion_p0_face_flux()

void cs_cdovb_diffusion_p0_face_flux ( const short int  f,
const cs_cell_mesh_t cm,
const cs_real_3_t diff_tensor,
const cs_real_t pot_values,
cs_real_t fluxes 
)

Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices. COST algorithm is used for reconstructing a piecewise constant gradient from the degrees of freedom.

Parameters
[in]fface id in the cell mesh
[in]cmpointer to a cs_cell_mesh_t structure
[in]diff_tensorproperty tensor times the face normal
[in]pot_valuesarray of values of the potential (all the mesh)
[in,out]fluxesvalues of the fluxes related to each vertex