Feel::OperatorLagrangeP1< SpaceType > Class Template Reference

#include <operatorlagrangep1.hpp>

Detailed Description

template<typename SpaceType>
class Feel::OperatorLagrangeP1< SpaceType >

Author

build a P1 Lagrange dof-equivalent space from a FunctionSpace

See Also

FunctionSpace

Inheritance diagram for Feel::OperatorLagrangeP1< SpaceType >:

Public Types
Typedefs
typedef super::domain_space_type	domain_space_type
typedef super::domain_space_ptrtype	domain_space_ptrtype
typedef domain_space_type::mesh_type	domain_mesh_type
typedef domain_space_type::mesh_ptrtype	domain_mesh_ptrtype
typedef domain_space_type::value_type	value_type
typedef domain_space_type::fe_type	domain_fe_type
typedef super::backend_ptrtype	backend_ptrtype
typedef super::dual_image_space_type	dual_image_space_type
typedef super::dual_image_space_ptrtype	dual_image_space_ptrtype
typedef dual_image_space_type::mesh_type	image_mesh_type
typedef dual_image_space_type::mesh_ptrtype	image_mesh_ptrtype
typedef dual_image_space_type::fe_type	image_fe_type
typedef std::vector< std::list < size_type > >	el2el_type
typedef detailOpLagP1::SpaceToLagrangeP1Space < SpaceType >::convex_type	domain_convex_type
typedef detailOpLagP1::SpaceToLagrangeP1Space < SpaceType > ::domain_reference_convex_type	domain_reference_convex_type
typedef detailOpLagP1::SpaceToLagrangeP1Space < SpaceType > ::image_convex_type	image_convex_type
typedef PointSetFekete < domain_reference_convex_type, domain_space_type::basis_type::nOrder, value_type >	pset_type
typedef PointSetToMesh < domain_reference_convex_type, value_type >	p2m_type
typedef domain_mesh_type::gm_type	gm_type
typedef domain_mesh_type::element_type	element_type
typedef gm_type::template Context< vm::POINT, element_type >	gmc_type
typedef boost::shared_ptr < gmc_type >	gmc_ptrtype
typedef gm_type::precompute_ptrtype	gmpc_ptrtype
Public Types inherited from Feel::OperatorLinear< SpaceType, detailOpLagP1::SpaceToLagrangeP1Space< SpaceType >::image_space_type >
typedef super::backend_ptrtype	backend_ptrtype
typedef super::backend_type	backend_type
typedef domain_space_type::template Element< typename domain_space_type::value_type, typename VectorUblas< typename domain_space_type::value_type > ::range::type >	domain_element_range_type
typedef domain_space_type::template Element< typename domain_space_type::value_type, typename VectorUblas< typename domain_space_type::value_type > ::slice::type >	domain_element_slice_type
typedef domain_space_type::element_type	domain_element_type
typedef super::domain_space_ptrtype	domain_space_ptrtype
typedef super::domain_space_type	domain_space_type
typedef dual_image_space_type::template Element< typename dual_image_space_type::value_type, typename VectorUblas< typename dual_image_space_type::value_type > ::range::type >	dual_image_element_range_type
typedef dual_image_space_type::template Element< typename dual_image_space_type::value_type, typename VectorUblas< typename dual_image_space_type::value_type > ::slice::type >	dual_image_element_slice_type
typedef dual_image_space_type::element_type	dual_image_element_type
typedef super::dual_image_space_ptrtype	dual_image_space_ptrtype
typedef super::dual_image_space_type	dual_image_space_type
typedef FsFunctionalLinear < detailOpLagP1::SpaceToLagrangeP1Space < SpaceType > ::image_space_type >	image_element_type
typedef boost::shared_ptr < matrix_type >	matrix_ptrtype
typedef backend_type::sparse_matrix_type	matrix_type
typedef Operator< SpaceType, detailOpLagP1::SpaceToLagrangeP1Space < SpaceType > ::image_space_type >	super_type
typedef OperatorLinear < SpaceType, detailOpLagP1::SpaceToLagrangeP1Space < SpaceType > ::image_space_type >	this_type
typedef backend_type::vector_ptrtype	vector_ptrtype
typedef backend_type::vector_type	vector_type
Public Types inherited from Feel::Operator< SpaceType, detailOpLagP1::SpaceToLagrangeP1Space< SpaceType >::image_space_type >
typedef boost::shared_ptr < backend_type >	backend_ptrtype
typedef Backend< value_type >	backend_type
typedef domain_space_type::element_type	domain_element_type
typedef boost::shared_ptr < domain_space_type >	domain_space_ptrtype
typedef SpaceType	domain_space_type
typedef boost::shared_ptr < dual_image_space_type >	dual_image_space_ptrtype
typedef detailOpLagP1::SpaceToLagrangeP1Space < SpaceType > ::image_space_type	dual_image_space_type
typedef FsFunctionalLinear < dual_image_space_type >	image_element_type
typedef domain_space_type::value_type	value_type

Public Member Functions
Constructors, destructor
	OperatorLagrangeP1 (domain_space_ptrtype const &space, backend_ptrtype const &backend, std::vector< WorldComm > const &worldsComm=std::vector< WorldComm >(1, Environment::worldComm()), std::string pathMeshLagP1=".", std::string prefix="", bool rebuild=true, bool parallelBuild=true)
	~OperatorLagrangeP1 ()
Operator overloads
OperatorLagrangeP1 const &	operator= (OperatorLagrangeP1 const &lp1)
Accessors
uint16_type	localDof (typename domain_mesh_type::element_const_iterator it, uint16_type localptid) const
uint16_type	localDof (typename domain_mesh_type::element_const_iterator, uint16_type localptid, mpl::bool_< false >) const
uint16_type	localDof (typename domain_mesh_type::element_const_iterator it, uint16_type localptid, mpl::bool_< true >) const
image_mesh_ptrtype	mesh ()
Methods
void	check () const
Public Member Functions inherited from Feel::OperatorLinear< SpaceType, detailOpLagP1::SpaceToLagrangeP1Space< SpaceType >::image_space_type >
OperatorLinear &	add (T const &scalar, OperatorLinear const &ol)
OperatorLinear &	add (T const &scalar, boost::shared_ptr< OperatorLinear > ol)
void	apply (const domain_element< typename domain_element_type::value_type, Storage > &de, image_element_type &ie) const
virtual void	apply (const domain_element_type &de, image_element_type &ie) const
virtual void	apply (const typename domain_space_type::element_type &de, typename dual_image_space_type::element_type &ie)
virtual void	apply (const domain_element_range_type &de, typename dual_image_space_type::element_type &ie)
virtual void	apply (const typename domain_space_type::element_type &de, dual_image_element_range_type &ie)
virtual void	apply (const domain_element_range_type &de, dual_image_element_range_type &ie)
virtual void	apply (const domain_element_slice_type &de, typename dual_image_space_type::element_type &ie)
virtual void	apply (const typename domain_space_type::element_type &de, dual_image_element_slice_type &ie)
virtual void	apply (domain_element_slice_typede, dual_image_element_slice_typeie)
virtual void	apply (const domain_element_range_type &de, dual_image_element_slice_type &ie)
virtual void	apply (const domain_element_slice_type &de, dual_image_element_range_type &ie)
virtual void	applyInverse (domain_element_type &de, const image_element_type &ie)
	apply the inverse of the operator:
backend_ptrtype &	backend ()
void	close ()
virtual double	energy (const typename domain_space_type::element_type &de, const typename dual_image_space_type::element_type &ie) const
virtual void	init (domain_space_ptrtype domainSpace, dual_image_space_ptrtype dualImageSpace, backend_ptrtype backend, bool buildMatrix=true, size_type pattern=Pattern::COUPLED)
domain_element_type	inv (RhsExpr const &rhs_expr)
matrix_type &	mat ()
matrix_type const &	mat () const
matrix_ptrtype const &	matPtr () const
matrix_ptrtype &	matPtr ()
virtual void	matPtr (matrix_ptrtype &matrix)
std::string	name () const
T2	operator() (T1 &de)
T2	operator() (boost::shared_ptr< T1 > de)
OperatorLinear &	operator+ (boost::shared_ptr< OperatorLinear > ol)
OperatorLinear &	operator+ (OperatorLinear const &ol)
this_type &	operator+= (ExprT const &e)
this_type &	operator= (ExprT const &e)
this_type &	operator= (this_type const &m)
	OperatorLinear (OperatorLinear const &ol, bool deep_copy=false)
	OperatorLinear (domain_space_ptrtype domainSpace, dual_image_space_ptrtype dualImageSpace, backend_ptrtype backend, bool buildMatrix=true, size_type pattern=Pattern::COUPLED)
size_type	pattern ()
void	setName (std::string name)
Public Member Functions inherited from Feel::Operator< SpaceType, detailOpLagP1::SpaceToLagrangeP1Space< SpaceType >::image_space_type >
domain_space_ptrtype	domainSpace ()
const domain_space_ptrtype	domainSpace () const
dual_image_space_ptrtype	dualImageSpace ()
const dual_image_space_ptrtype	dualImageSpace () const
	Operator (domain_space_ptrtype domainSpace, dual_image_space_ptrtype dualImageSpace)
image_element_type	operator() (const domain_element_type &de) const
void	setDomainSpace (domain_space_ptrtype const &domainspace)
void	setDualImageSpace (dual_image_space_ptrtype const &dualImageSpace)

Member Typedef Documentation

template<typename SpaceType>

typedef super::domain_space_type Feel::OperatorLagrangeP1< SpaceType >::domain_space_type

domain space

template<typename SpaceType>

typedef super::dual_image_space_type Feel::OperatorLagrangeP1< SpaceType >::dual_image_space_type

image space

template<typename SpaceType>

typedef std::vector<std::list<size_type> > Feel::OperatorLagrangeP1< SpaceType >::el2el_type

type which instances will hold the correspondance between the mesh elements associated to the domain space and the ones associated to the image space

Constructor & Destructor Documentation

template<typename space_type >

Feel::OperatorLagrangeP1< space_type >::OperatorLagrangeP1	(	domain_space_ptrtype const &	space,
		backend_ptrtype const &	backend,
		std::vector< WorldComm > const &	worldsComm = std::vector<WorldComm>(1,Environment::worldComm()),
		std::string	pathMeshLagP1 = ".",
		std::string	prefix = "",
		bool	rebuild = true,
		bool	parallelBuild = true
	)

Construct a P1 Lagrange space (ie spanned by a P1 Lagrange basis) out of the space space

References Feel::OperatorLagrangeP1< SpaceType >::check(), Feel::invalid_size_type_value, Feel::invalid_uint16_type_value, and Feel::PointSetToMesh< Convex, T >::visit().

template<typename SpaceType>

Feel::OperatorLagrangeP1< SpaceType >::~OperatorLagrangeP1 ( )

inline

destructor. nothing really to be done here

Member Function Documentation

template<typename space_type >

void Feel::OperatorLagrangeP1< space_type >::check

(

)

const

check that the P1 mesh is properly constructed

template<typename SpaceType>

OperatorLagrangeP1 const& Feel::OperatorLagrangeP1< SpaceType >::operator= ( OperatorLagrangeP1< SpaceType > const &  lp1 )

inline

copy operator

---

The documentation for this class was generated from the following file:

• operatorlagrangep1.hpp