Feel::BlockBilinearForm< TestPS, TrialPS > Class Template Reference

forward declarations of BlockBilinearForm and blocform2() More...

Collaboration diagram for Feel::BlockBilinearForm< TestPS, TrialPS >:

Classes
struct	DeferredDirichletState
class	RowDirichletView

Public Types
using	condensed_matrix_ptrtype = std::shared_ptr< condensed_matrix_type >
using	condensed_matrix_type = MatrixCondensed< value_type >
using	deferred_dirichlet_set_type = vf::DeferredDirichletSet< value_type >
using	post_solve_type = typename Backend< value_type >::post_solve_type
using	pre_solve_type = typename Backend< value_type >::pre_solve_type
using	product_space_t = test_product_space_t
using	size_type = typename condensed_matrix_type::size_type
using	sparse_matrix_ptrtype = typename condensed_matrix_type::sparse_matrix_ptrtype
using	test_product_space_t = decay_type< TestPS >
using	trial_product_space_t = decay_type< TrialPS >
using	value_type = typename Feel::decay_type< TestPS >::value_type
using	vector_ptrtype = typename vector_type::clone_ptrtype
using	vector_type = Vector< value_type >

Public Member Functions
sparse_matrix_ptrtype	activeMatrixPtr ()
sparse_matrix_ptrtype	activeMatrixPtr () const
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
sparse_matrix_ptrtype	activeMatrixPtr (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
sparse_matrix_ptrtype	activeMatrixPtr (RhsType const &rhs)
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
auto	activeSystem (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
auto	activeSystem (RhsType const &rhs)
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
auto	activeVectorPtr (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
auto	activeVectorPtr (RhsType const &rhs)
void	allocateMatrix (solve::strategy s=solve::strategy::monolithic, backend_ptrtype const &b=backend())
	allocate algebraic representation of the bilinear form More...
template<typename CondensedFormT , typename CondensedRhsT >
void	applyDeferredDirichlet (CondensedFormT &condensedForm, CondensedRhsT &condensedRhs)
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
void	applyDeferredDirichlet (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
void	applyDeferredDirichlet (RhsType const &rhs)
BlockBilinearForm &	autoDirichlet () noexcept
sparse_matrix_ptrtype	baseMatrixPtr ()
sparse_matrix_ptrtype	baseMatrixPtr () const
bool	baseOperatorClosed () const noexcept
	BlockBilinearForm (BlockBilinearForm &&)=default
	BlockBilinearForm (BlockBilinearForm const &)=default
	BlockBilinearForm (product_space_t &&ps, condensed_matrix_ptrtype &m)
	BlockBilinearForm (product_space_t const &ps, condensed_matrix_ptrtype &m)
template<typename T > requires StaticProductSpacesType<T>
	BlockBilinearForm (T &&ps)
template<typename T > requires DynamicProductSpaceType<T>
	BlockBilinearForm (T &&ps)
template<typename T , typename BackendT , typename RangeMapT = StencilRangeMap0Type> requires StaticProductSpacesType<T> && Feel::detail::is_backend_like_v<BackendT>
	BlockBilinearForm (T &&ps, BackendT &&b, RangeMapT r=stencilRangeMap())
template<typename T , typename BackendT , typename RangeMapT > requires StaticProductSpacesType<T> && Feel::detail::is_backend_like_v<BackendT>
	BlockBilinearForm (T &&ps, solve::strategy s, BackendT &&b, size_type pattern=Pattern::COUPLED, RangeMapT r=stencilRangeMap())
template<typename T , typename BackendT , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires StaticProductSpacesType<T> && Feel::detail::is_backend_like_v<BackendT>
	BlockBilinearForm (T &&ps, solve::strategy s, BackendT &&b, std::vector< PatternSizeT > const &patterns, RangeMapT r=stencilRangeMap())
template<typename TestT , typename TrialT > requires ( StaticProductSpacesType<TestT> || DynamicProductSpaceType<TestT> ) && ( StaticProductSpacesType<TrialT> || DynamicProductSpaceType<TrialT> )
	BlockBilinearForm (TestT &&testPs, TrialT &&trialPs)
template<typename TestT , typename TrialT , typename BackendT , typename RangeMapT = StencilRangeMap0Type> requires ( StaticProductSpacesType<TestT> || DynamicProductSpaceType<TestT> ) && ( StaticProductSpacesType<TrialT> || DynamicProductSpaceType<TrialT> ) && Feel::detail::is_backend_like_v<BackendT>
	BlockBilinearForm (TestT &&testPs, TrialT &&trialPs, BackendT &&b, RangeMapT r=stencilRangeMap())
template<typename TestT , typename TrialT , typename BackendT , typename RangeMapT = StencilRangeMap0Type> requires ( StaticProductSpacesType<TestT> || DynamicProductSpaceType<TestT> ) && ( StaticProductSpacesType<TrialT> || DynamicProductSpaceType<TrialT> ) && Feel::detail::is_backend_like_v<BackendT>
	BlockBilinearForm (TestT &&testPs, TrialT &&trialPs, solve::strategy s, BackendT &&b, size_type pattern=Pattern::COUPLED, RangeMapT r=stencilRangeMap())
template<typename TestT , typename TrialT , typename BackendT , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires ( StaticProductSpacesType<TestT> || DynamicProductSpaceType<TestT> ) && ( StaticProductSpacesType<TrialT> || DynamicProductSpaceType<TrialT> ) && Feel::detail::is_backend_like_v<BackendT>
	BlockBilinearForm (TestT &&testPs, TrialT &&trialPs, solve::strategy s, BackendT &&b, std::vector< PatternSizeT > const &patterns, RangeMapT r=stencilRangeMap())
void	clearDeferredDirichlet ()
	Clear deferred constraints before in-place materialization. More...
void	close ()
void	closeBaseOperator ()
sparse_matrix_ptrtype	constrainedMatrixPtr ()
sparse_matrix_ptrtype	constrainedMatrixPtr () const
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
sparse_matrix_ptrtype	constrainedMatrixPtr (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
sparse_matrix_ptrtype	constrainedMatrixPtr (RhsType const &rhs)
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
auto	constrainedSystem (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
auto	constrainedSystem (RhsType const &rhs)
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
auto	constrainedVectorPtr (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
auto	constrainedVectorPtr (RhsType const &rhs)
BlockBilinearForm &	deferDirichlet () noexcept
void	deferZeroRows (std::vector< int > const &dofs, std::vector< value_type > const &values, Feel::Context const &on_context, double value_on_diagonal, std::uint8_t entity_priority=vf::deferredDirichletEntityPriority(vf::DeferredDirichletEntity::unspecified))
bool	dirichletInPlace () const noexcept
vf::DeferredDirichletPolicy	dirichletPolicy () const noexcept
product_space_t	functionSpace () const
bool	hasDeferredDirichlet () const noexcept
bool	hasDirichletConstraints () const noexcept
bool	hasMaterializedConstrainedOperator () const noexcept
bool	hasPendingDirichletConstraints () const noexcept
bool	hasUnconstrainedMatrix () const noexcept
BlockBilinearForm &	immediateDirichlet () noexcept
bool	isMatrixAllocated () const
bool	isRectangular () const
auto	l1Norm () const
auto	linftyNorm () const
std::size_t	localStoredDirichletColumnEntryCount () const noexcept
void	materializeConstrainedOperator ()
template<typename RhsType > requires requires( RhsType& rhs ) { rhs.vectorPtr(); }
void	materializeConstrainedOperator (RhsType &rhs)
template<typename RhsType > requires requires( RhsType const& rhs ) { rhs.vectorPtr(); }
void	materializeConstrainedOperator (RhsType const &rhs)
condensed_matrix_type &	matrix ()
condensed_matrix_type const &	matrix () const
sparse_matrix_ptrtype	matrixPtr ()
sparse_matrix_ptrtype	matrixPtr () const
std::size_t	nnz () const
decltype(auto)	operator() (int n1, int n2)
template<typename N1 , typename N2 >
decltype(auto)	operator() (N1 n1, N2 n2, int s1=0, int s2=0)
BlockBilinearForm &	operator+= (BlockBilinearForm &a)
BlockBilinearForm &	operator= (BlockBilinearForm &&a)=default
BlockBilinearForm &	operator= (BlockBilinearForm const &a)
template<typename N1 > requires Feel::detail::BlockformStaticProductSpaces<test_product_space_t>
decltype(auto)	row (N1 n1, int s1=0)
void	setDirichletInPlace (bool value)
	Select in-place (true, default) or two-matrix Dirichlet materialization. More...
void	setDirichletPolicy (vf::DeferredDirichletPolicy policy) noexcept
template<typename T >
void	setFunctionSpace (T &&ps)
template<typename TestT , typename TrialT >
void	setFunctionSpaces (TestT &&testPs, TrialT &&trialPs)
template<typename BackendT >
void	setStrategy (BackendT &&b)
template<typename BackendT >
void	setStrategy (solve::strategy s, BackendT &&b, size_type pattern=Pattern::COUPLED)
template<typename BackendT , typename PatternSizeT >
void	setStrategy (solve::strategy s, BackendT &&b, std::vector< PatternSizeT > const &patterns)
void	setUseDeferredDirichlet (bool value) noexcept
bool	shouldDeferDirichlet (Feel::Context const &on_context) const noexcept
template<typename ... Ts>
Backend< double >::solve_return_type	solve (Ts &&... v)
template<typename Solution_t , typename Rhs_t >
Backend< double >::solve_return_type	solveImpl (Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind="petsc", bool rebuild=false, pre_solve_type pre=pre_solve_type(), post_solve_type post=post_solve_type())
template<typename PS_t , typename Solution_t , typename Rhs_t , typename CT > requires DynamicProductSpaceType<PS_t> && CondenserTag<CT>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, CT ct)
template<typename PS_t , typename Solution_t , typename Rhs_t , typename CT > requires FoldableProductSpacesType<PS_t> && CondenserTag<CT>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, CT ct)
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, hana::integral_constant< int, 1 >)
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, hana::integral_constant< int, 2 >)
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, hana::integral_constant< int, 3 *5 >)
	solve using static condensation in the case of 2 trace spaces
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, hana::integral_constant< int, 3 >)
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, hana::integral_constant< int, 4 >)
	solve using static condensation in the case of 2 trace spaces
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplCondense (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post, hana::integral_constant< int, 5 >)
	solve using static condensation in the case of 2 trace spaces
template<typename PS_t , typename Solution_t , typename Rhs_t >
Backend< double >::solve_return_type	solveImplCondenseTwoFieldInternal (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post)
template<typename PS_t , typename Solution_t , typename Rhs_t > requires StaticProductSpacesType<PS_t>
Backend< double >::solve_return_type	solveImplLocal (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post)
template<typename PS_t , typename Solution_t , typename Rhs_t > requires DynamicProductSpaceType<PS_t>
Backend< double >::solve_return_type	solveImplLocal (PS_t &ps, Solution_t &solution, Rhs_t const &rhs, std::string const &name, std::string const &kind, bool rebuild, pre_solve_type pre, post_solve_type post)
bool	supportsConstrainedOperatorView () const noexcept
void	syncLocalMatrix ()
test_product_space_t	testFunctionSpace () const
void	transpose (int n1, int n2)
trial_product_space_t	trialFunctionSpace () const
bool	useDeferredDirichlet () const noexcept
void	zero ()
void	zero (int n1, int n2)

Detailed Description

template<typename TestPS, typename TrialPS>
class Feel::BlockBilinearForm< TestPS, TrialPS >

forward declarations of BlockBilinearForm and blocform2()

Handles bilinear form over a product of spaces.

Member Function Documentation

allocateMatrix()

template<typename TestPS , typename TrialPS >

void Feel::BlockBilinearForm< TestPS, TrialPS >::allocateMatrix	(	solve::strategy	s = solve::strategy::monolithic,
		backend_ptrtype const &	b = backend()
	)

allocate algebraic representation of the bilinear form

Parameters

s	the solve strategy (monolithic, static condensation or local)
b	the algebraic backend to use (petsc or eigen)

clearDeferredDirichlet()

template<typename TestPS , typename TrialPS >

void Feel::BlockBilinearForm< TestPS, TrialPS >::clearDeferredDirichlet

(

)

Clear deferred constraints before in-place materialization.

After in-place materialization, call zero() and reassemble because the eliminated columns cannot be reconstructed from metadata.

dirichletInPlace()

template<typename TestPS , typename TrialPS >

bool Feel::BlockBilinearForm< TestPS, TrialPS >::dirichletInPlace ( ) const

noexcept

Returns

true when deferred constraints are materialized in place.

hasUnconstrainedMatrix()

template<typename TestPS , typename TrialPS >

bool Feel::BlockBilinearForm< TestPS, TrialPS >::hasUnconstrainedMatrix ( ) const

noexcept

Returns

true while the original unconstrained block operator is available.

isMatrixAllocated()

template<typename TestPS , typename TrialPS >

bool Feel::BlockBilinearForm< TestPS, TrialPS >::isMatrixAllocated

(

)

const

Returns

true if allocated, false otherwise

localStoredDirichletColumnEntryCount()

template<typename TestPS , typename TrialPS >

std::size_t Feel::BlockBilinearForm< TestPS, TrialPS >::localStoredDirichletColumnEntryCount ( ) const

noexcept

Returns

number of sparse Dirichlet-column entries retained on this rank.

nnz()

template<typename TestPS , typename TrialPS >

std::size_t Feel::BlockBilinearForm< TestPS, TrialPS >::nnz

(

)

const

Returns

the number of non-zero entries in matrix representation

setDirichletInPlace()

template<typename TestPS , typename TrialPS >

void Feel::BlockBilinearForm< TestPS, TrialPS >::setDirichletInPlace

(

bool

value

)

Select in-place (true, default) or two-matrix Dirichlet materialization.

Ordinary row elimination needs no auxiliary matrix data. Symmetric elimination retains only the sparse Dirichlet-column entries required to refresh the RHS when prescribed values change. Compatibility mode preserves the unconstrained matrix and clones the complete sparse matrix.