cs_cdofb_navsto.h File Reference

#include "cs_defs.h"
#include "cs_base.h"
#include "cs_cdo_connect.h"
#include "cs_cdo_quantities.h"
#include "cs_field.h"
#include "cs_iter_algo.h"
#include "cs_math.h"
#include "cs_matrix.h"
#include "cs_mesh.h"
#include "cs_navsto_param.h"
#include "cs_time_plot.h"
#include "cs_time_step.h"
#include "cs_sdm.h"

Include dependency graph for cs_cdofb_navsto.h:

Go to the source code of this file.

Data Structures
struct	cs_cdofb_navsto_builder_t
	Structure storing additional arrays related to the building of the Navier-Stokes system. More...

Typedefs
typedef void()	cs_cdofb_navsto_source_t(const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cdofb_navsto_builder_t *nsb, cs_cell_sys_t *csys)
	Compute and add a source term to the local RHS. This is a special treatment to enable source involving face DoFs and potentially the local discrete divergence/gradient operators. In the standard case, only the cell DoFs are involved. Examples are gravity term or Bousinesq term(s) More...

Enumerations
enum	cs_cdofb_navsto_boussinesq_type_t { CS_CDOFB_NAVSTO_BOUSSINESQ_CELL_DOF, CS_CDOFB_NAVSTO_BOUSSINESQ_FACE_DOF }
	Type of algorithm to compute the Boussinesq approximation. More...

Functions
void	cs_cdofb_navsto_set_boussinesq_algo (cs_cdofb_navsto_boussinesq_type_t type)
	Set the way to compute the Boussinesq approximation. More...
cs_cdofb_navsto_builder_t	cs_cdofb_navsto_create_builder (const cs_navsto_param_t *nsp, const cs_cdo_connect_t *connect)
	Create and allocate a local NavSto builder when Fb schemes are used. More...
void	cs_cdofb_navsto_free_builder (cs_cdofb_navsto_builder_t *nsb)
	Destroy the given cs_cdofb_navsto_builder_t structure. More...
void	cs_cdofb_navsto_define_builder (cs_real_t t_eval, const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cell_sys_t *csys, const cs_cdo_bc_face_t *pr_bc, const cs_boundary_type_t *bf_type, cs_cdofb_navsto_builder_t *nsb)
	Set the members of the cs_cdofb_navsto_builder_t structure. More...
void	cs_cdofb_navsto_mass_flux (const cs_navsto_param_t *nsp, const cs_cdo_quantities_t *quant, const cs_real_t *face_vel, cs_real_t *mass_flux)
	Compute the mass flux playing the role of the advection field in the Navier-Stokes equations One considers the mass flux across primal faces which relies on the velocity vector defined on each face. More...
double	cs_cdofb_navsto_cell_divergence (const cs_lnum_t c_id, const cs_cdo_quantities_t *quant, const cs_adjacency_t *c2f, const cs_real_t *f_vals)
	Compute the divergence in a cell of a vector-valued array defined at faces (values are defined both at interior and border faces). Variant based on the usage of cs_cdo_quantities_t structure. More...
void	cs_cdofb_navsto_compute_face_pressure (const cs_mesh_t *mesh, const cs_cdo_connect_t *connect, const cs_cdo_quantities_t *quant, const cs_time_step_t *ts, const cs_navsto_param_t *nsp, const cs_real_t *p_cell, cs_real_t *p_face)
	Compute an estimation of the pressure at faces. More...
void	cs_cdofb_navsto_add_grad_div (short int n_fc, const cs_real_t zeta, const cs_real_t div[], cs_sdm_t *mat)
	Add the grad-div part to the local matrix (i.e. for the current cell) More...
void	cs_cdofb_navsto_init_pressure (const cs_navsto_param_t *nsp, const cs_cdo_quantities_t *quant, const cs_time_step_t *ts, cs_field_t *pr)
	Initialize the pressure values. More...
void	cs_cdofb_navsto_init_face_pressure (const cs_navsto_param_t *nsp, const cs_cdo_connect_t *connect, const cs_time_step_t *ts, cs_real_t *pr_f)
	Initialize the pressure values when the pressure is defined at faces. More...
void	cs_cdofb_navsto_rescale_pressure_to_ref (const cs_navsto_param_t *nsp, const cs_cdo_quantities_t *quant, cs_real_t values[])
	Update the pressure field in order to get a field with a mean-value equal to the reference value. More...
void	cs_cdofb_navsto_set_zero_mean_pressure (const cs_cdo_quantities_t *quant, cs_real_t values[])
	Update the pressure field in order to get a field with a zero-mean average. More...
void	cs_cdofb_navsto_extra_op (const cs_navsto_param_t *nsp, const cs_mesh_t *mesh, const cs_cdo_quantities_t *quant, const cs_cdo_connect_t *connect, const cs_time_step_t *ts, cs_time_plot_t *time_plotter, const cs_adv_field_t *adv_field, const cs_real_t *mass_flux, const cs_real_t *p_cell, const cs_real_t *u_cell, const cs_real_t *u_face)
	Perform extra-operation related to Fb schemes when solving Navier-Stokes. Computation of the following quantities according to post-processing flags beeing activated. More...
void	cs_cdofb_block_dirichlet_alge (short int f, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_property_data_t *pty, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
	Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of an algebraic technique. This prototype matches the function pointer cs_cdo_apply_boundary_t. More...
void	cs_cdofb_block_dirichlet_pena (short int f, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_property_data_t *pty, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
	Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of a penalization technique (with a large coefficient). One assumes that static condensation has been performed and that the velocity-block has size 3*n_fc This prototype matches the function pointer cs_cdo_apply_boundary_t. More...
void	cs_cdofb_block_dirichlet_weak (short int fb, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_property_data_t *pty, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
	Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of a weak penalization technique (Nitsche). One assumes that static condensation has not been performed yet and that the velocity-block has size 3*(n_fc + 1) This prototype matches the function pointer cs_cdo_apply_boundary_t. More...
void	cs_cdofb_block_dirichlet_wsym (short int fb, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_property_data_t *pty, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
	Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of a weak penalization technique (symmetrized Nitsche). One assumes that static condensation has not been performed yet and that the velocity-block has size 3*(n_fc + 1) This prototype matches the function pointer cs_cdo_apply_boundary_t. More...
void	cs_cdofb_symmetry (short int fb, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_property_data_t *pty, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
	Take into account a boundary defined as 'symmetry' (treated as a sliding BCs on the three velocity components.) A weak penalization technique (symmetrized Nitsche) is used. One assumes that static condensation has not been performed yet and that the velocity-block has (n_fc + 1) blocks of size 3x3. This prototype matches the function pointer cs_cdo_apply_boundary_t. More...
void	cs_cdofb_fixed_wall (short int fb, const cs_equation_param_t *eqp, const cs_cell_mesh_t *cm, const cs_property_data_t *pty, cs_cell_builder_t *cb, cs_cell_sys_t *csys)
	Take into account a wall BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. This prototype matches the function pointer cs_cdo_apply_boundary_t. More...
cs_sles_convergence_state_t	cs_cdofb_navsto_nl_algo_cvg (cs_param_nl_algo_t nl_algo_type, const cs_real_t *pre_iterate, cs_real_t *cur_iterate, cs_iter_algo_t *algo)
	Test if one has to do one more non-linear iteration. Test if performed on the relative norm on the increment between two iterations. More...
void	cs_cdofb_navsto_set_gravity_func (const cs_navsto_param_t *nsp, cs_cdofb_navsto_source_t **p_func)
	Set the function pointer computing the source term in the momentum equation related to the gravity effect (hydrostatic pressure or the Boussinesq approximation) More...
void	cs_cdofb_navsto_gravity_term (const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cdofb_navsto_builder_t *nsb, cs_cell_sys_t *csys)
	Take into account the gravity effects. Compute and add the source term to the local RHS. This is a special treatment since of face DoFs are involved contrary to the standard case where only the cell DoFs is involved. More...
void	cs_cdofb_navsto_boussinesq_at_cell (const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cdofb_navsto_builder_t *nsb, cs_cell_sys_t *csys)
	Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This is the standard case where the face DoFs are used for the constant part rho0 . g[] and only the cell DoFs are involved for the remaining part (the Boussinesq approximation). More...
void	cs_cdofb_navsto_boussinesq_at_face (const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cdofb_navsto_builder_t *nsb, cs_cell_sys_t *csys)
	Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This way to compute the Boussinesq approximation relies only on DoFs at faces. This should enable to keep a stable (no velocity) in case of a stratified configuration. More...
void	cs_cdofb_navsto_boussinesq_by_part (const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cdofb_navsto_builder_t *nsb, cs_cell_sys_t *csys)
	Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This way to compute the Boussinesq approximation relies only on DoFs at faces. This should enable to keep a stable (no velocity) in case of a stratified configuration. More...
void	cs_cdofb_navsto_stream_source_term (cs_lnum_t n_elts, const cs_lnum_t *elt_ids, bool dense_output, void *input, cs_real_t *retval)
	Get the source term for computing the stream function. This relies on the prototype associated to the generic function pointer cs_dof_function_t. More...

Typedef Documentation

cs_cdofb_navsto_source_t

typedef void() cs_cdofb_navsto_source_t(const cs_navsto_param_t *nsp, const cs_cell_mesh_t *cm, const cs_cdofb_navsto_builder_t *nsb, cs_cell_sys_t *csys)

Compute and add a source term to the local RHS. This is a special treatment to enable source involving face DoFs and potentially the local discrete divergence/gradient operators. In the standard case, only the cell DoFs are involved. Examples are gravity term or Bousinesq term(s)

Parameters

[in]	nsp	set of parameters to handle the Navier-Stokes system
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	nsb	pointer to a builder structure for the NavSto system
[in,out]	csys	pointer to a cs_cell_sys_t structure

Enumeration Type Documentation

cs_cdofb_navsto_boussinesq_type_t

enum cs_cdofb_navsto_boussinesq_type_t

Type of algorithm to compute the Boussinesq approximation.

Enumerator
CS_CDOFB_NAVSTO_BOUSSINESQ_CELL_DOF	Boussinesq approximation relyong on a cell contribution. This algorithm uses cell DoFs for the Boussinesq part corresponding to rho0 * beta * (var[c_id] - var0) * g[] while the constant part equal to rho0 * g[] is built in order to be in balance with the pressure gradient (face DoF contributions).
CS_CDOFB_NAVSTO_BOUSSINESQ_FACE_DOF	Boussinesq approximation relyong on face contributions. This algorithm uses only face DoFs for the Boussinesq approximation. For the constant part (rho0 * g[]) as well as the variable part rho0 * beta * (var[c_id] - var0) * g[] The aim is to be in balance with the pressure gradient

Function Documentation

cs_cdofb_block_dirichlet_alge()

void cs_cdofb_block_dirichlet_alge	(	short int	f,
		const cs_equation_param_t *	eqp,
		const cs_cell_mesh_t *	cm,
		const cs_property_data_t *	pty,
		cs_cell_builder_t *	cb,
		cs_cell_sys_t *	csys
	)

Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of an algebraic technique. This prototype matches the function pointer cs_cdo_apply_boundary_t.

Parameters

[in]	f	face id in the cell mesh numbering
[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pty	pointer to a cs_property_data_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdofb_block_dirichlet_pena()

void cs_cdofb_block_dirichlet_pena	(	short int	f,
		const cs_equation_param_t *	eqp,
		const cs_cell_mesh_t *	cm,
		const cs_property_data_t *	pty,
		cs_cell_builder_t *	cb,
		cs_cell_sys_t *	csys
	)

Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of a penalization technique (with a large coefficient). One assumes that static condensation has been performed and that the velocity-block has size 3*n_fc This prototype matches the function pointer cs_cdo_apply_boundary_t.

Parameters

[in]	f	face id in the cell mesh numbering
[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pty	pointer to a cs_property_data_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdofb_block_dirichlet_weak()

void cs_cdofb_block_dirichlet_weak	(	short int	fb,
		const cs_equation_param_t *	eqp,
		const cs_cell_mesh_t *	cm,
		const cs_property_data_t *	pty,
		cs_cell_builder_t *	cb,
		cs_cell_sys_t *	csys
	)

Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of a weak penalization technique (Nitsche). One assumes that static condensation has not been performed yet and that the velocity-block has size 3*(n_fc + 1) This prototype matches the function pointer cs_cdo_apply_boundary_t.

Parameters

[in]	fb	face id in the cell mesh numbering
[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pty	pointer to a cs_property_data_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdofb_block_dirichlet_wsym()

void cs_cdofb_block_dirichlet_wsym	(	short int	fb,
		const cs_equation_param_t *	eqp,
		const cs_cell_mesh_t *	cm,
		const cs_property_data_t *	pty,
		cs_cell_builder_t *	cb,
		cs_cell_sys_t *	csys
	)

Take into account a Dirichlet BCs on the three velocity components. For instance for a velocity inlet boundary or a wall Handle the velocity-block in the global algebraic system in case of a weak penalization technique (symmetrized Nitsche). One assumes that static condensation has not been performed yet and that the velocity-block has size 3*(n_fc + 1) This prototype matches the function pointer cs_cdo_apply_boundary_t.

Parameters

[in]	fb	face id in the cell mesh numbering
[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pty	pointer to a cs_property_data_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdofb_fixed_wall()

void cs_cdofb_fixed_wall	(	short int	fb,
		const cs_equation_param_t *	eqp,
		const cs_cell_mesh_t *	cm,
		const cs_property_data_t *	pty,
		cs_cell_builder_t *	cb,
		cs_cell_sys_t *	csys
	)

Take into account a wall BCs by a weak enforcement using Nitsche technique plus a symmetric treatment. This prototype matches the function pointer cs_cdo_apply_boundary_t.

Parameters

[in]	fb	face id in the cell mesh numbering
[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pty	pointer to a cs_property_data_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system

cs_cdofb_navsto_add_grad_div()

void cs_cdofb_navsto_add_grad_div	(	short int	n_fc,
		const cs_real_t	zeta,
		const cs_real_t	div[],
		cs_sdm_t *	mat
	)

Add the grad-div part to the local matrix (i.e. for the current cell)

Parameters

[in]	n_fc	local number of faces for the current cell
[in]	zeta	scalar coefficient for the grad-div operator
[in]	div	divergence
[in,out]	mat	local system matrix to update

cs_cdofb_navsto_boussinesq_at_cell()

void cs_cdofb_navsto_boussinesq_at_cell	(	const cs_navsto_param_t *	nsp,
		const cs_cell_mesh_t *	cm,
		const cs_cdofb_navsto_builder_t *	nsb,
		cs_cell_sys_t *	csys
	)

Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This is the standard case where the face DoFs are used for the constant part rho0 . g[] and only the cell DoFs are involved for the remaining part (the Boussinesq approximation).

Parameters

[in]	nsp	set of parameters to handle the Navier-Stokes system
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	nsb	pointer to a builder structure for the NavSto system
[in,out]	csys	pointer to a cs_cell_sys_t structure

cs_cdofb_navsto_boussinesq_at_face()

void cs_cdofb_navsto_boussinesq_at_face	(	const cs_navsto_param_t *	nsp,
		const cs_cell_mesh_t *	cm,
		const cs_cdofb_navsto_builder_t *	nsb,
		cs_cell_sys_t *	csys
	)

Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This way to compute the Boussinesq approximation relies only on DoFs at faces. This should enable to keep a stable (no velocity) in case of a stratified configuration.

Parameters

[in]	nsp	set of parameters to handle the Navier-Stokes system
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	nsb	pointer to a builder structure for the NavSto system
[in,out]	csys	pointer to a cs_cell_sys_t structure

Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This way to compute the Boussinesq approximation relies only on DoFs at faces. This should enable to keep a stable (no velocity) in case of a stratified configuration.

Parameters

[in]	nsp	set of parameters to handle the Navier-Stokes system
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	nsb	pointer to a builder structure for the NavSto system
[in,out]	csys	pointer to a cs_cell_sys_t structure

cs_cdofb_navsto_boussinesq_by_part()

void cs_cdofb_navsto_boussinesq_by_part	(	const cs_navsto_param_t *	nsp,
		const cs_cell_mesh_t *	cm,
		const cs_cdofb_navsto_builder_t *	nsb,
		cs_cell_sys_t *	csys
	)

Take into account the buoyancy force with the Boussinesq approx. Compute and add the source term to the local RHS. This way to compute the Boussinesq approximation relies only on DoFs at faces. This should enable to keep a stable (no velocity) in case of a stratified configuration.

Parameters

[in]	nsp	set of parameters to handle the Navier-Stokes system
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	nsb	pointer to a builder structure for the NavSto system
[in,out]	csys	pointer to a cs_cell_sys_t structure

cs_cdofb_navsto_cell_divergence()

double cs_cdofb_navsto_cell_divergence	(	const cs_lnum_t	c_id,
		const cs_cdo_quantities_t *	quant,
		const cs_adjacency_t *	c2f,
		const cs_real_t *	f_vals
	)

Compute the divergence in a cell of a vector-valued array defined at faces (values are defined both at interior and border faces). Variant based on the usage of cs_cdo_quantities_t structure.

Parameters

[in]	c_id	cell id
[in]	quant	pointer to a cs_cdo_quantities_t
[in]	c2f	pointer to cell-to-face cs_adjacency_t
[in]	f_vals	values of the face DoFs

Returns

the divergence for the corresponding cell

cs_cdofb_navsto_compute_face_pressure()

void cs_cdofb_navsto_compute_face_pressure	(	const cs_mesh_t *	mesh,
		const cs_cdo_connect_t *	connect,
		const cs_cdo_quantities_t *	quant,
		const cs_time_step_t *	ts,
		const cs_navsto_param_t *	nsp,
		const cs_real_t *	p_cell,
		cs_real_t *	p_face
	)

Compute an estimation of the pressure at faces.

Parameters

[in]	mesh	pointer to a cs_mesh_t structure
[in]	connect	pointer to a cs_cdo_connect_t structure
[in]	quant	pointer to a cs_cdo_quantities_t structure
[in]	time_step	pointer to a cs_time_step_t structure
[in]	nsp	pointer to a cs_navsto_param_t struct.
[in]	p_cell	value of the pressure inside each cell
[in,out]	p_face	value of the pressure at each face

cs_cdofb_navsto_create_builder()

cs_cdofb_navsto_builder_t cs_cdofb_navsto_create_builder	(	const cs_navsto_param_t *	nsp,
		const cs_cdo_connect_t *	connect
	)

Create and allocate a local NavSto builder when Fb schemes are used.

Parameters

[in]	nsp	set of parameters to define the NavSto system
[in]	connect	pointer to a cs_cdo_connect_t structure

Returns

a cs_cdofb_navsto_builder_t structure

cs_cdofb_navsto_define_builder()

void cs_cdofb_navsto_define_builder	(	cs_real_t	t_eval,
		const cs_navsto_param_t *	nsp,
		const cs_cell_mesh_t *	cm,
		const cs_cell_sys_t *	csys,
		const cs_cdo_bc_face_t *	pr_bc,
		const cs_boundary_type_t *	bf_type,
		cs_cdofb_navsto_builder_t *	nsb
	)

Set the members of the cs_cdofb_navsto_builder_t structure.

Parameters

[in]	t_eval	time at which one evaluates the pressure BC
[in]	nsp	set of parameters to define the NavSto system
[in]	cm	cellwise view of the mesh
[in]	csys	cellwise view of the algebraic system
[in]	pr_bc	set of definitions for the presuure BCs
[in]	bf_type	type of boundaries for all boundary faces
[in,out]	nsb	builder to update

cs_cdofb_navsto_extra_op()

void cs_cdofb_navsto_extra_op	(	const cs_navsto_param_t *	nsp,
		const cs_mesh_t *	mesh,
		const cs_cdo_quantities_t *	quant,
		const cs_cdo_connect_t *	connect,
		const cs_time_step_t *	ts,
		cs_time_plot_t *	time_plotter,
		const cs_adv_field_t *	adv_field,
		const cs_real_t *	mass_flux,
		const cs_real_t *	p_cell,
		const cs_real_t *	u_cell,
		const cs_real_t *	u_face
	)

Perform extra-operation related to Fb schemes when solving Navier-Stokes. Computation of the following quantities according to post-processing flags beeing activated.

• The mass flux accross the boundaries.
• The global mass in the computational domain
• The norm of the velocity divergence
• the cellwise mass flux balance
• the kinetic energy
• the velocity gradient
• the pressure gradient
• the vorticity
• the helicity
• the enstrophy
• the stream function

Parameters

[in]	nsp	pointer to a cs_navsto_param_t struct.
[in]	mesh	pointer to a cs_mesh_t structure
[in]	quant	pointer to a cs_cdo_quantities_t struct.
[in]	connect	pointer to a cs_cdo_connect_t struct.
[in]	ts	pointer to a cs_time_step_t struct.
[in,out]	time_plotter	pointer to a cs_time_plot_t struct.
[in]	adv_field	pointer to a cs_adv_field_t struct.
[in]	mass_flux	scalar-valued mass flux for each face
[in]	p_cell	scalar-valued pressure in each cell
[in]	u_cell	vector-valued velocity in each cell
[in]	u_face	vector-valued velocity on each face

cs_cdofb_navsto_free_builder()

void cs_cdofb_navsto_free_builder

(

cs_cdofb_navsto_builder_t *

nsb

)

Destroy the given cs_cdofb_navsto_builder_t structure.

Parameters

[in,out]

nsb

pointer to the cs_cdofb_navsto_builder_t to free

cs_cdofb_navsto_gravity_term()

void cs_cdofb_navsto_gravity_term	(	const cs_navsto_param_t *	nsp,
		const cs_cell_mesh_t *	cm,
		const cs_cdofb_navsto_builder_t *	nsb,
		cs_cell_sys_t *	csys
	)

Take into account the gravity effects. Compute and add the source term to the local RHS. This is a special treatment since of face DoFs are involved contrary to the standard case where only the cell DoFs is involved.

Parameters

[in]	nsp	set of parameters to handle the Navier-Stokes system
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	nsb	pointer to a builder structure for the NavSto system
[in,out]	csys	pointer to a cs_cell_sys_t structure

cs_cdofb_navsto_init_face_pressure()

void cs_cdofb_navsto_init_face_pressure	(	const cs_navsto_param_t *	nsp,
		const cs_cdo_connect_t *	connect,
		const cs_time_step_t *	ts,
		cs_real_t *	pr_f
	)

Initialize the pressure values when the pressure is defined at faces.

Parameters

[in]	nsp	pointer to a cs_navsto_param_t structure
[in]	connect	pointer to a cs_cdo_connect_t structure
[in]	ts	pointer to a cs_time_step_t structure
[in,out]	pr_f	pointer to the pressure values at faces

cs_cdofb_navsto_init_pressure()

void cs_cdofb_navsto_init_pressure	(	const cs_navsto_param_t *	nsp,
		const cs_cdo_quantities_t *	quant,
		const cs_time_step_t *	ts,
		cs_field_t *	pr
	)

Initialize the pressure values.

Parameters

[in]	nsp	pointer to a cs_navsto_param_t structure
[in]	quant	pointer to a cs_cdo_quantities_t structure
[in]	ts	pointer to a cs_time_step_t structure
[in,out]	pr	pointer to the pressure cs_field_t structure

cs_cdofb_navsto_mass_flux()

void cs_cdofb_navsto_mass_flux	(	const cs_navsto_param_t *	nsp,
		const cs_cdo_quantities_t *	quant,
		const cs_real_t *	face_vel,
		cs_real_t *	mass_flux
	)

Compute the mass flux playing the role of the advection field in the Navier-Stokes equations One considers the mass flux across primal faces which relies on the velocity vector defined on each face.

Parameters

[in]	nsp	set of parameters to define the NavSto system
[in]	quant	set of additional geometrical quantities
[in]	face_vel	velocity vectors for each face
[in,out]	mass_flux	array of mass flux values to update (allocated)

cs_cdofb_navsto_nl_algo_cvg()

cs_sles_convergence_state_t cs_cdofb_navsto_nl_algo_cvg	(	cs_param_nl_algo_t	nl_algo_type,
		const cs_real_t *	pre_iterate,
		cs_real_t *	cur_iterate,
		cs_iter_algo_t *	algo
	)

Test if one has to do one more non-linear iteration. Test if performed on the relative norm on the increment between two iterations.

Parameters

[in]	nl_algo_type	type of non-linear algorithm
[in]	pre_iterate	previous state of the mass flux iterate
[in]	cur_iterate	current state of the mass flux iterate
[in,out]	algo	pointer to a cs_iter_algo_t structure

Returns

the convergence state

cs_cdofb_navsto_rescale_pressure_to_ref()

void cs_cdofb_navsto_rescale_pressure_to_ref	(	const cs_navsto_param_t *	nsp,
		const cs_cdo_quantities_t *	quant,
		cs_real_t	values[]
	)

Update the pressure field in order to get a field with a mean-value equal to the reference value.

Parameters

[in]	nsp	pointer to a cs_navsto_param_t structure
[in]	quant	pointer to a cs_cdo_quantities_t structure
[in,out]	values	pressure field values

cs_cdofb_navsto_set_boussinesq_algo()

void cs_cdofb_navsto_set_boussinesq_algo

(

cs_cdofb_navsto_boussinesq_type_t

type

)

Set the way to compute the Boussinesq approximation.

Parameters

[in]

type

type of algorithm to use

cs_cdofb_navsto_set_gravity_func()

void cs_cdofb_navsto_set_gravity_func	(	const cs_navsto_param_t *	nsp,
		cs_cdofb_navsto_source_t **	p_func
	)

Set the function pointer computing the source term in the momentum equation related to the gravity effect (hydrostatic pressure or the Boussinesq approximation)

Parameters

[in]	nsp	set of parameters for the Navier-Stokes system
[out]	p_func	way to compute the gravity effect

cs_cdofb_navsto_set_zero_mean_pressure()

void cs_cdofb_navsto_set_zero_mean_pressure	(	const cs_cdo_quantities_t *	quant,
		cs_real_t	values[]
	)

Update the pressure field in order to get a field with a zero-mean average.

Parameters

[in]	quant	pointer to a cs_cdo_quantities_t structure
[in,out]	values	pressure field values

cs_cdofb_navsto_stream_source_term()

void cs_cdofb_navsto_stream_source_term	(	cs_lnum_t	n_elts,
		const cs_lnum_t *	elt_ids,
		bool	dense_output,
		void *	input,
		cs_real_t *	retval
	)

Get the source term for computing the stream function. This relies on the prototype associated to the generic function pointer cs_dof_function_t.

Parameters

[in]	n_elts	number of elements to consider
[in]	elt_ids	list of elements ids
[in]	dense_output	perform an indirection in retval or not
[in]	input	NULL or pointer to a structure cast on-the-fly
[in,out]	retval	result of the function. Must be allocated.

cs_cdofb_symmetry()

void cs_cdofb_symmetry	(	short int	fb,
		const cs_equation_param_t *	eqp,
		const cs_cell_mesh_t *	cm,
		const cs_property_data_t *	pty,
		cs_cell_builder_t *	cb,
		cs_cell_sys_t *	csys
	)

Take into account a boundary defined as 'symmetry' (treated as a sliding BCs on the three velocity components.) A weak penalization technique (symmetrized Nitsche) is used. One assumes that static condensation has not been performed yet and that the velocity-block has (n_fc + 1) blocks of size 3x3. This prototype matches the function pointer cs_cdo_apply_boundary_t.

Parameters

[in]	fb	face id in the cell mesh numbering
[in]	eqp	pointer to a cs_equation_param_t struct.
[in]	cm	pointer to a cs_cell_mesh_t structure
[in]	pty	pointer to a cs_property_data_t structure
[in,out]	cb	pointer to a cs_cell_builder_t structure
[in,out]	csys	structure storing the cellwise system