cs_cdo_diffusion.c File Reference

Build discrete stiffness matrices and handled boundary conditions for diffusion term in CDO vertex-based and vertex+cell schemes. More...

#include "cs_defs.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <bft_mem.h>
#include "cs_hodge.h"
#include "cs_log.h"
#include "cs_math.h"
#include "cs_property.h"
#include "cs_reco.h"
#include "cs_scheme_geometry.h"
#include "cs_cdo_diffusion.h"

Include dependency graph for cs_cdo_diffusion.c:

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 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_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_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_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 operator. 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...

Detailed Description

Build discrete stiffness matrices and handled boundary conditions for diffusion term in CDO vertex-based and vertex+cell schemes.

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_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]	f	face id in the cell mesh
[in]	eqp	pointer to a cs_equation_param_t structure
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	array of values of the potential (all the mesh)
[in,out]	cb	auxiliary structure dedicated to diffusion
[out]	flux	pointer 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]	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 Case of scalar-valued CDO Face-based schemes.

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_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]	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_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 operator. This function is dedicated to vertex-based schemes. Flux = -Hdg * GRAD(pot)

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_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]	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_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]	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_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]	f	face id in the cell mesh
[in]	eqp	pointer to a cs_equation_param_t structure
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	array of values of the potential (all the mesh)
[in,out]	cb	auxiliary structure dedicated to diffusion
[in,out]	vf_flux	array 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]	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_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]	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_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]	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_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]	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_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]	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_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]	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_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]	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_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]	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_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]	f	face id in the cell mesh
[in]	eqp	pointer to a cs_equation_param_t structure
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pot	array of values of the potential (all the mesh)
[in,out]	cb	auxiliary structure dedicated to diffusion
[in,out]	vf_flux	array 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]	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,out]	fluxes	values of the fluxes related to each vertex