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_cellwise_diffusion_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...
typedef void()	cs_cdo_diffusion_enforce_dir_t(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)
	Enforce the Dirichlet BCs when a diffusion term is present. This routine define an operator which reconstructs the normal diffusive flux from the knowledge of the potential at degrees of freedom. More...

Functions
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_vbcost_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_vbcost_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_vbwbs_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_vbwbs_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_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_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_vbcost_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 Use the COST algo. for computing the discrete Hodge op. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot) More...
void	cs_cdo_diffusion_vbcost_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_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_cdovb_diffusion_p0_face_flux (const cs_cell_mesh_t *cm, const cs_real_3_t *diff_tensor, const cs_real_t *pot_values, short int f, cs_real_t t_eval, 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...
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...
double	cs_cdo_diffusion_vbcost_face_flux (short int f, const cs_cell_mesh_t *cm, const cs_real_3_t *diff_tensor, const cs_real_t *pot_values, double beta, cs_cell_builder_t *cb)
	Compute the normal flux for a face assuming only the knowledge of the potential at cell vertices. COST algorithm is used for reconstructing the degrees of freedom. More...

Typedef Documentation

cs_cdo_cellwise_diffusion_flux_t

typedef void() cs_cdo_cellwise_diffusion_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]	cm	pointer to a cs_face_mesh_t structure
[in]	pot	values of the potential fields at vertices
[in,out]	cb	auxiliary structure for computing the flux
[in,out]	flx	flux across dual faces inside this cell

cs_cdo_diffusion_enforce_dir_t

typedef void() cs_cdo_diffusion_enforce_dir_t(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)

Enforce the Dirichlet BCs when a diffusion term is present. This routine define an operator which reconstructs the normal diffusive flux from the knowledge of the potential at degrees of freedom.

Parameters

[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cell-wise system

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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cell-wise system

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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdo_diffusion_vbcost_face_flux()

double cs_cdo_diffusion_vbcost_face_flux	(	short int	f,
		const cs_cell_mesh_t *	cm,
		const cs_real_3_t *	diff_tensor,
		const cs_real_t *	pot_values,
		double	beta,
		cs_cell_builder_t *	cb
	)

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

Parameters

[in]	f	face id in the cell mesh
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	diff_tensor	property tensor times the face normal
[in]	pot_values	array of values of the potential (all the mesh)
[in]	beta	value of the stabilization coef. related to reco.
[in,out]	cb	auxiliary structure dedicated to diffusion

Returns

the diffusive flux across the face f

cs_cdo_diffusion_vbcost_get_cell_flux()

void cs_cdo_diffusion_vbcost_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]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	values of the potential fields at specific locations
[in,out]	cb	auxiliary structure for computing the flux
[in,out]	flx	values of the flux inside the cell

cs_cdo_diffusion_vbcost_get_dfbyc_flux()

void cs_cdo_diffusion_vbcost_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 Use the COST algo. for computing the discrete Hodge op. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot)

Parameters

[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	values of the potential fields at specific locations
[in,out]	cb	auxiliary structure for computing the flux
[in,out]	flx	values of the flux across specific entities

cs_cdo_diffusion_vbcost_weak_dirichlet()

void cs_cdo_diffusion_vbcost_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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdo_diffusion_vbcost_wsym_dirichlet()

void cs_cdo_diffusion_vbcost_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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdo_diffusion_vbwbs_weak_dirichlet()

void cs_cdo_diffusion_vbwbs_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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdo_diffusion_vbwbs_wsym_dirichlet()

void cs_cdo_diffusion_vbwbs_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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in,out]	fm	pointer to a cs_face_mesh_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure 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]	fm	pointer to a cs_face_mesh_t structure
[in]	pty_tens	3x3 matrix related to the diffusion property
[in]	p_v	array of values attached to face vertices
[in]	p_f	value attached to the face
[in]	p_c	value attached to the cell
[in,out]	cb	auxiliary 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]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	values of the potential fields at vertices
[in,out]	cb	auxiliary structure for computing the flux
[in,out]	flx	flux 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]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	values of the potential fields at vertices
[in,out]	cb	auxiliary structure for computing the flux
[in,out]	flx	flux across dual faces inside this cell

cs_cdovb_diffusion_p0_face_flux()

void cs_cdovb_diffusion_p0_face_flux	(	const cs_cell_mesh_t *	cm,
		const cs_real_3_t *	diff_tensor,
		const cs_real_t *	pot_values,
		short int	f,
		cs_real_t	t_eval,
		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]	cm	pointer to a cs_cell_mesh_t structure
[in]	diff_tensor	property tensor times the face normal
[in]	pot_values	array of values of the potential (all the mesh)
[in]	f	face id in the cell mesh
[in]	t_eval	time at which one evaluates the advection field
[in,out]	fluxes	values of the fluxes related to each vertex