Fluid Mechanics Toolbox. More...

Inheritance diagram for Feel::FeelModels::FluidMechanics< ConvexType, BasisVelocityType, BasisPressureType >:

Collaboration diagram for Feel::FeelModels::FluidMechanics< ConvexType, BasisVelocityType, BasisPressureType >:

Classes
class	BodyArticulation
	Body Articulation. More...

class	BodyBoundaryCondition
	Boundary Condition for a Body. More...

class	BodySetBoundaryCondition
	boundary conditions for a set of bodies More...

struct	FieldTag

struct	FilterBasisUnknownTurbulenceModel

class	NBodyArticulated

struct	TurbulenceModelBoundaryConditions

Public Types
typedef BasisPressureType	basis_fluid_p_type

typedef BasisVelocityType	basis_fluid_u_type

typedef basis_fluid_u_type::component_basis_type	basis_fluidinlet_type

typedef Lagrange< 0, Scalar, Continuous >	basis_l_type

typedef Lagrange< nOrderVelocity-1+mesh_type::nOrder, Vectorial, Discontinuous, PointSetFekete >	basis_normalstress_type

typedef bases< Lagrange< nOrderVelocity, Vectorial, Continuous, PointSetFekete > >	basis_vectorial_PN_type

using	bdf_fluidoutlet_windkessel_ptrtype = std::shared_ptr< bdf_fluidoutlet_windkessel_type >

using	bdf_fluidoutlet_windkessel_type = Bdf< space_fluidoutlet_windkessel_type >

typedef std::shared_ptr< bdf_trace_p0c_vectorial_type >	bdf_trace_p0c_vectorial_ptrtype

typedef Bdf< space_trace_p0c_vectorial_type >	bdf_trace_p0c_vectorial_type

typedef std::shared_ptr< bdf_velocity_type >	bdf_velocity_ptrtype

typedef Bdf< space_velocity_type >	bdf_velocity_type

typedef std::shared_ptr< component_element_velocity_type >	component_element_velocity_ptrtype

typedef component_space_velocity_type::element_type	component_element_velocity_type

typedef std::shared_ptr< component_space_velocity_type >	component_space_velocity_ptrtype

typedef space_velocity_type::component_functionspace_type	component_space_velocity_type

typedef ConvexType	convex_type

typedef std::shared_ptr< element_dist2wall_type >	element_dist2wall_ptrtype

typedef space_dist2wall_type::element_type	element_dist2wall_type

typedef std::shared_ptr< element_fluidinlet_type >	element_fluidinlet_ptrtype

typedef space_fluidinlet_type::element_type	element_fluidinlet_type

typedef std::shared_ptr< element_fluidoutlet_windkessel_type >	element_fluidoutlet_windkessel_ptrtype

typedef space_fluidoutlet_windkessel_type::element_type	element_fluidoutlet_windkessel_type

typedef std::shared_ptr< element_normalstress_type >	element_normalstress_ptrtype

typedef space_normalstress_type::element_type	element_normalstress_type

typedef std::shared_ptr< element_pressure_type >	element_pressure_ptrtype

typedef space_pressure_type::element_type	element_pressure_type

typedef std::shared_ptr< element_scalar_visu_ho_type >	element_scalar_visu_ho_ptrtype

typedef space_scalar_visu_ho_type::element_type	element_scalar_visu_ho_type

typedef std::shared_ptr< element_trace_p0c_vectorial_type >	element_trace_p0c_vectorial_ptrtype

typedef space_trace_p0c_vectorial_type::element_type	element_trace_p0c_vectorial_type

typedef std::shared_ptr< element_trace_velocity_component_type >	element_trace_velocity_component_ptrtype

typedef space_trace_velocity_component_type::element_type	element_trace_velocity_component_type

typedef std::shared_ptr< element_trace_velocity_type >	element_trace_velocity_ptrtype

typedef space_trace_velocity_type::element_type	element_trace_velocity_type

typedef std::shared_ptr< element_vectorial_PN_type >	element_vectorial_PN_ptrtype

typedef space_vectorial_PN_type::element_type	element_vectorial_PN_type

typedef std::shared_ptr< element_vectorial_visu_ho_type >	element_vectorial_visu_ho_ptrtype

typedef space_vectorial_visu_ho_type::element_type	element_vectorial_visu_ho_type

typedef std::shared_ptr< element_vectorialdisc_visu_ho_type >	element_vectorialdisc_visu_ho_ptrtype

typedef space_vectorialdisc_visu_ho_type::element_type	element_vectorialdisc_visu_ho_type

typedef std::shared_ptr< element_velocity_type >	element_velocity_ptrtype

typedef space_velocity_type::element_type	element_velocity_type

typedef std::shared_ptr< export_ho_type >	export_ho_ptrtype

typedef Exporter< mesh_visu_ho_type >	export_ho_type

typedef std::shared_ptr< export_type >	export_ptrtype

typedef std::shared_ptr< export_trace_type >	export_trace_ptrtype

typedef Exporter< trace_mesh_type, nOrderGeo >	export_trace_type

typedef Exporter< mesh_type, nOrderGeo >	export_type

using	force_type = Eigen::Matrix< typename super_type::value_type, nDim, 1, Eigen::ColMajor >

typedef model_algebraic_factory_type::graph_ptrtype	graph_ptrtype

typedef model_algebraic_factory_type::graph_type	graph_type

typedef model_algebraic_factory_type::indexsplit_ptrtype	indexsplit_ptrtype

typedef model_algebraic_factory_type::indexsplit_type	indexsplit_type

typedef std::shared_ptr< materialsproperties_type >	materialsproperties_ptrtype

typedef MaterialsProperties< nRealDim >	materialsproperties_type

typedef std::shared_ptr< mesh_type >	mesh_ptrtype

typedef Mesh< convex_type >	mesh_type

typedef Mesh< Simplex< nDim, 1, nDim > >	mesh_visu_ho_type

using	multibody_ptrtype = std::shared_ptr< multibody_type >

using	multibody_type = Multibody< convex_type >

typedef std::shared_ptr< op_interpolation_fluidinlet_type >	op_interpolation_fluidinlet_ptrtype

typedef OperatorInterpolation< space_fluidinlet_type, component_space_velocity_type, range_faces_type >	op_interpolation_fluidinlet_type

typedef std::shared_ptr< op_interpolation_visu_ho_scalar_type >	op_interpolation_visu_ho_scalar_ptrtype

typedef OperatorInterpolation< space_pressure_type, space_scalar_visu_ho_type >	op_interpolation_visu_ho_scalar_type

typedef std::shared_ptr< op_interpolation_visu_ho_vectorial_type >	op_interpolation_visu_ho_vectorial_ptrtype

typedef OperatorInterpolation< space_velocity_type, space_vectorial_visu_ho_type >	op_interpolation_visu_ho_vectorial_type

typedef OperatorPCDBase< typename space_velocity_type::value_type >	operatorpcdbase_type

typedef OperatorPMMBase< typename space_velocity_type::value_type >	operatorpmmbase_type

typedef Range< mesh_type, MESH_ELEMENTS >	range_elements_type

typedef Range< mesh_type, MESH_FACES >	range_faces_type

typedef std::shared_ptr< savets_pressure_type >	savets_pressure_ptrtype

typedef Bdf< space_pressure_type >	savets_pressure_type

typedef std::shared_ptr< self_type >	self_ptrtype

typedef FluidMechanics< ConvexType, BasisVelocityType, BasisPressureType >	self_type

using	size_type = typename super_type::size_type

typedef FunctionSpace< mesh_type, bases< Lagrange< nOrderVelocity, Scalar, Continuous, PointSetFekete > > >	space_create_ho_type

typedef std::shared_ptr< space_dist2wall_type >	space_dist2wall_ptrtype

using	space_dist2wall_type = Pch_type< mesh_type, 1 >

typedef std::shared_ptr< space_fluidinlet_type >	space_fluidinlet_ptrtype

typedef FunctionSpace< trace_mesh_type, bases< basis_fluidinlet_type > >	space_fluidinlet_type

typedef std::shared_ptr< space_fluidoutlet_windkessel_type >	space_fluidoutlet_windkessel_ptrtype

using	space_fluidoutlet_windkessel_type = Pch_type< trace_mesh_type, 0 >

typedef std::shared_ptr< space_meanpressurelm_type >	space_meanpressurelm_ptrtype

typedef FunctionSpace< mesh_type, bases< basis_l_type > >	space_meanpressurelm_type

typedef std::shared_ptr< space_normalstress_type >	space_normalstress_ptrtype

typedef FunctionSpace< trace_mesh_type, bases< basis_normalstress_type > >	space_normalstress_type

typedef std::shared_ptr< space_pressure_type >	space_pressure_ptrtype

typedef FunctionSpace< mesh_type, bases< basis_fluid_p_type > >	space_pressure_type

typedef std::shared_ptr< space_scalar_visu_ho_type >	space_scalar_visu_ho_ptrtype

typedef space_vectorial_visu_ho_type::component_functionspace_type	space_scalar_visu_ho_type

typedef std::shared_ptr< space_trace_p0c_scalar_type >	space_trace_p0c_scalar_ptrtype

typedef FunctionSpace< trace_mesh_type, bases< Lagrange< 0, Scalar, Continuous > > >	space_trace_p0c_scalar_type

typedef std::shared_ptr< space_trace_p0c_vectorial_type >	space_trace_p0c_vectorial_ptrtype

typedef FunctionSpace< trace_mesh_type, bases< Lagrange< 0, Vectorial, Continuous > > >	space_trace_p0c_vectorial_type

typedef std::shared_ptr< space_trace_velocity_component_type >	space_trace_velocity_component_ptrtype

typedef space_trace_velocity_type::component_functionspace_type	space_trace_velocity_component_type

typedef std::shared_ptr< space_trace_velocity_type >	space_trace_velocity_ptrtype

typedef FunctionSpace< trace_mesh_type, bases< basis_fluid_u_type > >	space_trace_velocity_type

typedef std::shared_ptr< space_vectorial_PN_type >	space_vectorial_PN_ptrtype

typedef FunctionSpace< mesh_type, basis_vectorial_PN_type >	space_vectorial_PN_type

typedef std::shared_ptr< space_vectorial_visu_ho_type >	space_vectorial_visu_ho_ptrtype

typedef FunctionSpace< mesh_visu_ho_type, bases< Lagrange< 1, Vectorial, Continuous, PointSetFekete > > >	space_vectorial_visu_ho_type

typedef std::shared_ptr< space_vectorialdisc_visu_ho_type >	space_vectorialdisc_visu_ho_ptrtype

typedef FunctionSpace< mesh_visu_ho_type, bases< Lagrange< 1, Vectorial, Discontinuous, PointSetFekete > > >	space_vectorialdisc_visu_ho_type

typedef std::shared_ptr< space_velocity_type >	space_velocity_ptrtype

typedef FunctionSpace< mesh_type, bases< basis_fluid_u_type > >	space_velocity_type

typedef std::shared_ptr< stab_gls_parameter_type >	stab_gls_parameter_ptrtype

typedef StabilizationGLSParameterBase< mesh_type >	stab_gls_parameter_type

using	super2_type = ModelPhysics< ConvexType::nDim >

using	super_type = ModelNumerical

using	trace_mesh_ptrtype = std::shared_ptr< trace_mesh_type >

using	trace_mesh_type = trace_mesh_t< mesh_type >

using	turbulence_model_ptrtype = std::shared_ptr< turbulence_model_type >

using	turbulence_model_type = FeelModels::coefficient_form_PDEs_t< convex_type >

Public Types inherited from Feel::FeelModels::ModelNumerical
typedef super_type::backend_ptrtype	backend_ptrtype

typedef super_type::backend_type	backend_type

typedef vf::BlocksBase< size_type >	block_pattern_type

using	index_type = typename super_type::index_type

typedef backend_type::indexsplit_ptrtype	indexsplit_ptrtype

typedef backend_type::indexsplit_type	indexsplit_type

using	size_type = typename super_type::size_type

typedef backend_type::sparse_matrix_ptrtype	sparse_matrix_ptrtype

typedef ModelAlgebraic	super_type

typedef double	value_type

typedef backend_type::vector_ptrtype	vector_ptrtype

Public Types inherited from Feel::FeelModels::ModelBase
using	worldcomm_ptr_t = std::shared_ptr< WorldComm >

using	worldcomm_t = WorldComm

using	worldscomm_ptr_t = std::vector< std::shared_ptr< WorldComm > >

Public Types inherited from Feel::JournalWatcher
using	function_update_information_type = std::function< void(nl::json &)>

using	notify_type = nl::json

Public Types inherited from Feel::FeelModels::ModelAlgebraic
typedef std::shared_ptr< backend_type >	backend_ptrtype

typedef Backend< value_type, size_type >	backend_type

typedef vf::BlocksBase< size_type >	block_pattern_type

using	block_vector_ptrtype = std::shared_ptr< block_vector_type >

using	block_vector_type = BlocksBaseVector< double >

typedef backend_type::graph_ptrtype	graph_ptrtype

typedef backend_type::graph_type	graph_type

using	index_type = uint32_type

typedef backend_type::indexsplit_ptrtype	indexsplit_ptrtype

typedef backend_type::indexsplit_type	indexsplit_type

typedef std::shared_ptr< model_algebraic_factory_type >	model_algebraic_factory_ptrtype

typedef ModelAlgebraicFactory	model_algebraic_factory_type

using	size_type = index_type

typedef backend_type::sparse_matrix_ptrtype	sparse_matrix_ptrtype

typedef ModelBase	super_type

typedef double	value_type

typedef backend_type::vector_ptrtype	vector_ptrtype

Public Types inherited from Feel::FeelModels::ModelMeshes< ModelAlgebraic::index_type >
using	index_type = ModelAlgebraic::index_type

using	mesh_adaptation_type = typename modelmesh_type::MeshAdaptation

using	mesh_base_ptrtype = typename modelmesh_type::mesh_base_ptrtype

using	mesh_base_type = typename modelmesh_type::mesh_base_type

using	modelmesh_type = ModelMesh< ModelAlgebraic::index_type >

Public Types inherited from Feel::FeelModels::ModelPhysics< ConvexType::nDim >
using	material_property_description_type = MaterialPropertyDescription

using	material_property_shape_dim_type = typename material_property_description_type::shape_dim_type

using	model_physic_ptrtype = std::shared_ptr< model_physic_type >

using	model_physic_type = ModelPhysic< nDim >

using	physic_id_type = std::pair< std::string, std::string >

Public Member Functions
void	addUpdateInHousePreconditionerPCD (std::string const &name, std::function< void(operatorpcdbase_type &)> const &init, std::function< void(operatorpcdbase_type &, DataUpdateBase &)> const &up=std::function< void(operatorpcdbase_type &, DataUpdateBase &)>())

void	addUpdateInHousePreconditionerPMM (std::string const &name, std::function< void(operatorpmmbase_type &)> const &init, std::function< void(operatorpmmbase_type &, DataUpdateBase &)> const &up=std::function< void(operatorpmmbase_type &, DataUpdateBase &)>())

bool	applyCIPStabOnlyOnBoundaryFaces () const

void	applyCIPStabOnlyOnBoundaryFaces (bool b)

bool	applyMovingMeshBeforeSolve () const

void	applyRemesh (mesh_ptrtype oldMesh, mesh_ptrtype newMesh, std::shared_ptr< RemeshInterpolation > remeshInterp=std::make_shared< RemeshInterpolation >())

super_type::block_pattern_type	blockPattern () const override

BodySetBoundaryCondition &	bodySetBC ()
	return the set of body BC

BodySetBoundaryCondition const &	bodySetBC () const
	return the set of body BC

virtual BlocksBaseGraphCSR	buildBlockMatrixGraph () const override

void	buildBlockVector ()

graph_ptrtype	buildMatrixGraph () const override

double	computeFlowRate (std::set< std::string > const &markers, bool useExteriorNormal=true) const

double	computeFlowRate (std::string const &marker, bool useExteriorNormal=true) const

template<typename SymbolsExprType >
force_type	computeForce (range_faces_type const &rangeFaces, SymbolsExprType const &se) const

double	computeMeshArea (std::set< std::string > const &markers) const

double	computeMeshArea (std::string const &marker="") const

double	computePressureMean () const

double	computePressureSum () const

double	computeVelocityDivergenceMean () const

double	computeVelocityDivergenceNormL2 () const

double	computeVelocityDivergenceSum () const

std::string	couplingFSIcondition () const

void	couplingFSIcondition (std::string s)

void	createFunctionSpacesNormalStress ()

void	createFunctionSpacesSourceAdded ()

bool	definePressureCst () const

std::string	definePressureCstMethod () const

double	definePressureCstPenalisationBeta () const

double	dirichletBCnitscheGamma () const

bool	doCIPStabConvection () const

void	doCIPStabConvection (bool b)

bool	doCIPStabDivergence () const

void	doCIPStabDivergence (bool b)

bool	doCIPStabPressure () const

void	doCIPStabPressure (bool b)

bool	doStabConvectionEnergy () const

void	doStabConvectionEnergy (bool b)

template<typename SymbolsExprType = symbols_expression_empty_t>
auto	dynamicViscosityExpr (std::string const &matName, SymbolsExprType const &se=symbols_expression_empty_t{}) const

template<typename SymbolsExprType = symbols_expression_empty_t>
auto	dynamicViscosityExpr (SymbolsExprType const &se=symbols_expression_empty_t{}, typename std::enable_if_t< is_symbols_expression_v< SymbolsExprType >\|\|is_symbols_expression_tensor_context_v< SymbolsExprType > > *=nullptr) const

template<typename VelocityFieldType , typename SymbolsExprType = symbols_expression_empty_t>
auto	dynamicViscosityExpr (VelocityFieldType const &u, std::string const &matName, SymbolsExprType const &se=symbols_expression_empty_t{}, typename std::enable_if_t< is_functionspace_element_v< unwrap_ptr_t< VelocityFieldType > > > *=nullptr) const

template<typename VelocityFieldType , typename SymbolsExprType = symbols_expression_empty_t>
auto	dynamicViscosityExpr (VelocityFieldType const &u, SymbolsExprType const &se=symbols_expression_empty_t{}, typename std::enable_if_t< is_functionspace_element_v< unwrap_ptr_t< VelocityFieldType > > > *=nullptr) const

void	exportResults ()

void	exportResults (double time)

template<typename ModelFieldsType , typename SymbolsExpr , typename ExportsExprType >
void	exportResults (double time, ModelFieldsType const &mfields, SymbolsExpr const &symbolsExpr, ExportsExprType const &exportsExpr)

template<typename ModelFieldsType , typename SymbolsExprType , typename ExportsExprType >
void	exportResults (double time, ModelFieldsType const &mfields, SymbolsExprType const &symbolsExpr, ExportsExprType const &exportsExpr)

template<typename SymbolsExpr >
void	exportResults (double time, SymbolsExpr const &symbolsExpr)

template<typename SymbExprType >
auto	exprPostProcessExports (SymbExprType const &se, std::string const &prefix="") const

template<typename SymbExprType >
auto	exprPostProcessExportsToolbox (SymbExprType const &se, std::string const &prefix) const

element_pressure_type &	fieldPressure ()

element_pressure_type const &	fieldPressure () const

element_pressure_ptrtype const &	fieldPressurePtr () const

element_velocity_type &	fieldVelocity ()

element_velocity_type const &	fieldVelocity () const

element_velocity_ptrtype const &	fieldVelocityExtrapolatedPtr () const

element_velocity_ptrtype &	fieldVelocityPtr ()

element_velocity_ptrtype const &	fieldVelocityPtr () const

	FluidMechanics (self_type const &M)=default

	FluidMechanics (std::string const &prefix, std::string const &keyword="fluid", worldcomm_ptr_t const &_worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository())

space_pressure_ptrtype const &	functionSpacePressure () const

space_velocity_ptrtype const &	functionSpaceVelocity () const

bool	hasNonNewtonianViscosity () const

bool	hasOperatorPCD () const

bool	hasOperatorPMM () const

bool	hasSolveNewtonianAtKickOff () const

void	hasSolveNewtonianAtKickOff (bool b)

bool	hasSolveStokesStationaryAtKickOff () const

void	hasSolveStokesStationaryAtKickOff (bool b)

bool	hasTurbulenceModel () const

bool	hasTurbulenceModel (std::string const &name) const

void	init (bool buildModelAlgebraicFactory=true)

void	initAlgebraicFactory ()

void	initInHousePreconditioner ()

void	initTimeStep ()

bool	isStationaryModel () const

FEELPP_DEPRECATED void	loadMesh (mesh_ptrtype __mesh)

materialsproperties_ptrtype &	materialsProperties ()

materialsproperties_ptrtype const &	materialsProperties () const

mesh_ptrtype	mesh () const

trace_mesh_ptrtype const &	meshDirichletLM () const

auto	modelContext (std::map< std::string, std::tuple< vector_ptrtype, size_type > > const &vectorData, std::string const &prefix="") const

auto	modelContext (std::string const &prefix="") const

auto	modelContext (vector_ptrtype sol, size_type rowStartInVector=0, std::string const &prefix="") const

auto	modelFields (std::map< std::string, std::tuple< vector_ptrtype, size_type > > const &vectorData, std::string const &prefix="") const

auto	modelFields (std::string const &prefix="") const

auto	modelFields (vector_ptrtype sol, size_type rowStartInVector=0, std::string const &prefix="") const

template<typename VelocityFieldType , typename PressureFieldType , typename ModelFieldsBodyType , typename VelocityExtrapolatedFieldType >
auto	modelFields (VelocityFieldType const &field_u, PressureFieldType const &field_p, ModelFieldsBodyType const &mfields_body, VelocityExtrapolatedFieldType const &field_beta_u, std::string const &prefix="") const

multibody_ptrtype	multibody () const

virtual int	nBlockMatrixGraph () const

std::shared_ptr< operatorpcdbase_type >	operatorPCD () const

std::shared_ptr< operatorpmmbase_type >	operatorPMM () const

void	postSolveLinear (vector_ptrtype rhs, vector_ptrtype sol) const override

void	postSolveNewton (vector_ptrtype rhs, vector_ptrtype sol) const override

void	postSolvePicard (vector_ptrtype rhs, vector_ptrtype sol) const override

void	preSolveLinear (vector_ptrtype rhs, vector_ptrtype sol) const override

void	preSolveNewton (vector_ptrtype rhs, vector_ptrtype sol) const override

void	preSolvePicard (vector_ptrtype rhs, vector_ptrtype sol) const override

std::shared_ptr< RangeDistributionByMaterialName< mesh_type > >	rangeDistributionByMaterialName () const

Range< mesh_type, MESH_ELEMENTS > const &	rangeMeshElements () const

void	setApplyMovingMeshBeforeSolve (bool b)

void	setDefinePressureCst (bool b)

void	setDefinePressureCstMethod (std::string s)

void	setDirichletBCnitscheGamma (double val)

void	setDoExport (bool b)

void	setMaterialsProperties (materialsproperties_ptrtype mp)

void	setMesh (mesh_ptrtype const &mesh)

void	setParameterValues (std::map< std::string, double > const &paramValues)

void	setSolverName (std::string const &type)

void	setStabilizationGLSDoAssembly (bool b)

void	setUseSemiImplicitTimeScheme (bool b)

std::shared_ptr< self_type >	shared_from_this ()

void	solve ()

std::string const &	solverName () const

void	solverPtAP_applyQ (vector_ptrtype const &Ud, vector_ptrtype &Ui, size_type rowStartInVector=0) const

double	stabCIPConvectionGamma () const

double	stabCIPDivergenceGamma () const

double	stabCIPPressureGamma () const

bool	stabilizationGLS () const

bool	stabilizationGLS_checkViscosityDependencyOnCoordinates () const

bool	stabilizationGLSDoAssembly () const

range_elements_type const &	stabilizationGLSEltRangeConvectionDiffusion (std::string const &matName) const

range_elements_type const &	stabilizationGLSEltRangePressure (std::string const &matName) const

stab_gls_parameter_ptrtype const &	stabilizationGLSParameterConvectionDiffusion () const

stab_gls_parameter_ptrtype const &	stabilizationGLSParameterPressure () const

std::string const &	stabilizationGLSType () const

bool	startBySolveNewtonian () const

void	startBySolveNewtonian (bool b)

bool	startBySolveStokesStationary () const

void	startBySolveStokesStationary (bool b)

void	startTimeStep (bool applyPreProcess=true)

void	startTimeStepPreProcess ()

template<typename SymbolsExprType = symbols_expression_empty_t>
auto	stressTensorExpr (SymbolsExprType const &se=symbols_expression_empty_t{}) const

template<typename VelocityFieldType , typename PressureFieldType , typename SymbolsExprType = symbols_expression_empty_t>
auto	stressTensorExpr (VelocityFieldType const &u, PressureFieldType const &p, std::string const &matName, SymbolsExprType const &se=symbols_expression_empty_t{}) const

template<typename VelocityFieldType , typename PressureFieldType , typename SymbolsExprType = symbols_expression_empty_t>
auto	stressTensorExpr (VelocityFieldType const &u, PressureFieldType const &p, SymbolsExprType const &se=symbols_expression_empty_t{}) const

template<typename ModelFieldsType >
auto	symbolsExpr (ModelFieldsType const &mfields) const

auto	symbolsExpr (std::string const &prefix="") const

template<typename ModelFieldsType >
auto	symbolsExprToolbox (ModelFieldsType const &mfields) const

tabulate_informations_ptr_t	tabulateInformations (nl::json const &jsonInfo, TabulateInformationProperties const &tabInfoProp) const override

std::shared_ptr< TSBase >	timeStepBase ()

std::shared_ptr< TSBase >	timeStepBase () const

bdf_velocity_ptrtype	timeStepBDF ()

bdf_velocity_ptrtype const &	timeStepBDF () const

std::string const &	timeStepping () const

auto	trialSelectorModelFields (size_type startBlockSpaceIndex=0) const

void	updateDefinePressureCst ()

template<typename SymbolsExprType >
void	updateElasticBody (SymbolsExprType const &se)

template<typename SymbolsExprType >
void	updateFluidInletVelocity (SymbolsExprType const &se)

void	updateInformationObject (nl::json &p) const override

template<typename ModelContextType >
void	updateInHousePreconditioner (DataUpdateBase &data, ModelContextType const &mctx) const

void	updateInHousePreconditioner (DataUpdateJacobian &data) const override

void	updateInHousePreconditioner (DataUpdateLinear &data) const override

template<typename SymbolsExprType >
void	updateInitialConditions (SymbolsExprType const &se)
	update initial conditions with symbols expression \se

void	updateJacobian (DataUpdateJacobian &data) const override

template<typename ModelContextType >
void	updateJacobian (DataUpdateJacobian &data, ModelContextType const &mfields) const

void	updateJacobian_Turbulence (DataUpdateJacobian &data) const

template<typename ModelContextType >
void	updateJacobian_Turbulence (DataUpdateJacobian &data, ModelContextType const &mfields) const

void	updateJacobianDofElimination (DataUpdateJacobian &data) const override

void	updateJacobianStabilisation (DataUpdateJacobian &data, element_velocity_type const &u, element_pressure_type const &p) const

template<typename ModelContextType , typename RangeType , typename... ExprAddedType>
void	updateJacobianStabilizationGLS (DataUpdateJacobian &data, ModelContextType const &mctx, ModelPhysicFluid< nDim > const &physicFluidData, MaterialProperties const &matProps, RangeType const &range, const ExprAddedType &... exprsAddedInResidual) const

void	updateLinear_Turbulence (DataUpdateLinear &data) const

template<typename ModelContextType >
void	updateLinear_Turbulence (DataUpdateLinear &data, ModelContextType const &mfields) const

void	updateLinearDofElimination_Turbulence (DataUpdateLinear &data) const

template<typename ModelContextType >
void	updateLinearDofElimination_Turbulence (DataUpdateLinear &data, ModelContextType const &mfields) const

void	updateLinearPDE (DataUpdateLinear &data) const override

template<typename ModelContextType >
void	updateLinearPDE (DataUpdateLinear &data, ModelContextType const &mfields) const

void	updateLinearPDEDofElimination (DataUpdateLinear &data) const override

template<typename ModelContextType >
void	updateLinearPDEDofElimination (DataUpdateLinear &data, ModelContextType const &mfields) const

void	updateLinearPDEStabilisation (DataUpdateLinear &data) const

template<typename ModelContextType , typename RangeType , typename ExprAddedRhsType = hana::tuple<>, typename ExprAddedLhsType = hana::tuple<>>
void	updateLinearPDEStabilizationGLS (DataUpdateLinear &data, ModelContextType const &mctx, ModelPhysicFluid< nDim > const &physicFluidData, MaterialProperties const &matProps, RangeType const &range, ExprAddedRhsType const &exprsAddedInResidualRhsTuple=hana::make_tuple(), ExprAddedLhsType const &exprsAddedInResidualLhsTuple=hana::make_tuple()) const

void	updateNewtonInitialGuess (DataNewtonInitialGuess &data) const override

template<typename ModelContextType >
void	updateNewtonInitialGuess (DataNewtonInitialGuess &data, ModelContextType const &mfields) const

void	updateNewtonInitialGuess_Turbulence (DataNewtonInitialGuess &data) const

template<typename ModelContextType >
void	updateNewtonInitialGuess_Turbulence (DataNewtonInitialGuess &data, ModelContextType const &mfields) const

void	updateNewtonIteration (int step, vector_ptrtype residual, vector_ptrtype sol, typename backend_type::solvernonlinear_type::UpdateIterationData const &data) const override

void	updateNormalStressOnCurrentMesh (std::string const &nameOfRange, element_normalstress_ptrtype &fieldToUpdate)

void	updateNormalStressOnReferenceMesh (std::string const &nameOfRange, element_normalstress_ptrtype &fieldToUpdate)

void	updateParameterValues ()

void	updatePicardIteration (int step, vector_ptrtype sol) const override

template<typename ExprT >
void	updatePressure (vf::Expr< ExprT > const &__expr)

void	updateRangeDistributionByMaterialName (std::string const &key, range_faces_type const &rangeFaces)

void	updateResidual (DataUpdateResidual &data) const override

template<typename ModelContextType >
void	updateResidual (DataUpdateResidual &data, ModelContextType const &mfields) const

void	updateResidual_Turbulence (DataUpdateResidual &data) const

template<typename ModelContextType >
void	updateResidual_Turbulence (DataUpdateResidual &data, ModelContextType const &mfields) const

void	updateResidualDofElimination (DataUpdateResidual &data) const override

void	updateResidualStabilisation (DataUpdateResidual &data, element_velocity_type const &u, element_pressure_type const &p) const

template<typename ModelContextType , typename RangeType , typename... ExprAddedType>
void	updateResidualStabilizationGLS (DataUpdateResidual &data, ModelContextType const &mctx, ModelPhysicFluid< nDim > const &physicFluidData, MaterialProperties const &matProps, RangeType const &range, const ExprAddedType &... exprsAddedInResidual) const

template<typename ExprT >
void	updateSourceAdded (vf::Expr< ExprT > const &__expr)

void	updateTimeStep ()

template<typename ExprT >
void	updateVelocity (vf::Expr< ExprT > const &__expr)

template<typename ExprT >
void	updateVelocityDiv (vf::Expr< ExprT > const &__expr)

void	updateWallShearStress (std::string const &nameOfRange, element_normalstress_ptrtype &fieldToUpdate)

bool	useFSISemiImplicitScheme () const

void	useFSISemiImplicitScheme (bool b)

bool	useSemiImplicitTimeScheme () const

vector_ptrtype	vectorPreviousVelocityExtrapolated () const

vector_ptrtype	vectorVelocityExtrapolated () const

std::shared_ptr< typename space_pressure_type::element_type >	velocityDiv ()

std::shared_ptr< typename space_pressure_type::element_type > const &	velocityDiv () const

bool	velocityDivIsEqualToZero () const

space_trace_velocity_ptrtype const &	XhDirichletLM () const

space_meanpressurelm_ptrtype const &	XhMeanPressureLM (int k) const

Public Member Functions inherited from Feel::FeelModels::ModelNumerical
virtual bool	checkResults () const

template<typename SymbolsExprType >
bool	checkResults (SymbolsExprType const &se) const

template<typename SpaceType >
auto	createBdf (std::shared_ptr< SpaceType > space, std::string const &name, int bdfOrder, int nConsecutiveSave, std::string const &myFileFormat) const

double	currentTime () const

bool	doRestart () const

template<typename ExporterType , typename ModelFieldsType , typename SymbolsExprType = symbols_expression_empty_t, typename TupleExprOnRangeType = hana::tuple<>>
void	executePostProcessExports (std::shared_ptr< ExporterType > exporter, double time, ModelFieldsType const &mFields, SymbolsExprType const &symbolsExpr=symbols_expression_empty_t{}, TupleExprOnRangeType const &tupleExprOnRange=hana::make_tuple())

template<typename ExporterType , typename ModelFieldsType , typename SymbolsExpr , typename TupleExprOnRangeType >
void	executePostProcessExports (std::shared_ptr< ExporterType > exporter, std::string const &tag, double time, ModelFieldsType const &mFields, SymbolsExpr const &symbolsExpr, TupleExprOnRangeType const &tupleExprOnRange)

template<typename ExporterType , typename ModelFieldsType , typename SymbolsExprType = symbols_expression_empty_t, typename TupleExprOnRangeType = hana::tuple<>>
void	executePostProcessExports (std::shared_ptr< ExporterType > exporter, std::string const &tag, double time, ModelFieldsType const &mFields, SymbolsExprType const &symbolsExpr=symbols_expression_empty_t{}, TupleExprOnRangeType const &tupleExprOnRange=hana::make_tuple())

template<typename MeshType , typename RangeType , typename SymbolsExpr , typename ModelFieldsType , typename ModelQuantitiesType >
void	executePostProcessMeasures (double time, std::shared_ptr< MeshType > mesh, RangeType const &rangeMeshElements, SymbolsExpr const &symbolsExpr, ModelFieldsType const &mFields, ModelQuantitiesType const &mQuantities)

template<typename ModelFieldsType >
void	executePostProcessSave (std::set< std::string > const &fieldsNamesToSave, std::string const &format, uint32_type index, ModelFieldsType const &fields)

template<typename ModelFieldsType >
void	executePostProcessSave (uint32_type index, ModelFieldsType const &fields)

std::string	exporterPath () const

GeomapStrategyType	geomap () const

bool	hasPostProcessExportsExpr (std::string const &exportTag="") const

bool	hasPostProcessExportsField (std::string const &exportTag, std::string const &fieldName) const

bool	hasPostProcessExportsField (std::string const &fieldName) const

bool	isStationary () const

	ModelNumerical (ModelNumerical const &app)=default

	ModelNumerical (std::string const &_theprefix, std::string const &keyword, worldcomm_ptr_t const &_worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository(), ModelBaseCommandLineOptions const &modelCmdLineOpt=ModelBaseCommandLineOptions())

	ModelNumerical (std::string const &_theprefix, worldcomm_ptr_t const &_worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository(), ModelBaseCommandLineOptions const &modelCmdLineOpt=ModelBaseCommandLineOptions())

std::set< std::string > const &	postProcessExportsAllFieldsAvailable (std::string const &exportTag="") const

std::set< std::string > const &	postProcessExportsFields (std::string const &exportTag="") const

std::set< std::string >	postProcessExportsFields (std::string const &tag, std::set< std::string > const &ifields, std::string const &prefix="") const

std::string const &	postProcessExportsPidName (std::string const &exportTag="") const

ModelMeasuresStorage &	postProcessMeasures ()

ModelMeasuresStorage const &	postProcessMeasures () const

std::set< std::string >	postProcessMeasuresQuantitiesNames (std::set< std::string > const &inames) const

std::set< std::string > const &	postProcessSaveFields () const

std::set< std::string >	postProcessSaveFields (std::set< std::string > const &ifields, std::string const &prefix="") const

fs::path const &	postProcessSaveRepository () const

bool	restartAtLastSave () const

std::string	restartPath () const

void	setExporterPath (std::string const &s)

void	setRestart (bool b)

void	setRestartAtLastSave (bool b)

void	setRestartPath (std::string const &s)

void	setStationary (bool b)

void	setTimeFinal (double v)

void	setTimeInitial (double v)

void	setTimeOrder (int o)

void	setTimeStep (double v)

double	time () const

double	timeFinal () const

double	timeInitial () const

int	timeOrder () const

double	timeStep () const

int	tsSaveFreq () const

bool	tsSaveInFile () const

virtual void	updateParameterValues_postProcess (std::map< std::string, double > &mp, std::string const &prefix_symbol) const

template<typename ExporterType , typename ModelFieldsType , typename SymbolsExprType , typename TupleExprOnRangeType >
bool	updatePostProcessExports (std::shared_ptr< ExporterType > exporter, std::set< std::string > const &fields, double time, ModelFieldsType const &mFields, SymbolsExprType const &symbolsExpr, TupleExprOnRangeType const &tupleExprOnRange)

template<typename ExporterType , typename ModelFieldsType , typename SymbolsExpr , typename TupleExprOnRangeType >
bool	updatePostProcessExports (std::shared_ptr< ExporterType > exporter, std::set< std::string > const &fieldsNamesToExport, double time, ModelFieldsType const &mFields, SymbolsExpr const &symbolsExpr, TupleExprOnRangeType const &tupleExprOnRange)

template<typename MeshType , typename RangeType , typename SymbolsExpr , typename ModelFieldsType , typename ModelQuantitiesType >
void	updatePostProcessMeasures (std::shared_ptr< MeshType > mesh, RangeType const &rangeMeshElements, SymbolsExpr const &symbolsExpr, ModelFieldsType const &mFields, ModelQuantitiesType const &mQuantities)

template<typename MeshType , typename RangeType , typename SymbolsExpr , typename ModelFieldsType >
void	updatePostProcessMeasuresNorm (std::shared_ptr< MeshType > mesh, RangeType const &rangeMeshElements, SymbolsExpr const &symbolsExpr, ModelFieldsType const &mFields)

template<typename MeasurePointEvalType , typename SymbolsExprType , typename ModelFieldsType >
void	updatePostProcessMeasuresPoint (std::shared_ptr< MeasurePointEvalType > measurePointsEvaluation, SymbolsExprType const &se, ModelFieldsType const &mFields)

template<typename ModelQuantitiesType , typename SymbolsExprType = symbols_expression_empty_t>
void	updatePostProcessMeasuresQuantities (ModelQuantitiesType const &mQuantities, SymbolsExprType const &symbolsExpr=symbols_expression_empty_t{})

template<typename MeshType , typename RangeType , typename SymbolsExpr , typename ModelFieldsType >
void	updatePostProcessMeasuresStatistics (std::shared_ptr< MeshType > mesh, RangeType const &rangeMeshElements, SymbolsExpr const &symbolsExpr, ModelFieldsType const &mFields)

void	updateTime (double t)

Public Member Functions inherited from Feel::FeelModels::ModelBase
void	addParameterInModelProperties (std::string const &symbolName, double value)

void	addTimerTool (std::string const &s, std::string const &fileName) const

po::variables_map const &	clovm () const
	return variables map from command line options

virtual void	createWorldsComm ()

bool	hasModelProperties () const

void	initModelProperties ()

bool	isUpdatedForUse () const

std::string const &	keyword () const
	keyword

worldscomm_ptr_t &	localNonCompositeWorldsComm ()

worldscomm_ptr_t const &	localNonCompositeWorldsComm () const

void	log (std::string const &_className, std::string const &_functionName, std::string const &_msg) const

bool	manageParameterValues () const

bool	manageParameterValuesOfModelProperties () const

	ModelBase (ModelBase &&app)=default

	ModelBase (ModelBase const &app)=default

	ModelBase (std::string const &prefix, std::string const &keyword, worldcomm_ptr_t const &worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository(), ModelBaseCommandLineOptions const &modelCmdLineOpt=ModelBaseCommandLineOptions())

	ModelBase (std::string const &prefix, worldcomm_ptr_t const &worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository(), ModelBaseCommandLineOptions const &modelCmdLineOpt=ModelBaseCommandLineOptions())

ModelProperties &	modelProperties ()

ModelProperties const &	modelProperties () const

std::shared_ptr< ModelProperties >	modelPropertiesPtr () const

std::string const &	prefix () const

void	printAndSaveInfo () const

void	printInfo () const

ModelBaseRepository const &	repository () const

std::string const &	rootRepository () const

void	saveInfo () const

std::string	scalabilityFilename () const

std::string	scalabilityPath () const

bool	scalabilityReinitSaveFile () const

bool	scalabilitySave () const

void	setIsUpdatedForUse (bool b)

void	setLocalNonCompositeWorldsComm (worldscomm_ptr_t &_worldsComm)

void	setManageParameterValues (bool b)

void	setManageParameterValuesOfModelProperties (bool b)

void	setModelProperties (nl::json const &j)
	Set the Model Properties object from a json struct the json may come from python. More...

void	setModelProperties (std::shared_ptr< ModelProperties > modelProps)

void	setModelProperties (std::string const &filename)
	Set the Model Properties object from a filename. More...

void	setScalabilityFilename (std::string const &s)

void	setScalabilityPath (std::string const &s)

void	setScalabilitySave (bool b)

void	setWorldsComm (worldscomm_ptr_t &_worldsComm)

std::string const &	subPrefix () const

auto	symbolsExprParameter () const

tabulate_informations_ptr_t	tabulateInformations () const

virtual tabulate_informations_ptr_t	tabulateInformations (nl::json const &jsonInfo, TabulateInformationProperties const &tabInfoProp) const

TimerToolBase &	timerTool (std::string const &s) const

void	updateInformationObject (nl::json &p) const override

ModelBaseUpload const &	upload () const

void	upload (std::string const &dataPath) const

bool	verbose () const

bool	verboseAllProc () const

worldcomm_t &	worldComm ()

worldcomm_t const &	worldComm () const

worldcomm_ptr_t &	worldCommPtr ()

worldcomm_ptr_t const &	worldCommPtr () const

worldscomm_ptr_t &	worldsComm ()

worldscomm_ptr_t const &	worldsComm () const

Public Member Functions inherited from Feel::JournalWatcher
	JournalWatcher (std::string const &category="", std::string const &name="", bool connect=JournalManager::journalAutoMode())
	Constructors. More...

	JournalWatcher (std::string const &category, bool useDefaultName, bool connect=JournalManager::journalAutoMode())

	JournalWatcher (function_update_information_type const &func, std::string const &category="", std::string const &name="", bool useDefaultNameIfEmpty=true, bool connect=JournalManager::journalAutoMode())

	JournalWatcher (JournalWatcher const &jw)
	Copy constructor.

virtual	~JournalWatcher ()
	Default destructor. The (inherited) object is always disconnected from the journal during the destruction.

bool	journalIsConnected () const
	GettersCheck if the object is connected to the journal. More...

std::string const &	journalWatcherInstanceName () const
	Return the full instance name for this watched object. The name is composed with the base name and a suffix index corresponding to the nth call. More...

nl::json::json_pointer	journalSection () const
	Return the section into the journal as json_pointer.

nl::json const &	informationObject () const
	Return the information into property tree.

void	journalConnect ()
	Setters. More...

void	journalDisconnect ()
	Disconnect the derived object from the simulation info manager. The disconnection is safe.

void	setInformationObject (nl::json const &informationObject)
	set information object

void	putInformationObject (nl::json const &informationObject)
	put information object

void	addInformationObject (nl::json const &informationObject)
	add information object

void	journalFinalize ()
	finalize journal publication

Public Member Functions inherited from Feel::FeelModels::ModelAlgebraic
backend_ptrtype	algebraicBackend (std::string const &name="") const

block_vector_ptrtype	algebraicBlockVectorSolution (std::string const &name="") const

model_algebraic_factory_ptrtype	algebraicFactory (std::string const &name="") const

backend_ptrtype	backend () const

virtual block_pattern_type	blockPattern () const
	return an empty blockPattern if not overhead

virtual BlocksBaseGraphCSR	buildBlockMatrixGraph () const

virtual graph_ptrtype	buildMatrixGraph () const

void	clearDofEliminationIds ()

void	clearStartSubBlockSpaceIndex ()

size_type	colStartInMatrix () const

std::map< std::string, dof_elimination_ids_value_type > const &	dofEliminationIds () const

dof_elimination_ids_value_type const &	dofEliminationIds (std::string const &spaceName) const

std::set< size_type > &	dofEliminationIdsAll (std::string const &spaceName, ElementsType e)

bool	errorIfSolverNotConverged () const

bool	hasDofEliminationIds (std::string const &spaceName) const

bool	hasStartSubBlockSpaceIndex (std::string const &name) const

void	initAlgebraicBackend (std::string const &name="")

block_vector_ptrtype	initAlgebraicBlockVectorSolution (int nBlock, std::string const &name="")

	ModelAlgebraic (ModelAlgebraic const &app)=default

	ModelAlgebraic (std::string _theprefix, std::string const &keyword, worldcomm_ptr_t const &_worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository(), ModelBaseCommandLineOptions const &modelCmdLineOpt=ModelBaseCommandLineOptions())

	ModelAlgebraic (std::string _theprefix, worldcomm_ptr_t const &_worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository(), ModelBaseCommandLineOptions const &modelCmdLineOpt=ModelBaseCommandLineOptions())

bool	needToRebuildCstPart () const

virtual void	postSolveLinear (vector_ptrtype rhs, vector_ptrtype sol) const

virtual void	postSolveNewton (vector_ptrtype rhs, vector_ptrtype sol) const

virtual void	postSolvePicard (vector_ptrtype rhs, vector_ptrtype sol) const

virtual void	preSolveLinear (vector_ptrtype rhs, vector_ptrtype sol) const

virtual void	preSolveNewton (vector_ptrtype rhs, vector_ptrtype sol) const

virtual void	preSolvePicard (vector_ptrtype rhs, vector_ptrtype sol) const

bool	printGraph () const

std::string	printGraphFileName () const

bool	rebuildCstPartInLinearSystem () const

bool	rebuildCstPartInResidual () const

bool	rebuildLinearPartInJacobian () const

void	removeAllAlgebraicDataAndTools ()

size_type	rowStartInMatrix () const
	index start of (sub-)block

size_type	rowStartInVector () const

void	setAlgebraicBackend (backend_ptrtype backend)

void	setAlgebraicBackend (std::string const &name, backend_ptrtype backend)

void	setAlgebraicFactory (model_algebraic_factory_ptrtype algFact)

void	setAlgebraicFactory (std::string const &name, model_algebraic_factory_ptrtype algFact)

void	setErrorIfSolverNotConverged (bool b)

void	setNeedToRebuildCstPart (bool b)

void	setPrintGraph (bool b)

void	setPrintGraphFileName (std::string s)

void	setRebuildCstPartInLinearSystem (bool b)

void	setRebuildCstPartInResidual (bool b)

void	setRebuildLinearPartInJacobian (bool b)

void	setStartBlockSpaceIndex (size_type s)

void	setStartBlockSpaceIndexMatrixCol (size_type s)

void	setStartBlockSpaceIndexMatrixRow (size_type s)

void	setStartBlockSpaceIndexVector (size_type s)

void	setStartSubBlockSpaceIndex (std::string const &name, size_type s)

void	setUseCstMatrix (bool b)

void	setUseCstVector (bool b)

void	setUseLinearJacobianInResidual (bool b)

size_type	startBlockSpaceIndexMatrixCol () const

size_type	startBlockSpaceIndexMatrixRow () const

size_type	startBlockSpaceIndexVector () const

size_type	startSubBlockSpaceIndex (std::string const &name) const

template<typename DataType >
void	updateDofEliminationIds (std::string const &spaceName, DataType &data) const
	update data useful for mpi synchronization of NewtonInitialGuess, impose value in residual or jacobian

void	updateDofEliminationIds (std::string const &spaceName, dof_elimination_ids_value_type const &dofIds, DataNewtonInitialGuess &data) const

void	updateDofEliminationIds (std::string const &spaceName, dof_elimination_ids_value_type const &dofIds, DataUpdateJacobian &data) const

void	updateDofEliminationIds (std::string const &spaceName, dof_elimination_ids_value_type const &dofIds, DataUpdateResidual &data) const

template<typename SpaceType , typename RangeType >
void	updateDofEliminationIds (std::string const &spaceName, std::shared_ptr< SpaceType > thespace, RangeType const &therange, ComponentType c1=ComponentType::NO_COMPONENT)

virtual void	updateInHousePreconditioner (DataUpdateJacobian &data) const

virtual void	updateInHousePreconditioner (DataUpdateLinear &data) const

virtual void	updateJacobian (DataUpdateJacobian &data) const

virtual void	updateJacobianDofElimination (DataUpdateJacobian &data) const

virtual void	updateLinearPDE (DataUpdateLinear &data) const

virtual void	updateLinearPDEDofElimination (DataUpdateLinear &data) const

virtual void	updateNewtonInitialGuess (DataNewtonInitialGuess &data) const

virtual void	updateNewtonIteration (int step, vector_ptrtype residual, vector_ptrtype sol, typename backend_type::solvernonlinear_type::UpdateIterationData const &data) const

virtual void	updatePicardIteration (int step, vector_ptrtype sol) const

virtual void	updateResidual (DataUpdateResidual &data) const

virtual void	updateResidualDofElimination (DataUpdateResidual &data) const

bool	useCstMatrix () const

bool	useCstVector () const

bool	useLinearJacobianInResidual () const

bool	verboseSolverTimer () const

bool	verboseSolverTimerAllProc () const

Public Member Functions inherited from Feel::FeelModels::ModelMeshes< ModelAlgebraic::index_type >
void	applyRemesh (std::string const &meshName, std::shared_ptr< MeshType > const &newMesh)

bool	hasMeshMotion (std::string const &meshName) const

bool	hasModelMesh (std::string const &meshName) const

void	initMeasurePointsEvaluationTool (std::string const &meshName)

auto	measurePointsEvaluationTool (std::string const &meshName)

auto	mesh (std::string const &meshName) const

auto	meshMotionTool (std::string const &meshName) const

auto	modelFields (std::string const &prefix_field, std::string const &prefix_symbol="") const

ModelMesh< ModelAlgebraic::index_type > &	modelMesh ()

ModelMesh< ModelAlgebraic::index_type > const &	modelMesh () const

ModelMesh< ModelAlgebraic::index_type > &	modelMesh (std::string const &meshName)

ModelMesh< ModelAlgebraic::index_type > const &	modelMesh (std::string const &meshName) const

	ModelMeshes (ModelMeshes &&)=default

	ModelMeshes (ModelMeshes const &)=default

std::string	repository_meshes () const

void	saveMetadata () const

void	setMesh (std::string const &meshName, mesh_base_ptrtype m)

void	setModelMeshAsShared (ModelMesh< ModelAlgebraic::index_type > const &m)

void	setModelMeshAsShared (std::string const &meshName, ModelMesh< ModelAlgebraic::index_type > const &m)
	shared data (mesh,space,...) between several ModelMesh

void	setParameterValues (std::map< std::string, double > const &paramValues)

void	setup (nl::json const &jarg)

void	setup (nl::json const &jarg, std::set< std::string > const &keywordsToSetup)

void	setupRestart (std::string const &meshName)

auto	symbolsExpr (std::string const &prefix_symbol="meshes") const

tabulate_informations_ptr_t	tabulateInformations (nl::json const &jsonInfo, TabulateInformationProperties const &tabInfoProp) const override

void	updateForUse (std::string const &meshName)

void	updateInformationObject (nl::json &p) const override

void	updateInformationObject (nl::json &p, std::string const &prefix_symbol) const

void	updateMeshAdaptation (std::string const &meshName, std::shared_ptr< typename mesh_adaptation_type::Event > event, SymbolsExprType const &se)

void	updateMeshMotion (std::string const &meshName, SymbolsExprType const &se)

void	updateTime (double time)

Public Member Functions inherited from Feel::FeelModels::ModelPhysics< ConvexType::nDim >
void	addPhysics (std::map< physic_id_type, std::shared_ptr< ModelPhysic< Dim > > > const &thePhysics)
	add physics if not already registered

bool	hasPhysic (physic_id_type const &pId) const
	return true if physic id is already registered

void	initPhysics (std::shared_ptr< ModelPhysics< nDim > > mphysics, ModelModels const &models)

void	initPhysics (std::shared_ptr< ModelPhysics< nDim > > mphysics, std::function< void(PhysicsTree &)> lambdaInit)

	ModelPhysics (ModelPhysics &&)=default

	ModelPhysics (ModelPhysics const &)=default

	ModelPhysics (std::string const &modeling)

	ModelPhysics (std::string const &modeling, ModelBase &&mbase)

	ModelPhysics (std::string const &modeling, ModelBase const &mbase)

std::shared_ptr< ModelPhysic< Dim > >	physic (physic_id_type const &pId) const
	return physic registered from physic id

std::string const &	physicModeling () const
	return the physic modeling

std::map< physic_id_type, std::shared_ptr< ModelPhysic< nDim > > > const &	physics () const
	return all physics registered

std::map< physic_id_type, std::shared_ptr< ModelPhysic< Dim > > >	physics (std::string const &type) const
	return all physics registered related to a type of physic

std::set< physic_id_type >	physicsAvailable () const
	return name of all physics registered

std::set< physic_id_type >	physicsAvailable (std::string const &type) const
	return name of all physics registered related to a type of physic

std::set< physic_id_type >	physicsAvailableFromCurrentType () const
	return name of all physics registered related to the current type

std::map< physic_id_type, std::shared_ptr< ModelPhysic< nDim > > >	physicsFromCurrentType () const
	return all physics registered related to the current type

std::string const &	physicType () const
	return the type of physic at top level

auto	symbolsExprPhysics (std::map< physic_id_type, std::shared_ptr< ModelPhysic< nDim > > > const &mphysics) const

auto	symbolsExprPhysicsFromCurrentType () const

tabulate_informations_ptr_t	tabulateInformations (nl::json const &jsonInfo, TabulateInformationProperties const &tabInfoProp) const override

void	updateInformationObjectFromCurrentType (nl::json &p) const

Static Public Member Functions
static self_ptrtype	New (std::string const &prefix, std::string const &keyword="fluid", worldcomm_ptr_t const &worldComm=Environment::worldCommPtr(), std::string const &subPrefix="", ModelBaseRepository const &modelRep=ModelBaseRepository())

Static Public Attributes
static const uint16_type	nDim = convex_type::nDim

static const uint16_type	nOrderGeo = convex_type::nOrder

static const uint16_type	nOrderPressure = BasisPressureType::nOrder

static const uint16_type	nOrderVelocity = BasisVelocityType::nOrder

static const uint16_type	nRealDim = convex_type::nRealDim

static const bool	useMixedBasis = true

Static Public Attributes inherited from Feel::FeelModels::ModelPhysics< ConvexType::nDim >
static const uint16_type	nDim

Additional Inherited Members
Protected Types inherited from Feel::FeelModels::ModelNumerical
using	super_model_base_type = ModelBase

using	super_model_meshes_type = ModelMeshes< typename ModelAlgebraic::index_type >

Protected Member Functions inherited from Feel::FeelModels::ModelNumerical
void	addPostProcessExportsAllFieldsAvailable (std::set< std::string > const &ifields)

void	addPostProcessExportsAllFieldsAvailable (std::string const &exportTag, std::set< std::string > const &ifields)

void	addPostProcessMeasuresQuantitiesAllNamesAvailable (std::set< std::string > const &inames)

virtual void	initPostProcess ()

template<typename MeshType , typename SymbolsExprType >
void	initPostProcessMeshes (SymbolsExprType const &se)

template<typename MeshType >
auto	modelFieldsMeshes (std::string const &prefix_field="", std::string const &prefix_symbol="") const

void	setPostProcessExportsAllFieldsAvailable (std::set< std::string > const &ifields)

void	setPostProcessExportsAllFieldsAvailable (std::string const &exportTag, std::set< std::string > const &ifields)

void	setPostProcessExportsPidName (std::string const &exportTag, std::string const &pidName)

void	setPostProcessExportsPidName (std::string const &pidName)

void	setPostProcessMeasuresQuantitiesAllNamesAvailable (std::set< std::string > const &inames)

void	setPostProcessSaveAllFieldsAvailable (std::set< std::string > const &ifields)

template<typename MeshType , bool AddFields = true>
auto	symbolsExprMeshes () const

template<typename ElementType , typename RangeType , typename SymbolsExpr >
void	updateInitialConditions (std::string const &fieldName, RangeType const &defaultRange, SymbolsExpr const &symbolsExpr, std::vector< std::shared_ptr< ElementType > > &dataToUpdate, std::map< int, double > const &priorTimes={{0, 0}})

Protected Member Functions inherited from Feel::JournalWatcher
void	applyUpdateInformationObject ()
	Protected Methods.

Protected Member Functions inherited from Feel::FeelModels::ModelPhysics< ConvexType::nDim >
std::vector< std::shared_ptr< ModelPhysic< Dim > > >	initPhysics (std::string const &type, ModelModels const &models, std::set< std::string > const &modelNameRequired, bool isRequired=true)

virtual void	updatePhysics (PhysicsTreeNode &physicsTree, ModelModels const &models)

Protected Attributes inherited from Feel::FeelModels::ModelPhysics< ConvexType::nDim >
std::string	M_physicModeling

std::map< physic_id_type, std::shared_ptr< ModelPhysic< nDim > > >	M_physics

Detailed Description

template<typename ConvexType, typename BasisVelocityType, typename BasisPressureType = Lagrange< (BasisVelocityType::nOrder>1)? (BasisVelocityType::nOrder-1):BasisVelocityType::nOrder, Scalar,Continuous,PointSetFekete>>
class Feel::FeelModels::FluidMechanics< ConvexType, BasisVelocityType, BasisPressureType >

Fluid Mechanics Toolbox.

Template Parameters

ConvexType
BasisVelocityType
BasisPressureType