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

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