Feel Namespace Reference

-*- mode: c++; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; show-trailing-whitespace: t -*- More...

Namespaces
namespace	math
	The math namespace unifies calls to functions and constants with respect to numerical types.

Classes
class	AboutData
	This class is used to store information about a program. More...
class	AboutDataPrivate
class	AboutPerson
	This structure is used to store information about a person or developer. More...
class	AdvReact
	Advection-Reaction solver. More...
class	Application
	provides information about the Application More...
class	ApplicationXML
	XML application. More...
struct	Assert
class	AssertContext
	contains details about a failed assertion More...
struct	bases
struct	bases_list
struct	basis_type
class	BasisFunctions
	base class for basis functions More...
class	Bdf
	Backward differencing formula time discretization. More...
class	BilinearFormBase
	Base class for Bilinear Forms handle algebraic representation and multithreading. More...
class	BlockBilinearForm
	forward declarations of BlockBilinearForm and blocform2() More...
class	BlockLinearForm
	forward declarations of BlockLinearForm and blockform1() More...
class	BlocksStencilPattern
class	BVH
	BVH base class. More...
class	BVH_ThirdParty
	implementation of BVH tool with an external third party More...
struct	BVHEnum
class	BVHRay
class	BVHRaysDistributed
class	Checker
	Checker class. More...
struct	CheckerConvergenceFailed
struct	CheckerExactFailed
struct	clear_values
struct	clear_values< Contextv, Value1 >
class	CNAB2
class	CNAB2x2
class	CollectionOfDataByMeshEntity
class	CommObject
struct	Configuration
struct	ContextGeometricBase
struct	continuity_type
class	Convex
	Convex base class. More...
class	ConvexBase
class	CreateSubmeshTool
class	DataByMeshEntity
struct	Dataset
class	Dof
	class that represents a degree of freedom More...
class	DofComposite
	Compositing of degree of freedom table. More...
class	DofFromBoundary
	Local Dof contribution from boundary dof. More...
class	DofFromEdge
	Local Dof contribution from edge dof. More...
class	DofFromElement
	local dof contribution from an element More...
class	DofFromMortar
	local dof contribution from a mortar element More...
class	DofFromPeriodic
	local contribution from periodic dof More...
class	DofTable
	Local-to-global Degree of Freedom table. More...
class	DofTableBase
struct	DofTableInfos
struct	domain_value_type
class	DummySharedFromThis
struct	edges_mesh
	get the mesh type of topological dimension d+1 if the real dimension of the mesh is d+1 More...
struct	element_type_helper
	Utility class to get the element type contained in ObjectType. More...
struct	element_type_helper< MeshType, std::enable_if_t< is_mesh_v< MeshType > > >
	Specialization for Meshes. More...
struct	element_type_helper< RangeType, std::enable_if_t< is_range_v< RangeType > > >
	Specialization for Range. More...
struct	element_type_helper< SpaceType, std::enable_if_t< is_functionspace_v< SpaceType > > >
	Specialization for FunctionSpaces. More...
struct	elements_mesh
	get the mesh type of topological dimension d+1 if the real dimension of the mesh is d+1 More...
class	Entity
class	Entity< SHAPE_HEXA, T >
class	Entity< SHAPE_LINE, T >
class	Entity< SHAPE_POINT, T >
class	Entity< SHAPE_QUAD, T >
class	Entity< SHAPE_TETRA, T >
class	Entity< SHAPE_TRIANGLE, T >
class	Environment
	Initialize, finalize, and query the Feel++ environment. More...
struct	expansion_type
class	Exporter
class	ExprBase
	Base class for expression. More...
class	ExpressionEvaluator
class	ExpressionEvaluatorBase
class	ExpressionEvaluatorNonLinear
class	ExpressionEvaluatorParam
struct	FaceDof
	Describe a Dof on a Face. More...
struct	faces_mesh
	get the mesh type of topological dimension d+1 if the real dimension of the mesh is d+1 More...
struct	facets_mesh
	get the mesh type of topological dimension d+1 if the real dimension of the mesh is d+1 More...
class	Factory
	Implements a generic object Factory. More...
class	FactoryClone
	Implements a generic cloning object Factory. More...
struct	FactoryDefaultError
	Manages the "Unknown Type" error in an object Factory. More...
class	FsFunctional
class	FsFunctionalLinear
class	FsFunctionalLinearComposite
class	FsFunctionalLinearFree
class	FunctionExpr
class	FunctionSpace
class	FunctionSpaceBase
	base class for FunctionSpace More...
struct	FunctionSpaceBuildCounts
	Snapshot of function-space construction instrumentation counters. More...
class	FunctionSpaceBuildInstrumentation
	Runtime-disabled counters used by focused tests and benchmarks. More...
class	FunctionSpaceManager
	Own and reuse canonical whole-mesh function spaces within a process. More...
struct	FunctionSpaceManagerConfig
	Runtime configuration of the process-local function-space manager. More...
struct	FunctionSpaceManagerOptions
	Normalized construction options that participate in a manager key. More...
struct	FunctionSpaceManagerStats
	Process-local counters and retained-state measurements. More...
class	Gauss
class	Geo0D
	Zero dimensional entity. More...
class	GeoElement0D
	Class for Points and Vertices. More...
class	GeoElement1D
	class for 1D elements More...
class	GeoElement2D
	Class for 2D elements. More...
class	GeoElement3D
	Class for 3D elements. More...
class	GeoEntity
	base class for all geometric entities More...
class	GeometricSpace
struct	GeometricSpaceBase
class	GeoND
	Base class for Multi-dimensional basis Geometrical Entities. More...
class	GeoNDCommon
	Common data shared in a collection of multi-dimensional geometrical entity. More...
class	GeoNDMeasuresStorage
class	GeoNDNoMeasuresStorage
struct	GinacExprManagerDefaultFileNameDeleterImpl
class	GinacExprManagerDefaultFileNameImpl
struct	GinacExprManagerDeleterImpl
class	GinacExprManagerImpl
struct	GithubUser
class	GitMetadata
	GitMetaData class holder. More...
struct	GT_Lagrange
class	Hypercube
class	HypercubeBase
struct	IMGeneric
class	Info
	information provider for versioning and installation directories More...
struct	InterpolationConforming
struct	InterpolationCurl
struct	InterpolationDiv
struct	InterpolationExpr
struct	InterpolationGradient
struct	InterpolationNonConforming
class	InterpolationTypeBase
class	InterpolationTypeBaseBase
struct	is_0d_real
struct	is_1d_real
struct	is_2d_real
struct	is_3d_real
struct	is_convex
struct	is_cube
struct	is_edge
struct	is_face
struct	is_filter
	Filters. More...
struct	is_filter< boost::tuple< T... > >
struct	is_geoelement
	Checks whether T is a GeoElement<n>D type. More...
struct	is_geoelement< GeoElement0D< Dim, SubFace, T, IndexT > >
struct	is_geoelement< GeoElement1D< Dim, GEOSHAPE, SubFace, T, IndexT, PointTypeIsSubFaceOf, UseMeasuresStorage > >
struct	is_geoelement< GeoElement2D< Dim, GEOSHAPE, SubFace, T, IndexT, UseMeasuresStorage > >
struct	is_geoelement< GeoElement3D< Dim, GEOSHAPE, T, IndexT, UseMeasuresStorage > >
struct	is_hypercube
struct	is_iterable
struct	is_iterable< T, std::void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end())> >
struct	is_iterable_of
struct	is_iterable_of< T, V, std::void_t< decltype(std::declval< T >().begin()), decltype(std::declval< T >().end()), std::is_same< decltype(*std::declval< T >().begin()), V > > >
struct	is_point
struct	is_ptr_or_shared_ptr
struct	is_reference_convex
	Checks whether T is a Reference convex type. More...
struct	is_reference_convex< Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T > >
struct	is_reference_convex< Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T > >
struct	is_segment
struct	is_shared_ptr
struct	is_shared_ptr< std::shared_ptr< T > >
struct	is_simplex
struct	is_square
struct	is_std_vector
struct	is_std_vector< std::vector< T > >
struct	is_tetrahedron
struct	is_topological_face
struct	is_triangle
struct	is_tuple
	std::tuple More...
struct	is_tuple< std::tuple< T... > >
class	JournalFeed
class	JournalManager
	JournalManager that manage the journal system handles all journalWatchers. More...
class	JournalWatcher
class	KDTree
	KDTree class. More...
struct	Line
class	LocalDof
class	LocalDofSet
class	Localization
class	Marker
class	MasterStream
	Output Stream that outputs only on master rank of a worldcomm. More...
class	MemoryUsage
	class to query for memory usage More...
class	Mesh
	unifying mesh class More...
class	Mesh0D
	0D mesh class More...
class	Mesh1D
	1D mesh class More...
class	Mesh2D
	2D mesh class More...
class	Mesh3D
	3D mesh class More...
struct	mesh_type
class	MeshAdaptation
class	MeshBase
	base mesh class More...
struct	meshes
class	MeshFragmentation
class	MeshHighOrder
	Class to handle high order meshes (only works for 2D meshes) More...
class	MeshInverse
struct	MeshMarkerName
class	MeshMover
	Move mesh according to a given map. More...
class	MeshPartitionSet
class	MeshStructured
struct	MeshStructuredBase
	Structured mesh class. More...
class	MeshStructuredSetup
	MeshStructuredSetup class define : More...
class	MeshStructuredSetupHyperRectangle
class	MeshStructuredSetupWithCoordinates
class	MeshSupport
	Description of a mesh support. More...
class	MeshSupportBase
	Description of a mesh support. More...
class	MeshTraits
	Traits for meshes. More...
struct	model_type
class	MongoConfig
class	Mortar
struct	mortar_type
struct	mortars
class	Newmark
	Newmark discretization. More...
class	NoMortar
class	NoPeriodicity
	NoPeriodicity class holder. More...
class	Operator
	Operator between function spaces. More...
class	OperatorInterpolation
	Global interpolation operator. More...
struct	OperatorInterpolationMatrixSetup
class	OperatorLagrangeP1
class	OperatorLinear
	Linear Operator between function spaces, represented by a matrix. More...
class	OperatorLinearComposite
class	OperatorLinearFree
	Linear Operator Free between function spaces, represented by a matrix but this matrix is not automatically assembled. More...
class	OperatorSteklovPc
	OperatorSteklovPc made easy. More...
class	OperatorTrace
	OperatorTrace made easy. More...
struct	Order
class	Oseen
class	OseenDefaults
	Oseen Default Data. More...
class	Output
	output class to describe code outputs More...
class	Output_impl
class	Parameter
	parameter class to describe code inputs More...
class	Parameter_impl
struct	parent_mesh
	get the mesh type of topological dimension d+1 if the real dimension of the mesh is d+1 More...
class	Partitioner
	partitioner class More...
class	Periodic
	Periodic class holder. More...
struct	PeriodicEntity
struct	Periodicity
struct	periodicity_type
class	PointSet
	Class of all PointSet on a Convex. More...
class	PointSetBase
	base class for point sets, to be used eg with SFINAE More...
class	PolicyCreationUsingNew
	default creation policy More...
class	PolicyFeelTimeDefault
	default feel time policy More...
struct	product_space_tag
class	ProductSpace
class	ProductSpaces
class	ProductSpaces2
	class mixing dynamic and compile-time space product More...
class	Projector
	Projection made easy. More...
class	PsLogger
	Writes output of the system command ps to a logfile. More...
class	QuadPtLocalization
class	Range
class	RangeBase
	RangeBase class. More...
class	Reference
	Reference convex. More...
class	Reference< Hypercube< Dim, Order, RDim >, Dim, Order, RDim, T >
class	Reference< Simplex< Dim, Order, RDim >, Dim, Order, RDim, T >
struct	Region
struct	RegionMarker
	class for RegionMarker More...
struct	RegionMarker2
	class for RegionMarker2 More...
struct	RegionMarker3
	class for RegionMarker3 More...
struct	RegionProcess
	class for RegionProcess More...
class	RegionTree
	implements a region-tree for point search in a set of boxes More...
struct	RemoteData
	Class which manages downloads from a URL or GitHub and download/upload with the Girder database by using libcurl. More...
class	RemoteDataProgress
	Progress utility class for remote data operations. More...
struct	remove_shared_ptr
struct	remove_shared_ptr< std::shared_ptr< T > >
struct	remove_std_vector
struct	remove_std_vector< std::vector< T > >
class	Repository
	@ structure to handle repository of results More...
class	SensorBase
	base class for sensors More...
class	SensorGaussian
	gaussian type sensor More...
class	SensorMap
class	SensorPointwise
	pointwise type sensor More...
class	SensorSurface
	surface type sensor More...
class	Simget
	Simulation Object. More...
class	Simplex
	simplex of dimension Dim More...
class	SimplexBase
class	Singleton
	implement the Singleton pattern More...
class	Sphere
	This class defines a sphere. More...
class	StatusRequestHTTP
class	Stencil
class	StencilManagerImpl
struct	stencilQuadSet
struct	stencilQuadSetBase
	define the quadrature order use with non standard stencil More...
struct	StencilRangeMap0Type
struct	StencilRangeMap1Type
struct	StencilRangeMap2Type
struct	StencilRangeMapTypeBase
struct	stencilrangetype
struct	strip_comments_grammar
struct	strip_comments_tokens
class	StructuredGrid
	class to represent a Structured Grid More...
class	SubFaceOf
	description of a subface or facet (topological d-1) of an element of topologicql dimension d More...
struct	SubFaceOfBase
	Tag base class. More...
class	SubFaceOfNone
class	SubMeshData
	data structure storing sub mesh data More...
class	Surface
	This class defines a surface. More...
class	Symbols
struct	SymmetricTensorFormat
	Field-level symmetric tensor format. More...
class	Table
class	TabulateInformationProperties
class	TabulateInformations
	base class that describe informations by tabulate/section design More...
class	TabulateInformationsSections
	describe informations by section More...
class	TabulateInformationsTable
	describe informations in table More...
class	TabulateInformationsTableAlternative
	describe informations in table More...
struct	Tag
class	TerminalProperties
	describe terminal properties if available : width, height More...
struct	Tetrahedron
class	TimerData
	TimerData is the value for the TimerTable map. More...
class	TimerMap
	timers map More...
struct	TimerPair
class	TimerTable
	TimerTable is a map of timer. More...
class	TimerTool
class	TimerToolBase
class	TimerToolNull
class	TimeSet
	Handles a set of time steps. More...
struct	TimeStepInfo
	class that stores time step information: More...
struct	trace_mesh
	helper class to get the type of the trace of a mesh More...
struct	trace_trace_mesh
	helper class to get the type of the trace of the trace of a mesh More...
struct	Triangle
class	TSBase
	base class for time sets More...
class	TSBaseMetadata
class	TwoSpacesMap
	This class provides a correspondancy map between two spaces and particularly between a sequential space Xs defined on a submesh of the parallel space Xp. More...
struct	type_identity
struct	type_traits
class	TypeInfo
	wrapper for std::type_info More...
struct	UpdateInformationObject
struct	value_type_trait
struct	value_type_trait< Type, std::enable_if_t< is_functionspace_v< Type > > >
struct	value_type_trait< Type, std::enable_if_t< is_mesh_v< Type > > >
struct	value_type_trait< Type, std::enable_if_t< is_range_v< Type > > >
class	Vector
class	VisitableBase
class	VisitableCatchAllDefault
class	Visitor
	This class is the base class to implement the Visitor Pattern. More...
class	VisitorBase
	The base class of any Acyclic Visitor. More...
class	VisitorBaseImpl
	Implements non-strict visitation (you can implement only part of the Visit functions) More...
class	VisitorBaseImpl< mpl::list< Head >, R >
class	VisitorBaseImpl< mpl::list< Head, Tail >, R >
class	VisitorCyclic
	Put it in every class that you want to make visitable (in addition to deriving it from VisitableBase<R> More...
class	VisitorList
struct	void_basis
class	WorldComm
	Provides interface to MPI Communicators. More...
class	WorldsComm
	a set of worlds communicator More...
class	xmlParser

Typedefs
template<typename MeshType >
using	alledges_t = edges_reference_wrapper_t< MeshType >
template<typename MeshType >
using	allelements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	allfaces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	allpoints_t = points_reference_wrapper_t< MeshType >
template<typename T >
using	args_remesh_type = NA::arguments< typename na::mesh::template required_as_t< std::shared_ptr< T > >, typename na::metric::template required_as_t< std::string >, typename na::required_elts::template required_as_t< std::vector< std::string > >, typename na::required_facets::template required_as_t< std::vector< std::string > >, typename na::parent::template required_as_t< std::shared_ptr< T > >, typename na::vm::template required_as_t< po::variables_map const & >, typename na::verbose::template required_as_t< int > >
	list of arguments type for remesh named parameters functions More...
template<typename PS >
using	blockform1_t = BlockLinearForm< PS >
template<typename TestPS , typename TrialPS = TestPS>
using	blockform2_t = BlockBilinearForm< TestPS, TrialPS >
template<typename MeshType >
using	boundaryedges_t = edges_reference_wrapper_t< MeshType >
template<typename MeshType >
using	boundaryelements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	boundaryfaces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	boundarypoints_t = points_reference_wrapper_t< MeshType >
template<size_type Contextv, size_type Value>
using	clear_value = mpl::size_t< Contextv &(~Value)>
typedef complex128_type	complex128_t
typedef std::complex< float64_t >	complex128_type
typedef std::complex< double >	complex64_type
typedef std::complex< double >	complex_type
using	Component = ComponentType
template<typename RangeType , typename ... Args>
using	concatenate_t = RangeType
using	conforming_t = mpl::bool_< true >
template<typename MeshType , int MESH_ENTITIES, std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>
using	container_reference_wrapper_t = boost::mp11::mp_if_c< MESH_ENTITIES==MESH_ELEMENTS, typename MeshTraits< MeshType >::elements_reference_wrapper_ptrtype, boost::mp11::mp_if_c< MESH_ENTITIES==MESH_FACES, typename MeshTraits< MeshType >::faces_reference_wrapper_ptrtype, boost::mp11::mp_if_c< MESH_ENTITIES==MESH_EDGES, typename MeshTraits< MeshType >::edges_reference_wrapper_ptrtype, typename MeshTraits< MeshType >::points_reference_wrapper_ptrtype > > >
using	Context = meta::Context< size_type >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationCurl<nonconforming_t>>
using	Curl_ptr_t = std::shared_ptr< Curl_t< DomainSpaceType, ImageSpaceType, IteratorRange, InterpType > >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationCurl<nonconforming_t>>
using	Curl_t = OperatorInterpolation< DomainSpaceType, ImageSpaceType, range_t< IteratorRange >, InterpType >
template<typename T >
using	decay_type = std::decay_t< remove_shared_ptr_type< std::decay_t< T > > >
template<int Order, typename MeshType >
using	dh_ptrtype = std::shared_ptr< dh_type< Order, MeshType > >
template<typename MeshType , int Order>
using	Dh_ptrtype = std::shared_ptr< dh_type< Order, MeshType > >
template<int Order, typename MeshType , typename T = double>
using	dh_type = FunctionSpace< MeshType, bases< RaviartThomas< Order > >, T, Periodicity< NoPeriodicity > >
template<typename MeshType , int Order, typename T = double>
using	Dh_type = FunctionSpace< MeshType, bases< RaviartThomas< Order > >, T, Periodicity< NoPeriodicity > >
typedef uint16_type	dim_type
	dimension type
template<typename T >
using	dimension_t = mp11::mp_size_t< decay_type< T >::nDim >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationDiv<nonconforming_t>>
using	Div_ptr_t = std::shared_ptr< Div_t< DomainSpaceType, ImageSpaceType, IteratorRange, InterpType > >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationDiv<nonconforming_t>>
using	Div_t = OperatorInterpolation< DomainSpaceType, ImageSpaceType, range_t< IteratorRange >, InterpType >
using	dof_id_type = index_type
	dof id type
template<typename SpaceT , bool same_mesh = true>
using	dyn_product_space_element_ptr_t = typename ProductSpace< SpaceT, same_mesh >::element_ptrtype
template<typename SpaceT , bool same_mesh = true>
using	dyn_product_space_element_t = typename ProductSpace< SpaceT, same_mesh >::element_type
template<typename SpaceT , bool same_mesh = true>
using	dyn_product_space_ptr_t = std::shared_ptr< ProductSpace< SpaceT, same_mesh > >
template<typename SpaceT , bool same_mesh = true>
using	dyn_product_space_t = ProductSpace< SpaceT, same_mesh >
template<typename SpaceT , typename... SpaceList>
using	dyn_product_spaces_element_ptr_t = typename ProductSpaces2< SpaceT, SpaceList... >::element_ptrtype
template<typename SpaceT , typename... SpaceList>
using	dyn_product_spaces_element_t = typename ProductSpaces2< SpaceT, SpaceList... >::element_type
template<typename SpaceT , typename... SpaceList>
using	dyn_product_spaces_ptr_t = std::shared_ptr< ProductSpaces2< SpaceT, SpaceList... > >
template<typename SpaceT , typename... SpaceList>
using	dyn_product_spaces_t = ProductSpaces2< SpaceT, SpaceList... >
template<typename MeshType >
using	edges_reference_wrapper_t = boost::tuple< mpl::size_t< MESH_EDGES >, typename MeshTraits< MeshType >::edge_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::edge_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::edges_reference_wrapper_ptrtype >
template<typename ObjectType >
using	element_ptr_t = typename element_type_helper< ObjectType >::ptrtype
template<typename ObjectType >
using	element_t = typename element_type_helper< ObjectType >::type
template<typename MeshType >
using	elements_pid_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	elements_reference_wrapper_t = boost::tuple< mpl::size_t< MESH_ELEMENTS >, typename MeshTraits< MeshType >::element_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::element_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::elements_reference_wrapper_ptrtype >
template<typename MeshType >
using	elements_wrapper_ptr_t = typename MeshTraits< MeshType >::elements_reference_wrapper_ptr_type
template<typename MeshType >
using	elements_wrapper_t = typename MeshTraits< MeshType >::elements_reference_wrapper_type
template<typename MeshType , int MESH_ENTITIES, std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>
using	entities_reference_wrapper_t = boost::mp11::mp_if_c< MESH_ENTITIES==MESH_ELEMENTS, elements_reference_wrapper_t< MeshType >, boost::mp11::mp_if_c< MESH_ENTITIES==MESH_FACES, faces_reference_wrapper_t< MeshType >, boost::mp11::mp_if_c< MESH_ENTITIES==MESH_EDGES, edges_reference_wrapper_t< MeshType >, points_reference_wrapper_t< MeshType > > > >
template<typename MeshType , int MESH_ENTITIES, std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>
using	entities_t = boost::mp11::mp_if_c< MESH_ENTITIES==MESH_ELEMENTS, typename MeshTraits< MeshType >::element_type, boost::mp11::mp_if_c< MESH_ENTITIES==MESH_FACES, typename MeshTraits< MeshType >::face_type, boost::mp11::mp_if_c< MESH_ENTITIES==MESH_EDGES, typename MeshTraits< MeshType >::edge_type, typename MeshTraits< MeshType >::point_type > > >
using	entity_filter_t = EntityFilterType
using	entity_process_t = EntityProcessType
template<typename RangeType >
using	entity_range_t = typename decay_type< RangeType >::element_t
template<typename SizeT = uint32_type>
using	EntityDof = FaceDof< SizeT >
template<typename MeshType >
using	ext_edges_t = edges_reference_wrapper_t< MeshType >
template<typename MeshType >
using	ext_elements_t = elements_reference_wrapper_t< MeshType >
template<typename RangeType >
using	ext_entities_from_iterator_t = RangeType
template<typename MeshType >
using	ext_faces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	faces_pid_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	faces_reference_wrapper_t = boost::tuple< mpl::size_t< MESH_FACES >, typename MeshTraits< MeshType >::face_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::face_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::faces_reference_wrapper_ptrtype >
template<typename RangeType >
using	filter_entity_t = typename RangeType::element_t
template<typename RangeType >
using	filter_enum_t = typename RangeType::idim_t
template<typename RangeType >
using	filter_iterator_t = typename RangeType::iterator_t
typedef int64_type	flag_type
template<typename FE1 , typename VectorType = typename Backend<typename functionspace_type<FE1>::value_type>::vector_type, typename ElemContType = VectorType>
using	form1_space_t = typename form1_t< FE1, VectorType, ElemContType >::space_type
	provide the type of the space associated to the linear form
template<typename FE1 , typename VectorType = typename Backend<typename functionspace_type<FE1>::value_type>::vector_type, typename ElemContType = VectorType>
using	form1_t = form1_type< FE1, VectorType, ElemContType >
	provide the type of the linear form
template<typename FE1 , typename VectorType = typename Backend<typename functionspace_type<FE1>::value_type>::vector_type, typename ElemContType = VectorType>
using	form1_type = Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType >
	provide the type of the linear form
typedef parameter::parameters< parameter::required< tag::mesh_type, boost::is_base_and_derived< MeshBase<>, _ > >, parameter::optional< parameter::deduced< tag::bases_list >, boost::is_base_and_derived< Feel::detail::bases_base, _ > >, parameter::optional< parameter::deduced< tag::value_type >, boost::is_floating_point< _ > >, parameter::optional< parameter::deduced< tag::mortar_type >, boost::is_base_and_derived< Feel::detail::mortar_base, _ > >, parameter::optional< parameter::deduced< tag::periodicity_type >, boost::is_base_and_derived< Feel::detail::periodicity_base, _ > > >	functionspace_signature
typedef GeoEntity< Simplex< 0, 1 > >	GeoPoint
typedef Feel::Singleton< GinacExprManagerImpl >	GinacExprManager
typedef Feel::Singleton< GinacExprManagerDefaultFileNameImpl >	GinacExprManagerDefaultFileName
typedef Feel::Singleton< GinacExprManagerDefaultFileNameDeleterImpl >	GinacExprManagerDefaultFileNameDeleter
typedef Feel::Singleton< GinacExprManagerDeleterImpl >	GinacExprManagerDeleter
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationGradient<nonconforming_t>>
using	Grad_ptr_t = std::shared_ptr< Grad_t< DomainSpaceType, ImageSpaceType, IteratorRange, InterpType > >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationGradient<nonconforming_t>>
using	Grad_t = OperatorInterpolation< DomainSpaceType, ImageSpaceType, range_t< IteratorRange >, InterpType >
template<typename T >
using	has_base_rangebase_32 = std::is_base_of< RangeBase< uint32_type >, T >
template<typename T >
using	has_base_rangebase_64 = std::is_base_of< RangeBase< uint64_type >, T >
template<size_type Contextv, size_type Value>
using	has_value = mpl::bool_<(Contextv &Value) !=0 >
template<typename T >
using	holo3_image = Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationNonConforming>
using	I_ptr_t = std::shared_ptr< I_t< DomainSpaceType, ImageSpaceType, IteratorRange, InterpType > >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationNonConforming>
using	I_t = operator_interpolation_t< DomainSpaceType, ImageSpaceType, IteratorRange, InterpType >
template<typename MeshType >
using	idelements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	idfaces_t = faces_reference_wrapper_t< MeshType >
using	index_type = uint32_type
typedef boost::int16_t	int16_type
typedef boost::int32_t	int32_type
typedef boost::int64_t	int64_type
typedef boost::int8_t	int8_type
template<typename MeshType >
using	internaledges_t = edges_reference_wrapper_t< MeshType >
template<typename MeshType >
using	internalelements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	internalfaces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	internalpoints_t = points_reference_wrapper_t< MeshType >
using	InterpolationConforme = InterpolationConforming
template<typename C >
using	InterpolationID = typename mpl::if_< C, mpl::identity< InterpolationConforming >, mpl::identity< InterpolationNonConforming > >::type::type
using	InterpolationNonConforme = InterpolationNonConforming
template<typename MeshType >
using	interprocessfaces_t = faces_reference_wrapper_t< MeshType >
template<typename IteratorType , typename ... Args>
using	intersect_t = std::remove_const< decay_type< IteratorType > >
template<typename T >
using	is_0d = mp11::mp_bool< decay_type< T >::nDim==0 >
template<typename T >
using	is_1d = mp11::mp_bool< decay_type< T >::nDim==1 >
template<typename T >
using	is_2d = mp11::mp_bool< decay_type< T >::nDim==2 >
template<typename T >
using	is_3d = mp11::mp_bool< decay_type< T >::nDim==3 >
template<typename MeshT >
using	is_mesh_structured = std::conditional_t< std::is_base_of_v< MeshStructuredBase, MeshT >, std::true_type, std::false_type >
	trait type to detect a MeshStructured mesh More...
template<class T >
using	is_std_vector_t = is_std_vector< T >
using	json = nlohmann::json
typedef GeoEntity< Hypercube< 3, 1 > >	LinearHexa
typedef GeoEntity< Simplex< 1, 1 > >	LinearLine
typedef GeoEntity< Hypercube< 2, 1 > >	LinearQuad
typedef GeoEntity< Simplex< 3, 1 > >	LinearTetra
typedef GeoEntity< Simplex< 2, 1 > >	LinearTriangle
template<typename MeshType >
using	marked2elements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	marked2faces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	marked3elements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	marked3faces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	markededges_t = edges_reference_wrapper_t< MeshType >
template<typename MeshType >
using	markedelements_t = elements_reference_wrapper_t< MeshType >
template<typename MeshType >
using	markedfaces_t = faces_reference_wrapper_t< MeshType >
template<typename MeshType >
using	markedpoints_t = points_reference_wrapper_t< MeshType >
using	multiple_space_t = hana::integral_constant< int, 2 >
using	multiple_spaces_t = multiple_space_t
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetEquiSpaced, typename T = double, int Tag = 0>
using	NChv_ptrtype = typename meta::NChv< MeshType, Order, Pts, T, Tag >::ptrtype
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetEquiSpaced, typename T = double, int Tag = 0>
using	NChv_type = typename meta::NChv< MeshType, Order, Pts, T, Tag >::type
template<typename MeshType , int Order, typename T = double>
using	Ned1h_ptrtype = typename meta::Ned1h< MeshType, Order, T >::ptrtype
template<typename MeshType , int Order, typename T = double>
using	Ned1h_type = typename meta::Ned1h< MeshType, Order, T >::type
typedef node< double >::type	node_type
using	nonconforming_t = mpl::bool_< false >
template<typename MeshType , int Order, typename T = double, int Tag = 0>
using	Odh_ptrtype = typename meta::Odh< MeshType, Order, T, Tag >::ptrtype
template<typename MeshType , int Order, typename T = double, int Tag = 0>
using	Odh_type = typename meta::Odh< MeshType, Order, T, Tag >::type
using	on_edges_t = boost::mp11::mp_int< MESH_EDGES >
using	on_elements_t = boost::mp11::mp_int< MESH_ELEMENTS >
using	on_facets_t = boost::mp11::mp_int< MESH_FACES >
using	on_internal_faces_t = boost::mp11::mp_int< MESH_INTERNAL_FACES >
using	on_points_t = boost::mp11::mp_int< MESH_POINTS >
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationNonConforming>
using	operator_interpolation_t = OperatorInterpolation< DomainSpaceType, ImageSpaceType, range_t< IteratorRange >, InterpType >
	get the type of an OperatorInterpolation More...
using	optional_double_t = boost::optional< double >
template<typename Base1 , typename Base2 , typename MeshType >
using	P2ch_ptrtype = std::shared_ptr< P2ch_type< Base1, Base2, MeshType > >
	Define the shared_ptr type for Taylor-Hood space. More...
template<typename Base1 , typename Base2 , typename MeshType >
using	P2ch_type = FunctionSpace< MeshType, bases< Base1, Base2 >, double, Periodicity< NoPeriodicity, NoPeriodicity >, mortars< NoMortar, NoMortar > >
	Define the type for P<Order1>P<Order2> More...
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pch_element_t = typename Pch_type< MeshType, Order, T, Pts, Tag >::element_type
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pch_element_type = Pch_element_t< MeshType, Order, T, Pts, Tag >
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pch_ptrtype = typename meta::Pch< MeshType, Order, T, Pts, Tag >::ptrtype
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pch_type = typename meta::Pch< MeshType, Order, T, Pts, Tag >::type
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pchm_ptrtype = typename meta::Pchm< MeshType, Order, T, Pts, Tag >::ptrtype
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pchm_type = typename meta::Pchm< MeshType, Order, T, Pts, Tag >::type
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pchms_ptrtype = typename meta::Pchms< MeshType, Order, T, Pts, Tag >::ptrtype
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pchms_type = typename meta::Pchms< MeshType, Order, T, Pts, Tag >::type
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename T = double, int Tag = 0>
using	Pchv_element_t = typename Pchv_type< MeshType, Order, Pts, T, Tag >::element_type
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename T = double, int Tag = 0>
using	Pchv_element_type = Pchv_element_t< MeshType, Order, Pts, T, Tag >
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename T = double, int Tag = 0>
using	Pchv_ptrtype = typename meta::Pchv< MeshType, Order, Pts, T, Tag >::ptrtype
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename T = double, int Tag = 0>
using	Pchv_type = typename meta::Pchv< MeshType, Order, Pts, T, Tag >::type
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete>
using	Pdh_element_t = typename Pdh_type< MeshType, Order, Pts >::element_type
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete>
using	Pdh_element_type = Pdh_element_t< MeshType, Order, Pts >
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete>
using	Pdh_ptrtype = std::shared_ptr< Pdh_type< MeshType, Order, Pts > >
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete>
using	Pdh_type = FunctionSpace< MeshType, bases< Lagrange< Order, Scalar, Discontinuous, Pts > > >
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pdhm_ptrtype = typename meta::Pdhm< MeshType, Order, T, Pts, Tag >::ptrtype
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pdhm_type = typename meta::Pdhm< MeshType, Order, T, Pts, Tag >::type
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pdhms_ptrtype = typename meta::Pdhms< MeshType, Order, T, Pts, Tag >::ptrtype
template<typename MeshType , int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pdhms_type = typename meta::Pdhms< MeshType, Order, T, Pts, Tag >::type
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete>
using	Pdhv_element_t = typename Pdhv_type< MeshType, Order, Pts >::element_type
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete>
using	Pdhv_element_type = Pdhv_element_t< MeshType, Order, Pts >
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pdhv_ptrtype = typename meta::Pdhv< MeshType, Order, Pts, Tag >::ptrtype
template<typename MeshType , int Order, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0>
using	Pdhv_type = typename meta::Pdhv< MeshType, Order, Pts, Tag >::type
template<typename MeshType >
using	pid_edges_t = edges_reference_wrapper_t< MeshType >
typedef Geo0D< 3 >	Point
template<typename MeshType >
using	points_pid_t = points_reference_wrapper_t< MeshType >
template<typename MeshType >
using	points_reference_wrapper_t = boost::tuple< mpl::size_t< MESH_POINTS >, typename MeshTraits< MeshType >::point_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::point_reference_wrapper_const_iterator, typename MeshTraits< MeshType >::points_reference_wrapper_ptrtype >
template<typename... SpaceList>
using	product_spaces_element_ptr_t = typename ProductSpaces< SpaceList... >::element_ptrtype
template<typename... SpaceList>
using	product_spaces_element_t = typename ProductSpaces< SpaceList... >::element_type
template<typename... SpaceList>
using	product_spaces_ptr_t = std::shared_ptr< ProductSpaces< SpaceList... > >
template<typename... SpaceList>
using	product_spaces_t = ProductSpaces< SpaceList... >
using	ProgressCallback = std::function< void(std::string filename, std::streamsize transferred, std::streamsize total)>
template<class DomainSpace , class DualImageSpace >
using	projector_ptrtype = std::shared_ptr< Projector< DomainSpace, DualImageSpace > >
template<class DomainSpace , class DualImageSpace >
using	projector_type = Projector< DomainSpace, DualImageSpace >
typedef uint16_type	quad_order_type
	quadrature order type
typedef GeoEntity< Hypercube< 3, 2 > >	QuadraticHexa
typedef GeoEntity< Simplex< 1, 2 > >	QuadraticLine
typedef GeoEntity< Hypercube< 2, 2 > >	QuadraticQuad
typedef GeoEntity< Simplex< 3, 2 > >	QuadraticTetra
typedef GeoEntity< Simplex< 2, 2 > >	QuadraticTriangle
template<typename RangeT >
using	range_container_t = std::tuple_element_t< 3, RangeT >
template<typename MeshType >
using	range_element_ptr_t = typename MeshTraits< MeshType >::elements_reference_wrapper_ptrtype
template<typename MeshType >
using	range_element_t = typename MeshTraits< MeshType >::elements_reference_wrapper_type
template<typename RangeT >
using	range_elementtype_t = std::tuple_element_t< 0, RangeT >
template<typename RangeT >
using	range_iterators_t = std::tuple_element_t< 1, RangeT >
template<typename RangeType >
using	range_t = typename mpl::if_< boost::is_std_list< RangeType >, mpl::identity< RangeType >, mpl::identity< std::list< RangeType > > >::type::type::value_type
	a RangeType can be one or more filter/range objects of the same type, we extract the underlying type by first casting everything to a list and then retrieving consistently the type.
typedef uint16_type	rank_type
	type for mpi rank ids
typedef float	real32_type
typedef double	real64_type
template<typename T >
using	real_dimension_t = boost::mp11::mp_size_t< decay_type< T >::nRealDim >
typedef std::shared_ptr< region_tree_type >	region_tree_ptrtype
	pointer type for Region Tree.
typedef RegionTree	region_tree_type
	an alias for RegionTree
template<typename T >
using	remove_shared_ptr_t = typename remove_shared_ptr< T >::type
template<typename T >
using	remove_shared_ptr_type = typename remove_shared_ptr< T >::type
template<typename T >
using	remove_std_vector_t = typename remove_std_vector< T >::type
template<size_type Contextv, size_type Value>
using	set_value = mpl::size_t<(Contextv|Value)>
typedef Singleton< Factory< Simget, std::string > >	SimgetFactory
	Simget factory.
using	single_space_t = hana::integral_constant< int, 1 >
using	single_spaces_t = single_space_t
using	size_type = size_t
	Indices (starting from 0)
typedef Feel::Singleton< StencilManagerImpl >	StencilManager
template<typename... T>
using	strongest_numeric_type = std::common_type_t< T... >
template<typename IteratorRangeT >
using	submeshrange_t = typename Feel::detail::submeshrangetype< IteratorRangeT >::type
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
using	support_mesh_t = typename unwrap_ptr_t< MeshSupportType >::mesh_type
using	tabulate_informations_ptr_t = typename TabulateInformations::self_ptrtype
using	tabulate_informations_sections_ptr_t = std::shared_ptr< tabulate_informations_sections_t >
using	tabulate_informations_sections_t = TabulateInformationsSections
using	tabulate_informations_t = TabulateInformations
	types
using	tabulate_informations_table_ptr_t = std::shared_ptr< tabulate_informations_table_t >
using	tabulate_informations_table_t = TabulateInformationsTable
	types
template<typename SpaceType >
using	Test = BasisFunctions< SpaceType, 0 >
template<int Order, typename MeshType >
using	THch_element_t = typename THch_type< Order, MeshType >::element_type
template<int Order, typename MeshType >
using	THch_pressure_space_ptr_t = typename THch_type< Order, MeshType >::template sub_functionspace_ptrtype< 1 >
template<int Order, typename MeshType >
using	THch_pressure_space_t = typename THch_type< Order, MeshType >::template sub_functionspace_type< 1 >
template<int Order, typename MeshType >
using	THch_pressure_t = typename THch_type< Order, MeshType >::element_type::template sub_element_type< 1 >
template<int Order, typename MeshType >
using	THch_ptrtype = std::shared_ptr< FunctionSpace< MeshType, bases< Lagrange< Order+1, Vectorial >, Lagrange< Order, Scalar > >, double, Periodicity< NoPeriodicity, NoPeriodicity >, mortars< NoMortar, NoMortar > > >
	Define the shared_ptr type for Taylor-Hood space. More...
template<int Order, typename MeshType >
using	THch_type = FunctionSpace< MeshType, bases< Lagrange< Order+1, Vectorial >, Lagrange< Order, Scalar > >, double, Periodicity< NoPeriodicity, NoPeriodicity >, mortars< NoMortar, NoMortar > >
	Define the type for Taylor-Hood space. More...
template<int Order, typename MeshType >
using	THch_velocity_space_ptr_t = typename THch_type< Order, MeshType >::template sub_functionspace_ptrtype< 0 >
template<int Order, typename MeshType >
using	THch_velocity_space_t = typename THch_type< Order, MeshType >::template sub_functionspace_type< 0 >
template<int Order, typename MeshType >
using	THch_velocity_t = typename THch_type< Order, MeshType >::element_type::template sub_element_type< 0 >
using	traced = boost::error_info< struct tag_stacktrace, boost::stacktrace::stacktrace >
template<typename SpaceType >
using	Trial = BasisFunctions< SpaceType, 1 >
template<typename T >
using	type_identity_t = typename type_identity< T >::type
typedef boost::uint16_t	uint16_type
typedef boost::uint32_t	uint32_type
typedef boost::uint64_t	uint64_type
typedef boost::uint8_t	uint8_type
template<typename T >
using	unwrap_ptr_t = remove_shared_ptr_type< std::remove_pointer_t< T > >
template<typename Type >
using	value_t = typename value_type_trait< Type >::type
using	worldcomm_ptr_t = std::shared_ptr< WorldComm >
	WorldComm shared_ptr alias type.
using	worldcomm_t = WorldComm
	WorldComm alias type.
using	worldscomm_ptr_t = std::vector< worldcomm_ptr_t >
	WorldsComm shared_ptr alias type.

Enumerations
enum	{   lvl_info = google::GLOG_INFO , lvl_warn = google::GLOG_WARNING , lvl_debug = google::GLOG_INFO , lvl_error = google::GLOG_ERROR ,   lvl_fatal = google::GLOG_FATAL }
enum	{ INTERPOLATE_DIFFERENT_MESH =0 , INTERPOLATE_SAME_MESH = 1 }
enum	{   STEP_NEW = ( 1 << 0 ) , STEP_HAS_DATA = ( 1 << 1 ) , STEP_ON_DISK = ( 1 << 2 ) , STEP_IN_MEMORY = ( 1 << 3 ) ,   STEP_IGNORED = ( 1 << 4 ) , STEP_OVERWRITE = ( 1 << 10 ) }
	Legacy serialized step-state flags, retained for API/archive compatibility. Scheduling and publication state belong to TimeSet::Step, not ExportFieldSet. More...
enum	BDFTimeScheme {   BDF_ORDER_ONE =1 , BDF_ORDER_TWO , BDF_ORDER_THREE , BDF_ORDER_FOUR ,   BDF_MAX_ORDER = 4 }
enum class	BvhIntersectContext { anyHint =0 , closest , all }
enum class	Checks { NONE =0 , EXACT , CONVERGENCE_ORDER }
enum class	ComponentType {   NO_COMPONENT = -1 , X = 0 , Y , Z ,   NX , NY , NZ , TX ,   TY , TZ }
enum	DebugLevels { DEBUG_INFO = 0 , DEBUG_WARN = 1 , DEBUG_ERROR = 2 , DEBUG_FATAL = 3 }
	Area debugging tool. More...
enum class	DofTableExtendedType { NONE = 0 , VERTICES , DEFAULT }
enum	ElementsType {   MESH_ELEMENTS = 0 , MESH_FACES = 1 , MESH_INTERNAL_FACES = 2 , MESH_EDGES = 3 ,   MESH_INTERNAL_EDGES = 4 , MESH_POINTS = 5 }
	entity identifier for mesh iterators More...
enum class	EntityFilterType { PROCESS_ID , MARKER , ON_BOUNDARY , INTERNAL }
enum class	EntityProcessType {   LOCAL_ONLY , LOCAL_AND_INTERPROCESS_ONLY , GHOST_ONLY , ALL ,   IGNORE_ENTITY_ON_INTERPROCESS_FACE }
enum	FaceLocation { INTERNAL = false , ON_BOUNDARY = true }
enum class	FunctionSpaceReusePolicy { automatic , reuse , rebuild , bypass }
	Select how a whole-mesh function-space request interacts with the manager. More...
enum	FunctionSpaceType { SCALAR = 0 , VECTORIAL = 1 , TENSOR2 , TENSOR2_SYMM }
enum	GeoEntityContext { MESH_ENTITY_INTERNAL = ( 1<<0 ) , MESH_ENTITY_BOUNDARY = ( 1<<1 ) }
enum class	interpolation_operand_type {   ID = 0 , GRADIENT , CURL , DIV ,   EXPR }
enum class	IOStatus { isLoading , isSaving }
enum class	Location {   unknown =0 , global =10 , relative , absolute ,   git , custom }
enum	LogSeverity { INFO = 0 , WARNING = 1 , ERROR = 2 , FATAL = 3 }
enum	MESH_CHANGES { MESH_CHANGES_POINTS_COORDINATES = 0 , MESH_CHANGES_CONNECTIVITY = 1 , MESH_CHANGES_PARTITION = 2 }
enum	MeshComponents {   MESH_UPDATE_EDGES = ( 1 << 0 ) , MESH_UPDATE_FACES = ( 1 << 1 ) , MESH_CHECK = ( 1 << 2 ) , MESH_PARTITION = ( 1 << 3 ) ,   MESH_RENUMBER = ( 1 << 4 ) , MESH_ADD_ELEMENTS_INFO = ( 1 << 5 ) , MESH_PROPAGATE_MARKERS = ( 1 << 6 ) , MESH_REMOVE_PERIODIC_FACES_FROM_BOUNDARY = ( 1 << 7 ) ,   MESH_NO_UPDATE_MEASURES = ( 1 << 8 ) , MESH_UPDATE_ELEMENTS_ADJACENCY = ( 1 << 9 ) , MESH_UPDATE_FACES_MINIMAL = ( 1 << 10 ) , MESH_GEOMAP_NOT_CACHED = ( 1 << 11 ) ,   MESH_DO_NOT_UPDATE = (1 << 16 ) }
	Mesh components enum. More...
enum	Pattern {   DEFAULT = 1 << 0 , DEFAULT , EXTENDED = 1 << 1 , COUPLED = 1 << 2 ,   PATTERN_SYMMETRIC = 1 << 3 , ZERO = 1 << 4 , HAS_NO_BLOCK_PATTERN = 1 << 5 , HDG = 1 << 6 ,   NONE = 1<<7 , NONE =0 , NONE = 0 }
enum	ReferenceGeometry {   GEOMETRY_POINT = ( 1<<0 ) , GEOMETRY_LINE = ( 1<<1 ) , GEOMETRY_SURFACE = ( 1<<2 ) , GEOMETRY_VOLUME = ( 1<<3 ) ,   GEOMETRY_4 = ( 1<<4 ) , GEOMETRY_5 = ( 1<<5 ) }
enum	ReferenceShapes {   SHAPE_LINEAR = ( 1<<0 ) , SHAPE_BILINEAR = ( 1<<1 ) , SHAPE_QUADRATIC = ( 1<<2 ) , SHAPE_NONE = ( 1<<3 ) ,   SHAPE_POINT = ( 1<<4 ) , SHAPE_LINE = ( 1<<5 ) , SHAPE_TRIANGLE = ( 1<<6 ) , SHAPE_QUAD = ( 1<<7 ) ,   SHAPE_HEXA = ( 1<<8 ) , SHAPE_PRISM = ( 1<<9 ) , SHAPE_TETRA = ( 1<<10 ) , SHAPE_SP4 = ( 1<<11 ) ,   SHAPE_SP5 = ( 1<<12 ) }
enum class	RemeshMode { MMG = 1 , PARMMG = 2 }
enum class	select_elements_from_expression {   with_positive_values = 1 , with_negative_values = 2 , with_changing_sign = 3 , with_value = 4 ,   with_value_range = 5 }
	EXTRACT_ELEM.
enum class	solution_t { unique , up_to_a_constant }
enum	StabilizationMethods {   NO , CIP , SGS , SUPG ,   GALS }
enum class	SymmetricTensorOrder {   Storage , DiagonalFirst , VtkTensor6 , EnsightTensor6 ,   XdmfTensor6 }
	Output order for packed symmetric tensor components. More...
enum class	SymmetricTensorScaling { Tensor , EngineeringShear , Mandel }
	Scaling convention applied to off-diagonal symmetric tensor entries. More...
enum	tokenids { IDANY = spirit::lex::min_token_id + 10 }
enum	TSState { TS_UNITIALIZED = 0 , TS_RUNNING , TS_STOPPED }
enum	TSStragegy { TS_STRATEGY_DT_CONSTANT , TS_STRATEGY_DT_ADAPTATIVE }
enum class	Zone { LOCAL , GLOBAL , NEIGHBORHOOD }
	A Zone can be LOCAL or GLOBAL, NEIGHBORHOOD.

Functions
template<typename ... Ts>
AboutData	about (Ts &&... v)
Repository::Config	absoluteRepository (fs::path abs_path)
	Create repository config for absolute path location. More...
Feel::po::options_description	advection_options (std::string const &prefix)
Feel::po::options_description	alemesh_options (std::string const &prefix)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	allelements (MeshType const &mesh)
template<typename MeshType >
auto	allmarkededgesByType (MeshType const &mesh, uint16_type markerType, entity_process_t ept, typename std::enable_if< is_2d< MeshType >::value >::type *=nullptr)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	allmarkededgesByType (MeshType const &mesh, uint16_type markerType, entity_process_t ept, typename std::enable_if< is_3d< MeshType >::value >::type *=nullptr)
template<typename MeshType >
auto	allmarkedfacesByType (MeshType const &mesh, uint16_type markerType, entity_process_t ept)
template<typename MeshType >
auto	allmarkedpointsByType (MeshType const &mesh, uint16_type markerType, entity_process_t ept)
std::string	askPassword (std::string const &message)
	Ask the user to fill a password. The password is hidden with asterisks. More...
FEELPP_NO_EXPORT std::pair< std::string, std::string >	at_option_parser (std::string const &s)
FEELPP_NO_EXPORT std::pair< std::string, std::string >	at_option_parser_2 (std::string const &s)
std::string	backtrace ()
std::string	backtrace (int)
template<typename ... Ts>
auto	bdf (Ts &&... v)
template<size_t S, class ITERATOR >
ITERATOR	begin (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR > &range)
template<size_t S, class ITERATOR >
ITERATOR	begin (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR > const &range)
template<size_t S, class ITERATOR , class CONTAINER >
ITERATOR	begin (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR, CONTAINER > &range)
template<size_t S, class ITERATOR , class CONTAINER >
ITERATOR	begin (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR, CONTAINER > const &range)
template<typename MeshType , int MESH_ENTITIES>
auto	begin (Range< MeshType, MESH_ENTITIES > &range)
	get the begin iterator of a range More...
template<typename MeshType , int MESH_ENTITIES>
auto	begin (Range< MeshType, MESH_ENTITIES > const &range)
template<class ITERATOR >
ITERATOR	begin (std::pair< ITERATOR, ITERATOR > &range)
po::options_description	benchmark_options (std::string const &prefix)
template<typename PS >
BlockLinearForm< PS >	blockform1 (PS &&ps)
template<typename PS , typename BackendT >
BlockLinearForm< PS >	blockform1 (PS &&ps, BackendT &&b)
template<typename PS , typename T >
BlockLinearForm< PS >	blockform1 (PS &&ps, condensed_vector_ptr_t< T > v)
template<typename PS , typename BackendT >
BlockLinearForm< PS >	blockform1 (PS &&ps, solve::strategy s, BackendT &&b)
template<typename PS > requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS &&ps)
template<typename PS , typename BackendT > requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS &&ps, BackendT &&b)
template<typename PS , typename T > requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS &&ps, condensed_matrix_ptr_t< T > &m)
template<typename PS , typename BackendT , typename RangeMapT = StencilRangeMap0Type> requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS &&ps, solve::strategy s, BackendT &&b, size_type pattern=Pattern::COUPLED, RangeMapT r=stencilRangeMap())
template<typename PS , typename BackendT , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS &&ps, solve::strategy s, BackendT &&b, std::vector< PatternSizeT > const &patterns, RangeMapT r=stencilRangeMap())
template<typename PS , typename BackendT , typename RangeMapT = StencilRangeMap0Type> requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS const &ps, solve::strategy s, BackendT &&b, size_type pattern=Pattern::COUPLED, RangeMapT r=stencilRangeMap())
template<typename PS , typename BackendT , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires ( !NA::is_named_argument_v<std::decay_t<PS>> )
BlockBilinearForm< PS >	blockform2 (PS const &ps, solve::strategy s, BackendT &&b, std::vector< PatternSizeT > const &patterns, RangeMapT r=stencilRangeMap())
template<typename ... Ts> requires Feel::detail::Blockform2NamedArgumentsWithTrial<Ts...>
auto	blockform2 (Ts &&... v)
template<typename ... Ts> requires ( Feel::detail::Blockform2NamedArguments<Ts...> && !Feel::detail::Blockform2NamedArgumentsWithTrial<Ts...> )
auto	blockform2 (Ts &&... v)
FEELPP_TRAITS_OP_CODE	BOOST_PP_TUPLE_REVERSE_1 ((float, float, 1, 0, 7, std::numeric_limits< float >::epsilon() *factor_from_eps_fl, 0)) FEELPP_TRAITS_OP_CODE BOOST_PP_TUPLE_REVERSE_1((double
	Generate the type traits.
template<typename ... Ts>
bool	boption (Ts &&... v)
template<typename MeshType >
auto	boundaryedges (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	boundaryelements (MeshType const &mesh, uint16_type entity_min_dim=0, uint16_type entity_max_dim=2, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	boundaryfaces (MeshSupportType const &imesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	boundaryfaces (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
Range< MeshType, MESH_FACES >	boundaryfaces (MeshType const &mesh, Range< MeshType, MESH_ELEMENTS > const &r)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	boundaryfaces (MeshType const &mesh, rank_type pid, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	boundarypoints (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename... Ts>
auto	boundingVolumeHierarchy (Ts &&... v)
FEELPP_NO_EXPORT RegionTree::element_base *	build (RegionTree::pbox_container_type &b, const node_type &bmin, const node_type &bmax, size_type last_dir)
constexpr int	cantor_pairing (int a, int b)
	a pairing function is a process to uniquely encode two natural numbers into a single natural number. More...
template<typename... T>
constexpr int	cantor_pairing (int a, int b, T &&... ts)
	compute cantor pairing recursively for number of natural numbers > 2 More...
FEELPP_EXPORT MasterStream	cerr (std::cerr, nullptr, Logger::Level::warn)
template<typename CheckerT , typename ElementT > requires is_scalar_field_v<ElementT> || is_vector_field_v<ElementT> || is_matrix_field_v<ElementT>
int	check (CheckerT &&thechecker, ElementT const &u, solution_t s=solution_t::unique)
template<typename ... Ts>
Checker	checker (Ts &&... v)
	check create function More...
void	cleanupTemporaryDirectory (const std::string &extractionDir)
	Remove all files and directories in a directory. More...
FEELPP_EXPORT MasterStream	clog (std::clog, nullptr, Logger::Level::info)
Feel::po::options_description	coefficientformpde_options (std::string const &prefix)
Feel::po::options_description	coefficientformpdes_options (std::string const &prefix)
template<typename MeshType >
std::map< int, Range< MeshType, MESH_ELEMENTS > >	collectionOfMarkedelements (MeshType const &mesh, std::any const &collectionOfMarkersFlag)
template<typename MeshType >
auto	collectionOfMarkedelementsWithGhostsSplitted (MeshType const &mesh, std::any const &collectionOfMarkersFlag)
template<typename IteratorType , typename Predicate >
auto	complement (IteratorType &&it, Predicate pred)
	Provides the complement of the set of entities given by [begin(it),end(it)] with respect to the negation of predicate pred. More...
template<typename RangeType , typename... Args>
FEELPP_EXPORT auto	concatenate (RangeType &&r, Args &&... args)
	this function takes a set of iterators over geometrical entities of the same type (e.g. More...
template<typename... Ts>
auto	context (Ts &&... v)
	get the the geometric mapping context associated to a functionspace More...
std::pair< bool, nl::json >	convertDescToJson (std::string const &desc)
template<typename ... Ts>
auto	convolve (Ts &&... varg)
template<typename ... Ts>
int	countoption (Ts &&... v)
template<typename Predicate >
auto	countWithoutGhost (Predicate is_ghost)
	Lambda function factory to count cells excluding ghosts. More...
FEELPP_EXPORT MasterStream	cout (std::cout, nullptr, Logger::Level::info)
template<typename SpacePtrType , typename MetricSetter >
bool	createGradedLevelsetMetric (SpacePtrType const &P1h, std::string const &metric_expr, MetricSetter metric_setter, std::vector< std::string > default_markers={})
	Create a Graded Levelset metric. More...
template<typename ... Ts>
auto	createSubmesh (Ts &&... v)
template<typename ... Ts>
auto	createSubmeshP1 (Ts &&... v)
template<typename T , typename IndexT >
ublas::vector< double >	cross (Geo0D< 3, T, IndexT > p1, Geo0D< 3, T, IndexT > p2)
template<typename E1 , typename E2 >
ublas::vector< double >	cross (ublas::vector_expression< E1 > _p1, ublas::vector_expression< E2 > _p2)
template<typename PS , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<PS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (PS &&ps, std::vector< PatternSizeT > const &patterns, RangeMapT range=stencilRangeMap())
template<typename PS , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<PS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (PS &&ps, std::vector< PatternSizeT > const &patterns, RangeMapT range=stencilRangeMap())
template<typename PS , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<PS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (PS &&ps, uint32_type pattern=Pattern::COUPLED, RangeMapT range=stencilRangeMap())
template<typename PS , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<PS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (PS &&ps, uint32_type pattern=Pattern::COUPLED, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, std::vector< PatternSizeT > const &patterns, RangeMapT range=stencilRangeMap())
	Build rectangular blocks of CSR graphs from distinct row/test and column/trial product spaces.
template<typename TestPS , typename TrialPS , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, std::vector< PatternSizeT > const &patterns, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, std::vector< PatternSizeT > const &patterns, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename PatternSizeT , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, std::vector< PatternSizeT > const &patterns, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, uint32_type pattern=Pattern::COUPLED, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, uint32_type pattern=Pattern::COUPLED, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpacesBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, uint32_type pattern=Pattern::COUPLED, RangeMapT range=stencilRangeMap())
template<typename TestPS , typename TrialPS , typename RangeMapT = StencilRangeMap0Type> requires std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TestPS>> && std::is_base_of_v<ProductSpaceBase, std::remove_reference_t<TrialPS>> && std::is_base_of_v<StencilRangeMapTypeBase, RangeMapT>
BlocksBaseGraphCSR	csrGraphBlocks (TestPS &&testPs, TrialPS &&trialPs, uint32_type pattern=Pattern::COUPLED, RangeMapT range=stencilRangeMap())
template<typename ... Ts>
auto	Curl (Ts &&... v)
Repository::Config	customRepository (std::string reldir, std::function< fs::path()> callback)
	Create a Repository Config with custom location callback. More...
DebugStream	Debug (bool cond, int area, DebugStream::stprintf)
DebugStream	Debug (int area, DebugStream::stprintf func)
Feel::po::options_description	densityviscosity_options (std::string const &prefix)
	generate options for the fluid solver
FEELPP_NO_EXPORT void	destroy (RegionTree::element_base *n)
template<int Order, typename MeshType >
dh_ptrtype< Order, MeshType >	Dh (std::shared_ptr< MeshType > mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
template<int Order, typename MeshType >
std::shared_ptr< FunctionSpace< MeshType, bases< RaviartThomas< Order >, Lagrange< Order, Scalar, Discontinuous > > > >	DhPdh (std::shared_ptr< MeshType > mesh, std::vector< DofTableExtendedType > dte=std::vector< DofTableExtendedType >(2, DofTableExtendedType::DEFAULT))
template<typename T >
constexpr int	dimension (T const &t)
template<typename T , typename IndexT >
T	distance (Geo0D< 1, T, IndexT > const &p1, Geo0D< 1, T, IndexT > const &p2)
template<typename T , typename IndexT >
T	distance (Geo0D< 2, T, IndexT > const &p1, Geo0D< 2, T, IndexT > const &p2)
template<typename T , typename IndexT >
T	distance (Geo0D< 3, T, IndexT > const &p1, Geo0D< 3, T, IndexT > const &p2)
template<typename ElementType >
ElementType	div (ElementType const &v1, ElementType const &v2, typename boost::enable_if< boost::is_base_of< FunctionSpaceBase::ElementBase, ElementType > >::type *dummy=0)
	Computes the element wise division of two vectors and eventually in parallel. More...
template<typename ... Ts>
auto	Div (Ts &&... v)
template<typename ... Ts>
double	doption (Ts &&... v)
FEELPP_NO_EXPORT void	dump (RegionTree::element_base *p, int level, size_type &count)
template<typename MeshT , typename = std::enable_if_t<is_mesh_v<MeshT>>>
void	dump (std::shared_ptr< MeshT > const &mesh, std::string const &header={})
char **	dupargv (char **argv)
template<typename SpaceT , bool same_mesh = true>
ProductSpace< SpaceT, same_mesh >	dynProduct (int n, typename SpaceT::mesh_ptrtype mesh)
template<typename SpaceT , bool same_mesh = true>
std::shared_ptr< ProductSpace< SpaceT, same_mesh > >	dynProductPtr (int n, std::shared_ptr< SpaceT > const &s)
template<typename SpaceT , bool same_mesh = true>
std::shared_ptr< ProductSpace< SpaceT, same_mesh > >	dynProductPtr (int n, typename SpaceT::mesh_ptrtype mesh)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	edges (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
FEELPP_EXPORT void	editPtreeFromOptions (pt::ptree &p, std::string const &prefix)
	Edit the value in the ptree from the command line options The syntax is : –json-editions=key1:value1 key2:value2 key3:value3.
Feel::po::options_description	electricity_options (std::string const &prefix)
template<typename ElementType >
boost::tuple< mpl::size_t< MESH_ELEMENTS >, typename std::list< ElementType >::const_iterator, typename std::list< ElementType >::const_iterator >	element (ElementType const &elt)
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	elements (MeshSupportType const &imesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>
auto	elements (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , typename EntityRangeType , std::enable_if_t< is_range_v< EntityRangeType >, int > = 0>
auto	elements (MeshType const &mesh, EntityRangeType const &rangeEntity, ElementsType type=ElementsType::MESH_POINTS)
template<typename MeshType , typename RangeType , typename EntityRangeType >
Range< typename RangeType::mesh_t, MESH_ELEMENTS >	elements (MeshType const &mesh, RangeType const &rangeElt, EntityRangeType const &rangeEntity, ElementsType type=ElementsType::MESH_POINTS)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>
auto	elements (MeshType const &mesh, rank_type pid, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , typename ExprType , typename... Ts, std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>
Range< MeshType, MESH_ELEMENTS >	elements (MeshType const &mesh, vf::Expr< ExprType > const &expr, Ts &&... v)
template<typename MeshType >
auto	elementsWithMarkedFaces (MeshType const &imesh, boost::any const &flag, EntityProcessType entity=EntityProcessType::LOCAL_ONLY)
template<size_t S, class ITERATOR >
ITERATOR	end (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR > &range)
template<size_t S, class ITERATOR >
ITERATOR	end (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR > const &range)
template<size_t S, class ITERATOR , class CONTAINER >
ITERATOR	end (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR, CONTAINER > &range)
template<size_t S, class ITERATOR , class CONTAINER >
ITERATOR	end (boost::tuple< mpl::size_t< S >, ITERATOR, ITERATOR, CONTAINER > const &range)
template<typename MeshType , int MESH_ENTITIES>
auto	end (Range< MeshType, MESH_ENTITIES > &range)
template<typename MeshType , int MESH_ENTITIES>
auto	end (Range< MeshType, MESH_ENTITIES > const &range)
template<class ITERATOR >
ITERATOR	end (std::pair< ITERATOR, ITERATOR > &range)
template<int EntityCoDim, typename ElementT >
std::optional< std::map< uint16_type, typename ElementT::marker_type > >	entityMarkers (ElementT const &e, uint16_type f)
	get the map of markers of a entity of a geoelement More...
template<typename T , typename TIter = decltype(std::begin(std::declval<T>())), typename = decltype(std::end(std::declval<T>()))>
constexpr auto	enumerate (T &&iterable, size_t start=0)
	create an index associated to a iterable object More...
DebugStream	Error (bool cond, int area)
DebugStream	Error (int area)
template<typename MeshType >
std::shared_ptr< Pdh_element_t< MeshType, 0 > >	etaQ (Pdh_ptrtype< MeshType, 0 > const &Xh, std::shared_ptr< MeshType > const &m)
	Return default triangle/tetrahedra quality (eta) of a given cell. More...
template<typename MeshType >
std::shared_ptr< Pdh_element_t< MeshType, 0 > >	etaQ (std::shared_ptr< MeshType > const &m)
template<typename ElementType , typename CoeffType >
Feel::remove_shared_ptr_type< ElementType >	expansion (std::vector< ElementType > const &b, CoeffType const &c, int M=-1)
	Given a set of coefficient c and a set of finite element function b, build. More...
template<typename ElementType , typename CoeffType >
void	expansion (std::vector< ElementType > const &b, CoeffType const &c, Vector< typename Feel::remove_shared_ptr_type< ElementType >::value_type > &res, int M=-1)
	Given a set of coefficient c and a set of finite element function b, build. More...
template<typename MeshT , typename ExprT , std::enable_if_t< std::is_base_of_v< MeshBase< typename MeshT::index_type >, MeshT > &&std::is_base_of_v< ExprBase, ExprT >, MeshT > * = nullptr>
Pch_element_type< MeshT, 1 >	expr (std::shared_ptr< MeshT > const &mesh, ExprT &&e)
	create an isotropic metric field based on a scalar expression More...
template<typename SpaceT , typename ExprT , std::enable_if_t< std::is_base_of_v< FunctionSpaceBase, SpaceT > &&std::is_base_of_v< ExprBase, ExprT >, SpaceT > * = nullptr>
SpaceT::element_type	expr (std::shared_ptr< SpaceT > const &Xh, ExprT &&e)
	create an isotropic metric field based on a scalar expression More...
bool	extractZipFile (const std::string &zipFilePath, const std::string &extractionDir)
	Extract a zip file to a directory. More...
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	faces (MeshSupportType const &imesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	faces (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	faces (MeshType const &mesh, rank_type pid, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename FacetType >
auto	facetGlobalToLocal (FacetType &&f)
	get the local indexing of a facet from the global id More...
template<typename FacetType , typename DofTableType >
auto	facetGlobalToLocal (FacetType &&f, DofTableType &&dof)
	get the local indexing of a facet from the global id and a doftable More...
DebugStream	Fatal (bool cond, int area)
DebugStream	Fatal (int area)
bool	filename_is_dot (fs::path const &p)
bool	filename_is_dot_dot (fs::path const &p)
std::optional< fs::path >	findGitDirectory (fs::path p)
fs::path	findHome ()
std::string	findUser ()
template<typename ExprT1 >
Expr< FlatExpr< ExprT1 > >	flat (ExprT1 const &__e1)
	precompute expression tensor More...
Feel::po::options_description	fluidMechanics_options (std::string const &prefix)
Feel::po::options_description	fluidStructInteraction_options (std::string const &prefix)
template<typename Xs , typename F , std::enable_if_t< boost::hana::Foldable< Xs >::value, int > = 0>
void	for_each (Xs &&xs, F &&f)
template<typename X1 , typename RepType >
vf::detail::LinearForm< X1, RepType, RepType >	form (std::string name, std::shared_ptr< X1 > const &__X1, std::shared_ptr< RepType > __M, size_type rowstart=0, bool init=false, bool do_threshold=false, typename X1::value_type threshold=type_traits< typename RepType::value_type >::epsilon())
template<typename X1 , typename X2 >
vf::detail::BilinearForm< X1, X2 >	form (std::string name, std::shared_ptr< X1 > const &__X1, std::shared_ptr< X2 > const &__X2, std::shared_ptr< MatrixSparse< double > > __M, size_type rowstart=0, size_type colstart=0, bool init=false, bool do_threshold=false, typename X1::value_type threshold=type_traits< double >::epsilon(), size_type pattern=Pattern::COUPLED)
template<typename ... Ts>
auto	form1 (Ts &&... v)
	create a linear form using named arguments More...
template<typename ... Ts>
auto	form1_mean (Ts &&... v)
template<typename ... Ts>
auto	form2 (Ts &&... v)
	create a bi-linear form using named arguments More...
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	fragmentationMarkedElements (MeshType const &mesh, EntityProcessType entity=EntityProcessType::LOCAL_ONLY, bool includeNonMarkedElement=true)
	return mesh fragmentatin by marked elements : a mapping between fragment id to to the tuple (range, marker ids, fragment name)
void	freeargv (char **vector)
template<typename ... Ts>
auto	functionalLinear (Ts &&... v)
template<typename ... Ts>
auto	functionalLinearComposite (Ts &&... v)
template<typename ... Ts>
auto	functionalLinearFree (Ts &&... v)
template<typename FunctionType , typename... FunctionArgsExprsType>
auto	functionExpr (FunctionType f, const FunctionArgsExprsType &... argsExprs)
template<int O, typename FunctionType , typename... FunctionArgsExprsType>
auto	functionExpr (FunctionType f, const FunctionArgsExprsType &... argsExprs)
template<typename FunctionType , int Order, typename FunctionArgsTupleType >
auto	functionExprWithArgsTuple (FunctionType &&f, FunctionArgsTupleType &&args)
template<typename FunctionType , int Order, typename FunctionArgsTupleType >
auto	functionExprWithArgsTuple (FunctionType const &f, FunctionArgsTupleType const &args)
template<typename... Ts>
auto	geomapPrecompute (Ts &&... v)
	precompute geometric mapping at a set of points
int	getOneChar ()
	Get a unique char (no return cariage requrired). This function is a custom getch.
template<typename SpaceType , typename MeshType , typename Factory >
std::shared_ptr< SpaceType >	getOrCreateFunctionSpace (std::shared_ptr< MeshType > const &mesh, FunctionSpaceManagerOptions const &options, FunctionSpaceReusePolicy policy, Factory &&factory)
	Typed factory adapter for the process-wide function-space manager. More...
template<typename SpaceType , typename MeshType , typename Factory >
std::shared_ptr< SpaceType >	getOrCreateWholeMeshFunctionSpace (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte, FunctionSpaceReusePolicy policy, Factory &&factory)
	Get or construct a whole-mesh function space with standard mesh options. More...
Repository::Config	gitRepository (fs::path start_path=".")
	Create repository config for git location. More...
template<typename C >
auto	globalRank (C const &c)
template<typename T , typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>
T	globalReduce (T local, bool global, RangeT const &r)
	Utility function for MPI global reduction. More...
Repository::Config	globalRepository (std::string reldir, nl::json d={})
std::tm	gmtimeFrom (std::chrono::system_clock::time_point tp)
	Return a std::tm in UTC from a given system_clock::time_point. More...
std::tm	gmtimeNow ()
	Return current time as std::tm in UTC for use with {fmt}. More...
template<typename ... Ts>
auto	Grad (Ts &&... v)
template<typename SpaceT , typename RangeType , std::enable_if_t< std::is_base_of_v< FunctionSpaceBase, SpaceT > &&is_range_v< decay_type< RangeType > > &&decay_type< RangeType >::entities()==MESH_FACES, SpaceT > * = nullptr>
SpaceT::element_type	gradedfromls (std::shared_ptr< SpaceT > const &Xh, RangeType &&facets, double hclose, double hfar, double cst=0.)
	create an isotropic metric field based on a levelset gradation More...
void	handleExceptions ()
	handle exceptions using a Lippincott function this funnction allows to handle the exceptions thrown in Feel++ More...
template<typename EltType >
bool	hasFaceWithAnyOfTheMarkers (EltType const &e, std::vector< std::string > const &flags, std::enable_if_t<(dimension_v< EltType > > 0) &&is_geoelement_v< EltType > > *=nullptr)
	check if a element as faces with any of the string markers More...
template<typename EltType >
bool	hasFaceWithMarker (EltType const &e, boost::any const &flag, std::enable_if_t<(dimension_v< EltType > > 0) &&is_geoelement_v< EltType > > *=nullptr)
	get if a face of an element has the marker flag More...
template<size_type Contextv>
bool	hasValue (size_type c)
bool	hasValue (size_type c, size_type v)
Feel::po::options_description	heat_options (std::string const &prefix)
Feel::po::options_description	heatFluid_options (std::string const &prefix)
template<typename MeshType > requires is_mesh_v<MeshType>
auto	hMeasures (MeshType &&m)
	compute h measures statistics over all elements of a mesh
template<typename RangeType > requires is_range_v<RangeType>
std::tuple< value_t< RangeType >, value_t< RangeType >, value_t< RangeType > >	hMeasures (RangeType &&r)
template<typename RangeType > requires is_range_v<RangeType>
std::tuple< value_t< RangeType >, value_t< RangeType >, value_t< RangeType > >	hMeasures (RangeType &&r, size_t nEntityInRange)
	compute h measure statistics over a range of elements or facets
template<typename MeshType > requires is_mesh_v<MeshType>
auto	hMeasures (std::shared_ptr< MeshType > const &m)
	compute h measures statistics over all elements of a shared_ptr<mesh> More...
template<typename ... Ts>
auto	I (Ts &&... v)
template<typename MeshType >
auto	idedelements (MeshType const &mesh, flag_type flag)
template<typename MeshType >
auto	idedfaces (MeshType const &mesh, size_type id)
template<typename MeshType , typename IteratorType >
auto	idelements (MeshType const &imesh, IteratorType begin, IteratorType end)
template<typename MeshType , typename T >
auto	idelements (MeshType const &imesh, std::vector< T > const &l)
	build a list of elements based on a list of element ids l from a mesh imesh
template<typename ... Ts>
auto	integrate (Ts &&... v)
Feel::po::options_description	interfaceforces_options (std::string const &prefix)
template<typename MeshType >
auto	internaledges (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	internalelements (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	internalfaces (MeshSupportType const &imesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	internalfaces (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
Range< MeshType, MESH_FACES >	internalfaces (MeshType const &mesh, Range< MeshType, MESH_ELEMENTS > const &r)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	internalfaces (MeshType const &mesh, rank_type pid, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	internalpoints (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename SpaceType , typename FunctionType , typename InterpType >
void	interpolate (std::shared_ptr< SpaceType > const &space, FunctionType const &f, InterpType &interp)
	Given a space space using a lagrange basis, compute the interpolation interp of f belonging to another function space. More...
template<typename SpaceType , typename FunctionType >
bool	interpolate_copy (std::shared_ptr< SpaceType > const &space, FunctionType const &f, typename SpaceType::element_type &interp)
template<typename InterpType , typename SizeT >
void	interpolate_sync (InterpType &interp, bool hasMeshSupportPartialDomain, std::set< SizeT > const &dofUsedWithPartialMeshSupport)
template<typename MeshType >
auto	interprocessedges (MeshType const &imesh, rank_type neighbor_pid=invalid_rank_type_value, EntityProcessType entity=EntityProcessType::ALL)
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	interprocessfaces (MeshSupportType const &imesh, rank_type neighbor_pid=invalid_v< rank_type >)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	interprocessfaces (MeshType const &mesh)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	interprocessfaces (MeshType const &mesh, rank_type neighbor_pid)
template<typename RangeType , typename... Args>
FEELPP_EXPORT auto	intersect (RangeType &&it, Args &&... args)
	this function takes a set of iterators over geometrical entities of the same type (e.g. More...
template<typename ... Ts>
int	ioption (Ts &&... v)
constexpr int64_t	ipow (int64_t base, int exp, int64_t result=1)
	compute integer power More...
template<typename ... Ts>
auto	IPtr (Ts &&... v)
template<typename PS >
constexpr auto	is_product_spaces (PS &&ps)
template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>
auto	isGhostCell ()
	Lambda function factory to check if a cell is a ghost. More...
template<typename ... Ts>
auto	lagrangeP1 (Ts &&... v)
Feel::po::options_description	levelset_options (std::string const &prefix)
Dataset	loadDatasetDescription (const std::string &jsonPath)
Repository::Config	localRepository (std::string reldir, nl::json d={})
Location	location (const std::string &location_string) noexcept
	get the Location enum from string More...
const std::string &	location (Location location_enum) noexcept
	get location string from Location enum the string is empty if the Location is unknown More...
DebugStream	Log (bool cond, int area, DebugStream::stprintf)
DebugStream	Log (int area, DebugStream::stprintf func)
template<typename MeshType >
decltype(auto)	make_elements_wrapper ()
AboutData	makeAboutDefault (std::string name)
	default makeAbout function to define the AboutData structure of the Feel++ application More...
template<typename C , typename ... Args>
InterpolationCurl< C >	makeCurlInterpolation (C &&c, Args &&... args)
template<typename C , typename ... Args>
InterpolationDiv< C >	makeDivInterpolation (C &&c, Args &&... args)
template<typename ExprType , typename C , typename ... Args>
InterpolationExpr< ExprType, C >	makeExprInterpolation (ExprType const &expr, C &&c, Args &&... args)
template<typename C , typename ... Args>
InterpolationGradient< C >	makeGradientInterpolation (C &&c, Args &&... args)
template<typename C , typename ... Args>
InterpolationID< C >	makeInterpolation (C &&c, Args &&... args)
template<class T , class... Args>
decltype(auto)	makeMesh (Args &&... args)
template<typename Geo , uint16_type Dim = 1, uint16_type Order = 1, uint16_type RDim = Dim, typename T = double>
Reference< Geo, Geo::nDim, 1, Geo::nRealDim, T >	makeReferenceConvex ()
template<class T , class... Args>
std::shared_ptr< Mesh< T > >	makeSharedMesh (Args &&... args)
	Create a shared pointer Mesh<T> from Args. More...
template<class T , class... Args>
std::unique_ptr< Mesh< T > >	makeUniqueMesh (Args &&... args)
	Create a unique pointer Mesh<T> from Args. More...
worldscomm_ptr_t	makeWorldsComm (int n, WorldComm &wc)
	Create a WorldsComm shared_ptr of size n from cloning wc. More...
worldscomm_ptr_t	makeWorldsComm (int n, worldcomm_ptr_t const &wc)
	Create a WorldsComm shared_ptr of size n from cloning shared_ptr wc. More...
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked2elements (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked2elements (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked2faces (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked2faces (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked3elements (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked3elements (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked3faces (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	marked3faces (MeshType const &mesh, std::initializer_list< boost::any > markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markededges (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markededges (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markededges (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	markededgesByType (MeshType const &mesh, uint16_type markerType, boost::any const &__marker, entity_process_t ept, typename std::enable_if< is_3d< MeshType >::value >::type *=nullptr)
template<typename MeshType >
auto	markededgesByType (MeshType const &mesh, uint16_type markerType, boost::any const &markersFlag, entity_process_t ept, typename std::enable_if< is_2d< MeshType >::value >::type *=nullptr)
template<typename MeshType >
auto	markededgesByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept, typename std::enable_if< is_2d< MeshType >::value >::type *=nullptr)
template<typename MeshType >
auto	markededgesByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept, typename std::enable_if< is_3d< MeshType >::value >::type *=nullptr)
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	markedelements (MeshSupportType const &imesh, boost::any markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markedelements (MeshType const &mesh)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markedelements (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markedelements (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	markedelementsByType (MeshType const &mesh, uint16_type markerType, boost::any const &markersFlag, entity_process_t ept)
template<typename MeshType >
auto	markedelementsByType (MeshType const &mesh, uint16_type markerType, boost::any const &markersFlag, rank_type pid, entity_process_t ept)
template<typename MeshType >
auto	markedelementsByType (MeshType const &mesh, uint16_type markerType, entity_process_t ept)
template<typename MeshType >
auto	markedelementsByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept)
template<typename MeshType >
auto	markedelementsByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, rank_type pid, entity_process_t ept)
template<typename MeshSupportType , std::enable_if_t< std::is_base_of_v< MeshSupportBase, unwrap_ptr_t< MeshSupportType > >, int > = 0>
auto	markedfaces (MeshSupportType const &imesh, boost::any markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markedfaces (MeshType const &mesh)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markedfaces (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>
auto	markedfaces (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	markedfacesByType (MeshType const &mesh, uint16_type markerType, boost::any const &markersFlag, entity_process_t ept)
template<typename MeshType >
auto	markedfacesByType (MeshType const &mesh, uint16_type markerType, boost::any const &markersFlag, rank_type pid, entity_process_t ept)
template<typename MeshType >
auto	markedfacesByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept)
template<typename MeshType >
auto	markedfacesByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, rank_type pid, entity_process_t ept)
template<typename MeshType >
auto	markedpoints (MeshType const &mesh, boost::any const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	markedpoints (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	markedpoints (MeshType const &mesh, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept=entity_process_t::LOCAL_ONLY)
template<typename MeshType >
auto	markedpointsByType (MeshType const &mesh, uint16_type markerType, boost::any const &__marker, entity_process_t ept)
template<typename MeshType >
auto	markedpointsByType (MeshType const &mesh, uint16_type markerType, std::initializer_list< boost::any > const &markersFlag, entity_process_t ept)
std::vector< MeshMarkerName >	markerMap (int Dim)
template<typename... Ts>
auto	maxelt (Ts &&... v)
	compute the max of the element of a function space at DOF points over the range r More...
Feel::po::options_description	maxwell_options (std::string const &prefix)
template<typename ... Ts>
auto	mean (Ts &&... v)
template<typename ... Ts>
double	measure (Ts &&... v)
template<typename MeshType >
auto	measurePointElements (std::shared_ptr< FunctionSpace< MeshType, bases< Lagrange< MeshType::nOrder, Scalar > > > > &Xh) -> decltype(Xh->element())
	Given a function space Xh, compute the sum of of the measure of the elements shared by a point in the mesh. More...
template<typename Shape , typename T , int Tag1, int Tag2 = Tag1, int TheTag = Tag1>
std::shared_ptr< Mesh< Shape, T, TheTag > >	merge (std::shared_ptr< Mesh< Shape, T, Tag1 > > m1, std::shared_ptr< Mesh< Shape, T, Tag2 > > m2)
FEELPP_EXPORT void	mergePtree (pt::ptree &pa, const pt::ptree &pb)
template<typename MeshType , typename DisplType >
std::shared_ptr< MeshType >	meshMove (std::shared_ptr< MeshType > &m, DisplType const &u)
template<typename C >
FEELPP_DEPRECATED auto	meshrank (C const &c)
template<typename T , typename IndexT >
Geo0D< 1, T, IndexT >	middle (Geo0D< 1, T, IndexT > const &p1, Geo0D< 1, T, IndexT > const &p2)
template<typename T , typename IndexT >
Geo0D< 2, T, IndexT >	middle (Geo0D< 2, T, IndexT > const &p1, Geo0D< 2, T, IndexT > const &p2)
template<typename T , typename IndexT >
Geo0D< 3, T, IndexT >	middle (Geo0D< 3, T, IndexT > const &p1, Geo0D< 3, T, IndexT > const &p2)
template<typename MeshType , typename RangeType >
FEELPP_EXPORT Range< typename MeshTraits< MeshType >::mesh_type, RangeType::mesh_entities >	migrate (MeshType const &mesh, RangeType const &range)
	This function takes a mesh and a range of entities defined on another mesh. If a mesh relation exists between mesh and range (sub mesh or parent mesh), we return a new range with the same entities but defined on this mesh. If some entities can not be retrieved, we ignore them. NOTE: For now, we support only faces entity and only relation with same kind of entity (i.e mesh dim == range mesh dim)
template<typename... Ts>
auto	minelt (Ts &&... v)
	compute the min of the element of a function space at DOF points over the range r More...
template<typename... Ts>
auto	minmaxelt (Ts &&... v)
	compute the min of the element of a function space at DOF points over the range r More...
Feel::po::options_description	mixedpoisson_options (std::string const &prefix)
template<int Order, template< class, uint16_type, class > class Pts = PointSetEquiSpaced, typename MeshType , typename T = double>
std::shared_ptr< FunctionSpace< MeshType, bases< Lagrange< Order, Scalar, Continuous, Pts > >, T, Periodicity< NoPeriodicity >, mortars< Mortar > > >	Moch (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	build a function space of continuous function which are piecewise polynomial of degree (total or in each variable) less than k.
Feel::po::options_description	modelalgebraic_options (std::string const &prefix)
Feel::po::options_description	modelbase_options (std::string const &prefix)
Feel::po::options_description	modelnumerical_options (std::string const &prefix)
FEELPP_NO_EXPORT po::options_description	mpiOptions ()
Feel::po::options_description	multifluid_options (std::string const &prefix, uint16_type nls=3)
template<int Order, template< class, uint16_type, class > class Pts = PointSetEquiSpaced, typename MeshType , typename T = double, int Tag = 0>
NChv_ptrtype< MeshType, Order, Pts, T, Tag >	NChv (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Given a mesh, build a function space of vectorial continuous function which are piecewise polynomial of degree (total or in each variable) less than k using Lagrange basis functions.
template<int Order, typename MeshType , typename T = double>
meta::Ned1h< MeshType, Order, T >::ptrtype	Ned1h (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
template<int Order, typename MeshType , typename RangeType , typename T = double>
meta::Ned1h< MeshType, Order, T >::ptrtype	Ned1h (std::shared_ptr< MeshType > const &mesh, RangeType &&rangeElt, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
template<typename CollectionOfRangeT , std::enable_if_t< is_range_v< typename CollectionOfRangeT::value_type >, int > = 0>
size_type	nelements (CollectionOfRangeT const &its, bool global=false, bool ignoreGhosts=true)
	Compute the number of elements in a collection of ranges. More...
template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>
size_type	nelements (RangeT const &its, Zone const &z)
	Compute the number of elements in a range for a given zone. More...
template<typename RangeT , std::enable_if_t< is_filter_v< RangeT >, int > = 0>
size_type	nelements (RangeT const &r, bool global=false, bool ignoreGhosts=true)
	Compute the number of elements in a range. More...
template<typename MeshType , int Entities>
FEELPP_DEPRECATED size_type	nelements (std::list< Range< MeshType, Entities > > const &r, bool global, bool ignoreGhosts=true)
	[Deprecated] Compute the number of elements in a list of ranges. More...
template<typename ... Ts>
auto	newmark (Ts &&... v)
	NLOHMANN_JSON_SERIALIZE_ENUM (Location, { { Location::unknown, nullptr }, { Location::global, "global" }, { Location::relative, "relative" }, { Location::absolute, "absolute" }, { Location::git, "git" }, { Location::custom, "custom" } }) inline const std
	get the location strings assocation to enum Location More...
DofTableExtendedType	normalizeFunctionSpaceDofTable (DofTableExtendedType dte)
	Normalize an extended-DOF-table option for use in a manager key. More...
template<typename ... Ts>
double	normH1 (Ts &&... v)
template<typename ... Ts>
double	normL2 (Ts &&... v)
template<typename ... Ts>
double	normL2Squared (Ts &&... v)
template<typename ... Ts>
double	normSemiH1 (Ts &&... v)
template<typename MeshType >
std::shared_ptr< Pdh_element_t< MeshType, 0 > >	nsrQ (Pdh_ptrtype< MeshType, 0 > const &Xh, std::shared_ptr< MeshType > const &m)
	Return the normalized shape ratio (NSR) for a given element. More...
template<typename MeshType >
std::shared_ptr< Pdh_element_t< MeshType, 0 > >	nsrQ (std::shared_ptr< MeshType > const &m)
template<int Order, typename MeshType , typename T = double, int Tag = 0>
Odh_ptrtype< MeshType, Order, T, Tag >	Odh (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Given a mesh, build a function space of discontinuous function which are piecewise polynomial of degree and \(L_2\) Orthonormal.
template<typename... Ts>
auto	opelt (Ts &&... v)
	compute the min of the element of a function space at DOF points over the range r More...
bool	operator!= (const TypeInfo &lhs, const TypeInfo &rhs)
template<typename X , bool SM>
bool	operator!= (ProductSpace< X, SM > const &x, ProductSpace< X, SM > const &y)
template<typename T , typename... SList1, typename... SList2>
bool	operator!= (ProductSpaces2< T, SList1... > const &x, ProductSpaces2< T, SList2... > const &y)
template<typename... SList1, typename... SList2>
bool	operator!= (ProductSpaces< SList1... > const &x, ProductSpaces< SList2... > const &y)
template<typename FormT > requires std::derived_from<FormT, BilinearFormBase<typename FormT::value_type>>
FormT	operator* (double a, FormT const &b)
	left multiply a form by a scalar
template<typename SpaceType , typename VectorType , typename ElemContType >
Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType >	operator* (Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &a, typename SpaceType::value_type const &s)
	operator * with a scalar on the right More...
template<typename SpaceType , typename VectorType , typename ElemContType >
Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType >	operator* (typename SpaceType::value_type const &s, Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &a)
	operator * with a scalar on the left More...
template<typename SpaceType , typename VectorType , typename ElemContType >
Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType >	operator+ (Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &a, Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &b)
	operator + with two linear forms More...
template<typename SpaceType , typename VectorType , typename ElemContType >
Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType >	operator- (Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &a)
	unary minus operator More...
template<typename SpaceType , typename VectorType , typename ElemContType >
Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType >	operator- (Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &a, Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &b)
	operator - with two linear forms More...
template<typename SpaceType , typename VectorType , typename ElemContType >
Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType >	operator/ (Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &a, typename SpaceType::value_type const &s)
	operator / with a scalar More...
bool	operator< (const TypeInfo &lhs, const TypeInfo &rhs)
template<class T , class U >
bool	operator< (std::weak_ptr< T > const &a, std::weak_ptr< U > const &b)
template<typename T , int N1 = Eigen::Dynamic, int N2 = Eigen::Dynamic>
DebugStream &	operator<< (DebugStream &__os, Eigen::Matrix< T, N1, N2 > const &__n)
template<uint16_type Dim, typename T , typename IndexT >
FEELPP_DEPRECATED DebugStream &	operator<< (DebugStream &__os, Geo0D< Dim, T, IndexT > const &__n)
template<uint16_type Dim, typename GEOSHAPE , typename T , typename IndexT , typename POINTTYPE , bool UseMeasuresStorage>
FEELPP_DEPRECATED DebugStream &	operator<< (DebugStream &__os, GeoND< Dim, GEOSHAPE, T, IndexT, POINTTYPE, UseMeasuresStorage > const &__n)
template<typename T , int N1 = Eigen::Dynamic, int N2 = Eigen::Dynamic>
NdebugStream &	operator<< (NdebugStream &__os, Eigen::Matrix< T, N1, N2 > const &)
template<uint16_type Dim, typename T , typename IndexT >
FEELPP_DEPRECATED NdebugStream &	operator<< (NdebugStream &__os, Geo0D< Dim, T, IndexT > const &__n)
template<uint16_type Dim, typename GEOSHAPE , typename T , typename IndexT , typename POINTTYPE , bool UseMeasuresStorage>
NdebugStream &FEELPP_DEPRECATED	operator<< (NdebugStream &__os, GeoND< Dim, GEOSHAPE, T, IndexT, POINTTYPE, UseMeasuresStorage > const &__n)
template<typename SizeT = uint32_type>
std::ostream &	operator<< (std::ostream &__os, Dof< SizeT > const &__dof)
template<uint16_type Dim, typename T , typename IndexT >
std::ostream &	operator<< (std::ostream &__os, Geo0D< Dim, T, IndexT > const &__n)
template<uint16_type Dim, typename GEOSHAPE , typename T , typename IndexT , typename POINTTYPE , bool UseMeasuresStorage>
std::ostream &	operator<< (std::ostream &__os, GeoND< Dim, GEOSHAPE, T, IndexT, POINTTYPE, UseMeasuresStorage > const &__n)
template<int NC, typename SizeT = uint32_type>
std::ostream &	operator<< (std::ostream &__os, LocalDof< NC, SizeT > const &__dof)
std::ostream &	operator<< (std::ostream &o, Printer::OutputText const &cb)
std::ostream &	operator<< (std::ostream &o, Table const &c)
std::ostream &	operator<< (std::ostream &o, TableImpl::Cell const &c)
std::ostream &	operator<< (std::ostream &o, TabulateInformations const &ti)
	ostream operator
std::ostream &	operator<< (std::ostream &o, TabulateInformations::ExporterAscii const &ea)
std::ostream &	operator<< (std::ostream &o, TabulateInformations::ExporterAsciiDoc const &ead)
std::ostream &	operator<< (std::ostream &os, AboutData const &about)
	outpout stream an AboutData structure More...
template<typename MeshType , int MESH_ENTITIES, typename = std::enable_if_t<std::is_base_of_v<MeshBase<>, decay_type<std::remove_pointer_t<MeshType>>>, int>>
std::ostream &	operator<< (std::ostream &os, const Range< MeshType, MESH_ENTITIES > &range)
template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >
std::ostream &	operator<< (std::ostream &os, FunctionSpace< A0, A1, A2, A3, A4 > const &Xh)
	iostream operator to print some information about the function space Xh More...
std::ostream &	operator<< (std::ostream &os, interpolation_operand_type const &o)
template<typename Geo , uint16_type Dim, uint16_type Order, uint16_type RDim, typename T >
std::ostream &	operator<< (std::ostream &os, Reference< Geo, Dim, Order, RDim, T > const &ref)
bool	operator<= (const TypeInfo &lhs, const TypeInfo &rhs)
bool	operator== (const TypeInfo &lhs, const TypeInfo &rhs)
template<typename X , bool SM>
bool	operator== (ProductSpace< X, SM > const &x, ProductSpace< X, SM > const &y)
template<typename T , typename... SList1, typename... SList2>
bool	operator== (ProductSpaces2< T, SList1... > const &x, ProductSpaces2< T, SList2... > const &y)
template<typename... SList1, typename... SList2>
bool	operator== (ProductSpaces< SList1... > const &x, ProductSpaces< SList2... > const &y)
bool	operator> (const TypeInfo &lhs, const TypeInfo &rhs)
bool	operator>= (const TypeInfo &lhs, const TypeInfo &rhs)
template<typename space_type >
std::shared_ptr< OperatorSteklovPc< space_type > >	operatorSteklPc (std::shared_ptr< space_type > const &space, typename OperatorSteklovPc< space_type >::backend_ptrtype const &backend=Backend< double >::build(BACKEND_PETSC))
	this function returns a OperatorSteklovPc shared_ptr with More...
template<typename self_type >
std::shared_ptr< OperatorTrace< self_type > >	operatorTrace (std::shared_ptr< self_type > const &domainspace)
	this function returns a OperatorTrace shared_ptr with More...
template<typename ... Ts>
auto	opInterpolation (Ts &&... v)
template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange , typename InterpType >
decltype(auto)	opInterpPtr (std::shared_ptr< DomainSpaceType > const &domainspace, std::shared_ptr< ImageSpaceType > const &imagespace, IteratorRange const &r, typename OperatorInterpolation< DomainSpaceType, ImageSpaceType, typename Feel::detail::opinterprangetype< IteratorRange >::type, InterpType >::backend_ptrtype const &backend, InterpType const &interptype, bool ddmethod, OperatorInterpolationMatrixSetup< typename DomainSpaceType::value_type > const &matSetup=OperatorInterpolationMatrixSetup< typename DomainSpaceType::value_type >{})
template<typename space_type >
std::shared_ptr< OperatorLagrangeP1< space_type > >	opLagrangeP1_impl (std::shared_ptr< space_type > const &Xh, typename OperatorLagrangeP1< space_type >::backend_ptrtype const &backend, std::string pathMeshLagP1, std::string prefix, bool rebuild, bool parallel, size_type meshUpdate)
template<typename ... Ts>
auto	opLift (Ts &&... v)
template<typename ... Ts>
auto	opLinear (Ts &&... v)
template<typename ... Ts>
auto	opLinearComposite (Ts &&... v)
template<typename ... Ts>
auto	opLinearFree (Ts &&... v)
template<typename ... Ts>
auto	opProjection (Ts &&... v)
template<typename... Ts>
auto	opselt (Ts &&... v)
	compute the set of operations ops of the element of a function space at DOF points over the range r More...
template<typename ... Ts>
po::variable_value	option (Ts &&... v)
template<typename T >
T	optionT (std::string const &name)
template<typename T , typename ... Ts, typename = typename std::enable_if_t< sizeof...(Ts) != 0 && ( NA::is_named_argument_v<Ts> && ...) >>
T	optionT (Ts &&... v)
po::options_description	oseen_options (std::string const &prefix, OseenDefaults defaults)
template<typename Base1 , typename Base2 , typename MeshType >
P2ch_ptrtype< Base1, Base2, MeshType >	P2ch (std::shared_ptr< MeshType > mesh, std::vector< DofTableExtendedType > dte=std::vector< DofTableExtendedType >(2, DofTableExtendedType::DEFAULT))
	Given a mesh and polynomial order \(k\)(template argument), build a product function space of \([P_{k}]^d \times P_{l}]\) where $d$ is the dimension of the associated mesh. More...
nl::json	parseCustomFormat (const std::string &customInput)
template<typename MeshType >
std::unique_ptr< MeshPartitionSet< MeshType > >	partitionMesh (std::shared_ptr< MeshType > mesh, rank_type nGlobalParts, std::vector< Range< MeshType, MESH_ELEMENTS > > partitionByRange=std::vector< Range< MeshType, MESH_ELEMENTS > >(), json const &partconfig=json())
	partition a mesh and provide a helper data struct navigate in the newly partitioned mesh More...
template<typename RangeType , std::enable_if_t< is_range_v< RangeType >, int > = 0>
std::vector< decay_type< RangeType > >	partitionRange (RangeType &&range, int nParts)
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>
Pch_ptrtype< MeshType, Order, T, Pts, Tag >	Pch (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Build a whole-mesh continuous scalar Lagrange function space. More...
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , typename RangeType , int Tag = 0>
Pch_ptrtype< MeshType, Order, T, Pts, Tag >	Pch (std::shared_ptr< MeshType > const &mesh, RangeType &&rangeElt, DofTableExtendedType dte=DofTableExtendedType::DEFAULT, size_type components=0)
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pch (Ts &&... v)
	Build a whole-mesh continuous scalar Lagrange space using named arguments. More...
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>
Pchm_ptrtype< MeshType, Order, T, Pts, Tag >	Pchm (std::shared_ptr< MeshType > mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pchm (Ts &&... v)
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>
Pchms_ptrtype< MeshType, Order, T, Pts, Tag >	Pchms (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	build a function space of continuous symmetric matrix fields which are piecewise polynomial of degree (total or in each variable) less than k.
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pchms (Ts &&... v)
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , typename T = double, int Tag = 0>
Pchv_ptrtype< MeshType, Order, Pts, T, Tag >	Pchv (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Build a whole-mesh continuous vector Lagrange function space. More...
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , typename RangeType , typename T = double, int Tag = 0>
Pchv_ptrtype< MeshType, Order, Pts, T, Tag >	Pchv (std::shared_ptr< MeshType > const &mesh, RangeType &&rangeElt, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Given a mesh, build a function space of vectorial continuous function which are piecewise polynomial of degree (total or in each variable) less than k using Lagrange basis functions.
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename T = double, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pchv (Ts &&... v)
	Build a whole-mesh continuous vector Lagrange space using named arguments. More...
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType >
Pdh_ptrtype< MeshType, Order, Pts >	Pdh (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Build a whole-mesh discontinuous scalar Lagrange function space. More...
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , typename RangeType >
Pdh_ptrtype< MeshType, Order, Pts >	Pdh (std::shared_ptr< MeshType > const &mesh, RangeType &&rangeElt, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Given a mesh, build a function space of discontinuous function which are piecewise polynomial of degree (total or in each variable) less than k.
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pdh (Ts &&... v)
	Build a whole-mesh discontinuous scalar Lagrange space using named arguments. More...
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>
Pdhm_ptrtype< MeshType, Order, T, Pts, Tag >	Pdhm (std::shared_ptr< MeshType > mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pdhm (Ts &&... v)
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>
Pdhms_ptrtype< MeshType, Order, T, Pts, Tag >	Pdhms (std::shared_ptr< MeshType > const &mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	build a function space of discontinuous symmetric matrix fields which are piecewise polynomial of degree (total or in each variable) less than k.
template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pdhms (Ts &&... v)
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , typename RangeType , int Tag = 0>
Pdhv_ptrtype< MeshType, Order, Pts, Tag >	Pdhv (std::shared_ptr< MeshType > const &mesh, RangeType &&rangeElt, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Given a mesh, build a function space of vectorial discontinuous function which are piecewise polynomial of degree (total or in each variable) less than k using Lagrange basis functions.
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>
Pdhv_ptrtype< MeshType, Order, Pts, Tag >	Pdhv (std::shared_ptr< MeshType > mesh, DofTableExtendedType dte=DofTableExtendedType::DEFAULT)
	Build a whole-mesh discontinuous vector Lagrange function space. More...
template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts> requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )
auto	Pdhv (Ts &&... v)
	Build a whole-mesh discontinuous vector Lagrange space using named arguments. More...
template<typename A0 >
Periodicity< A0 >	periodicity (A0 const &a0)
template<typename A0 , typename A1 >
Periodicity< A0, A1 >	periodicity (A0 const &a0, A1 const &a1)
template<typename A0 , typename A1 , typename A2 >
Periodicity< A0, A1, A2 >	periodicity (A0 const &a0, A1 const &a1, A2 const &a2)
template<typename MeshType >
auto	points (MeshType const &mesh, entity_process_t ept=entity_process_t::LOCAL_ONLY)
std::string	prefixvm (std::string const &prefix, std::string const &opt, std::string const &sep=".")
	Function that compute the command line option prefix for the option variable map. More...
std::string	preprocessCustomFormat (const std::string &input)
template<typename MeshT >
void	print (MeshT *m)
template<typename E >
void	print_and_trace (std::string const &s, E const &e)
template<typename StatsIterator >
void	printData (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
template<typename StatsIterator >
void	printErrors (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
void	printGitReport ()
template<typename StatsIterator >
void	printNumbers (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
template<typename StatsIterator >
void	printTime (std::ostream &out, StatsIterator statsit, StatsIterator statsen, std::string const &key, size_type stats=Application::ALL|Application::HEADER)
template<typename MeshType , typename OtherMeshType >
void	printTypeInformation ()
template<typename ElementType >
ElementType	prod (ElementType const &v1, ElementType const &v2, typename boost::enable_if< boost::is_base_of< FunctionSpaceBase::ElementBase, ElementType > >::type *dummy=0)
	Computes the element wise product of two vectors and eventually in parallel. More...
template<typename... SpaceList>
ProductSpaces< SpaceList... >	product (SpaceList... spaces)
	compile time product of function spaces More...
template<typename T , typename... SpaceList>
ProductSpaces2< T, SpaceList... >	product2 (SpaceList... spaces, std::shared_ptr< ProductSpace< T, true > > const &ps)
	mixed compile time and runtime product of function space More...
template<typename T , typename... SpaceList>
ProductSpaces2< T, SpaceList... >	product2 (std::shared_ptr< ProductSpace< T, true > > const &ps, SpaceList... spaces)
	mixed compile time and runtime product of function space More...
template<typename... SpaceList>
std::unique_ptr< ProductSpaces< SpaceList... > >	productPtr (SpaceList... spaces)
template<typename TDomainSpace , typename TDualImageSpace >
std::shared_ptr< Projector< TDomainSpace, TDualImageSpace > >	projector (std::shared_ptr< TDomainSpace > const &domainspace, std::shared_ptr< TDualImageSpace > const &imagespace, typename Projector< TDomainSpace, TDualImageSpace >::backend_ptrtype const &abackend=Backend< double >::build(soption(_name="backend")), ProjectorType proj_type=L2, double epsilon=0.01, double gamma=20, DirichletType dirichlet_type=WEAK)
	this function returns a Projector shared_ptr with More...
template<typename MeshTestType , typename IteratorRange , typename Im , typename Expr >
std::shared_ptr< QuadPtLocalization< typename Feel::detail::quadptlocrangetype< IteratorRange >::type, Im, Expr > >	quadPtLocPtr (std::shared_ptr< MeshTestType > meshTest, IteratorRange const &elts, Im const &im, Expr const &expr)
template<typename MeshTestType , typename MeshTrialType , typename IteratorRange , typename Im , typename Expr >
std::shared_ptr< QuadPtLocalization< typename Feel::detail::quadptlocrangetype< IteratorRange >::type, Im, Expr > >	quadPtLocPtr (std::shared_ptr< MeshTestType > meshTest, std::shared_ptr< MeshTrialType > meshTrial, IteratorRange const &elts, Im const &im, Expr const &expr)
template<typename T >
std::vector< T >	range (T &&beg, T &&end)
	return a range of integers between beg and end with a step of 1 More...
template<typename T >
std::vector< T >	range (T &&beg, T &&end, T &&step)
	Provides range of integers. More...
template<typename T >
std::vector< T >	range (T &&end)
	return a range of integers between 0 and end with a step of 1 More...
template<typename... Tv>
auto	range (Tv &&... v)
template<typename C >
auto	rank (C const &c)
template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>
rank_type	rank (RangeT const &range)
	get the rank of a range of entities More...
static size_t	read_data (char *ptr, size_t size, size_t nmemb, void *stream)
std::string	readFromFile (std::string const &filename)
	helper function that read a file filename and store its contents into a std::string
template<typename T >
constexpr int	real_dimension (T const &t)
Feel::po::options_description	redistanciation_fm_options (std::string const &prefix, bool addProjectorsOpts)
Feel::po::options_description	redistanciation_hj_options (std::string const &prefix)
template<typename SpaceType , typename Expr >
SpaceType::element_type	region (std::shared_ptr< SpaceType > const &space, Expr const &expr)
template<typename SpaceType >
SpaceType::element_type	regionMarker (std::shared_ptr< SpaceType > const &space)
template<typename SpaceType >
SpaceType::element_type	regionMarker2 (std::shared_ptr< SpaceType > const &space)
template<typename SpaceType >
SpaceType::element_type	regionMarker3 (std::shared_ptr< SpaceType > const &space)
template<typename SpaceType >
SpaceType::element_type	regionProcess (std::shared_ptr< SpaceType > const &space)
template<typename SpaceType , typename Expr >
SpaceType::element_type	regionv (std::shared_ptr< SpaceType > const &space, Expr const &expr)
template<typename... Ts>
auto	remesh (Ts &&... v)
	remesh with named arguments More...
Feel::po::options_description	remesh_options (std::string const &prefix)
	build command line options for remesh More...
template<typename MeshT >
std::tuple< std::shared_ptr< MeshT >, int >	remeshImpl (std::shared_ptr< MeshT > const &r, std::string const &metric_expr, std::vector< std::string > const &req_elts, std::vector< std::string > const &req_facets, std::shared_ptr< MeshT > const &parent, nl::json const &params)
	given a metric and required elements/facets, remesh a mesh More...
template<typename T >
decltype(auto)	remove_shared_ptr_f (T &&e)
FEELPP_EXPORT std::string	removeComments (std::string str_with_comments)
	remove c and c++ comments from string str_with_comments if any
StatusRequestHTTP	requestDownloadURL (const std::string &url, std::ostream &ofile, int timeout=5000, int max_retries=3, int backoff_delay=1000)
StatusRequestHTTP	requestHTTPCUSTOM (const std::string &customRequest, const std::string &url, const std::vector< std::string > &headers, std::ostream &ofile, int timeout=5000, int max_retries=3, int backoff_delay=1000)
StatusRequestHTTP	requestHTTPGET (const std::string &url, const std::vector< std::string > &headers, std::ostream &ofile, int timeout=5000, int max_retries=3, int backoff_delay=1000)
StatusRequestHTTP	requestHTTPGETWithProgress (const std::string &url, const std::vector< std::string > &headers, std::ostream &ofile, const std::string &filename, const ProgressCallback &progressCallback, int timeout=5000, int max_retries=3, int backoff_delay=1000)
StatusRequestHTTP	requestHTTPPOST (const std::string &url, const std::vector< std::string > &headers, std::istream &ifile, int fsize, std::ostream &ofile, int timeout=5000, int max_retries=3, int backoff_delay=1000)
StatusRequestHTTP	requestHTTPPOST (const std::string &url, const std::vector< std::string > &headers, std::ostream &ofile, int timeout=5000, int max_retries=3, int backoff_delay=1000)
std::string	sanitize (std::string const &s)
	trim string to remove special characters More...
std::vector< std::string >	sanitize (std::vector< std::string > const &s)
	trim a vector of strings removing all leading and trailing spaces and replace all special characters " ;:," inside the block by a _ More...
fs::path	scratchdir ()
template<typename MeshType , typename = std::enable_if_t<std::is_base_of_v<std::enable_shared_from_this<MeshType>,MeshType>>>
std::shared_ptr< MeshType const >	shared_from_this (MeshType const &m)
template<typename MeshType , typename = std::enable_if_t<!std::is_base_of_v<std::enable_shared_from_this<MeshType>,MeshType>>>
MeshType const *	shared_from_this (MeshType const &m)
template<typename MeshType >
std::shared_ptr< MeshType >	shared_from_this (std::shared_ptr< MeshType > const &m)
Feel::po::options_description	solidMechanics_options (std::string const &prefix)
template<typename ... Ts>
std::string	soption (Ts &&... v)
FEELPP_NO_EXPORT bool	splitTest (const RegionTree::pbox_container_type &b, const node_type &bmin, const node_type &bmax, size_type dir, scalar_type &split_v)
template<typename ... Ts>
auto	stencil (Ts &&... v)
void	stencilManagerAdd (StencilManagerImpl::key_type const &key, StencilManagerImpl::graph_ptrtype graph)
	function that add an entry in the StencilManager
void	stencilManagerGarbage (StencilManagerImpl::key_type const &key)
	function that cleans up one entry the StencilManager
void	stencilManagerGarbageCollect ()
	function that cleans up the StencilManager any time stencil() is called
void	stencilManagerPrint ()
	print entries stored in stencil manager
template<int I, int J, typename IteratorRange >
fusion::pair< fusion::pair< mpl::int_< I >, mpl::int_< J > >, typename stencilrangetype< IteratorRange >::list_type >	stencilRange (IteratorRange const &r)
StencilRangeMap0Type	stencilRangeMap ()
template<typename ThePair1Type >
StencilRangeMap1Type< ThePair1Type >	stencilRangeMap (ThePair1Type const &p)
template<typename ThePair1Type , typename ThePair2Type >
StencilRangeMap2Type< ThePair1Type, ThePair2Type >	stencilRangeMap (ThePair1Type const &p1, ThePair2Type const &p2)
template<typename EltType >
fusion::result_of::accumulate< typenameEltType::functionspace_type::functionspace_vector_type, fusion::vector<>, Feel::detail::CreateElementVector< EltType > >::type	subelements (EltType const &e, std::vector< std::string > const &n)
	extract subelements from an element of a product of spaces More...
template<typename FE1 , class BinaryOperation , typename VectorType = typename Backend<typename functionspace_type<FE1>::value_type>::vector_type, typename ElemContType = VectorType>
Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType >	sum (std::vector< Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType > > const &v, BinaryOperation op, Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType > init=Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType >())
	sum of linear forms More...
template<typename SpaceT > requires is_functionspace_v<SpaceT>
constexpr SpaceT::template GetMeshSupport< typenameSpaceT::mesh_ptrtype, 0 >::ptrtype	support (std::shared_ptr< SpaceT > const &X)
template<int Dim>
std::vector< symbol >	symbols ()
std::vector< symbol >	symbols (std::initializer_list< std::string > l)
std::vector< symbol >	symbols (std::vector< std::string > const &symbNames, std::vector< GiNaC::symbol > const &symbExisting)
std::vector< symbol >	symbols (std::vector< std::string > l)
template<>
std::vector< symbol >	symbols< 1 > ()
template<>
std::vector< symbol >	symbols< 2 > ()
template<>
std::vector< symbol >	symbols< 3 > ()
template<SymmetricTensorFormatLike FormatT>
constexpr uint16_type	symmetricTensorComponentCount (uint16_type n, FormatT const &format)
	Number of output components for a dimension/format pair. More...
constexpr uint16_type	symmetricTensorComponentCount (uint16_type n, SymmetricTensorOrder order)
	Number of output components for a dimension/order pair. More...
template<SymmetricTensorFormatLike FormatT>
constexpr char const *	symmetricTensorComponentLabel (uint16_type outputSlot, uint16_type n, FormatT const &format)
	Component label for an output slot in a format object. More...
constexpr char const *	symmetricTensorComponentLabel (uint16_type outputSlot, uint16_type n, SymmetricTensorOrder order)
	Component label for an output slot. More...
template<typename T = double>
constexpr T	symmetricTensorComponentScale (uint16_type i, uint16_type j, uint16_type n, SymmetricTensorScaling scaling)
	Scaling factor for a tensor component. More...
constexpr uint16_type	symmetricTensorInvalidSlot ()
	Sentinel value for unused entries in fixed-size mapping arrays. More...
constexpr bool	symmetricTensorIsShearComponent (uint16_type i, uint16_type j, uint16_type n)
	Check whether a tensor component is off-diagonal. More...
constexpr bool	symmetricTensorIsShearStorageSlot (uint16_type storageSlot, uint16_type n)
	Check whether a compact storage slot represents an off-diagonal component. More...
constexpr bool	symmetricTensorIsTensor6Order (SymmetricTensorOrder order)
	Check whether an order describes a six-component exporter tuple. More...
constexpr char const *	symmetricTensorOrderName (SymmetricTensorOrder order)
	Stable metadata name for a symmetric tensor output order. More...
template<SymmetricTensorFormatLike FormatT>
constexpr uint16_type	symmetricTensorOutputSlot (uint16_type i, uint16_type j, uint16_type n, FormatT const &format)
	Map a symmetric tensor component to an output slot for a format object. More...
constexpr uint16_type	symmetricTensorOutputSlot (uint16_type i, uint16_type j, uint16_type n, SymmetricTensorOrder order)
	Map a symmetric tensor component to an output slot. More...
template<SymmetricTensorFormatLike FormatT>
constexpr uint16_type	symmetricTensorOutputSlotFromStorage (uint16_type storageSlot, uint16_type n, FormatT const &format)
	Map a compact storage slot to an output slot for a format object. More...
constexpr uint16_type	symmetricTensorOutputSlotFromStorage (uint16_type storageSlot, uint16_type n, SymmetricTensorOrder order)
	Map a compact storage slot to an output slot. More...
template<typename T = double>
constexpr T	symmetricTensorScale (bool isShear, SymmetricTensorScaling scaling)
	Scaling factor for a diagonal or off-diagonal component. More...
constexpr char const *	symmetricTensorScalingName (SymmetricTensorScaling scaling)
	Stable metadata name for a symmetric tensor scaling convention. More...
constexpr std::array< uint16_type, 2 >	symmetricTensorStorageComponent (uint16_type storageSlot, uint16_type n)
	Component indices represented by a compact packed-storage slot. More...
constexpr uint16_type	symmetricTensorStorageComponentCount (uint16_type n)
	Number of compact packed-storage components for a symmetric tensor. More...
constexpr uint16_type	symmetricTensorStorageIndex (uint16_type i, uint16_type j, uint16_type n)
	Legacy compact packed-storage slot for a symmetric tensor component. More...
template<typename T = double>
constexpr T	symmetricTensorStorageScale (uint16_type storageSlot, uint16_type n, SymmetricTensorScaling scaling)
	Scaling factor for a compact storage slot. More...
constexpr std::array< uint16_type, 6 >	symmetricTensorStorageToOutputMap (uint16_type n, SymmetricTensorOrder order)
	Fixed-size compact-storage-to-output-slot map. More...
constexpr bool	symmetricTensorSupportedDimension (uint16_type n)
	Check whether a tensor dimension is supported by these helpers. More...
template<typename ElementType , typename RangeType , typename FunctionType >
void	syncDofs (ElementType &phi, RangeType const &range, FunctionType const &func)
template<typename VectorType , typename DofTableType , typename RangeType , typename FunctionType >
void	syncDofs (VectorType &phi, DofTableType const &dofTable, RangeType const &range, FunctionType const &func)
template<typename SpaceType >
Test< SpaceType >	test (std::shared_ptr< SpaceType > const &X)
template<int Order, typename MeshType >
THch_ptrtype< Order, MeshType >	THch (std::shared_ptr< MeshType > mesh, std::vector< DofTableExtendedType > dte=std::vector< DofTableExtendedType >(2, DofTableExtendedType::DEFAULT))
	Given a mesh and polynomial order \(k\)(template argument), build a product function space of \([P_{k+1}]^d \times P_{k}]\) where $d$ is the dimension of the associated mesh. More...
Feel::po::options_description	thermoElectric_options (std::string const &prefix)
template<class E >
void	throw_with_trace (const E &e)
	helper class for throwing any exception with stacktrace: More...
static const std::string	timerDefaultInstanceName ()
Feel::po::options_description	toolboxes_options (std::string const &type)
Feel::po::options_description	toolboxes_options (std::string const &type, std::string const &prefix)
template<typename RefEntity >
void	toPython (RefEntity const &e, std::string str="simplex")
template<typename SpaceType >
Trial< SpaceType >	trial (std::shared_ptr< SpaceType > const &X)
template<typename T >
constexpr hana::integral_constant< int,(decay_type< T >::nSpaces==1)?1:2 >	type_space_t (T &&t)
template<typename T1 , typename T2 >
constexpr hana::integral_constant< int,(decay_type< T1 >::nSpaces==1 &&decay_type< T2 >::nSpaces==1)?1:2 >	type_spaces_t (T1 &&t1, T2 &&t2)
Repository::Config	unknownRepository ()
template<typename C >
unwrap_ptr_t< C > &	unwrap_ptr (C &c)
template<typename C >
unwrap_ptr_t< C > &	unwrap_ptr (C *c)
template<typename C >
unwrap_ptr_t< C > const &	unwrap_ptr (C const &c)
std::vector< ptree::ptree > &	updateStats (std::vector< ptree::ptree > &stats)
template<typename ... Ts>
std::vector< double >	vdoption (Ts &&... v)
template<typename ... Ts>
std::vector< std::string >	vsoption (Ts &&... v)
DebugStream	Warning (bool cond, int area)
DebugStream	Warning (int area)
template<typename T >
worldcomm_ptr_t	wc (T &&t)
worldcomm_t const &	worldComm (CommObject const &commObj)
template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>
WorldComm const &	worldComm (RangeT const &range)
worldcomm_ptr_t const &	worldCommPtr (CommObject const &commObj)
FEELPP_DEPRECATED worldscomm_ptr_t	worldsComm (worldcomm_ptr_t const &wc)
static size_t	write_data (char *ptr, size_t size, size_t nmemb, void *stream)
template<typename ItT1 , typename ItT2 >
static auto	zip (ItT1 &&itBegin, ItT2 &&itEnd)
template<typename F , typename ItT1 , typename ItT2 >
static auto	zip_with (F &&f, ItT1 &&itBegin, ItT2 &&itEnd)

Variables
constexpr auto &	_about = NA::identifier<na::about>
constexpr auto &	_accumulate = NA::identifier<na::accumulate>
constexpr auto &	_addmidpoint = NA::identifier<na::addmidpoint>
constexpr auto &	_alpha = NA::identifier<na::alpha>
constexpr auto &	_arg = NA::identifier<na::arg>
constexpr auto &	_argc = NA::identifier<na::argc>
constexpr auto &	_argv = NA::identifier<na::argv>
constexpr auto &	_atolerance = NA::identifier<na::atolerance>
constexpr auto &	_author = NA::identifier<na::author>
constexpr auto &	_auxiliary_matrices = NA::identifier<na::auxiliary_matrices>
constexpr auto &	_backend = NA::identifier<na::backend>
constexpr auto &	_bc = NA::identifier<na::bc>
constexpr auto &	_beta = NA::identifier<na::beta>
constexpr auto &	_block = NA::identifier<na::block>
constexpr auto &	_bugs = NA::identifier<na::bugs>
constexpr auto &	_buildGraphWithTranspose = NA::identifier<na::buildGraphWithTranspose>
constexpr auto &	_byparts = NA::identifier<na::byparts>
constexpr auto &	_chdir = NA::identifier<na::chdir>
constexpr auto &	_close = NA::identifier<na::close>
constexpr auto &	_cmdName = NA::identifier<na::cmdName>
constexpr auto &	_collapseOnBoundary = NA::identifier<na::collapseOnBoundary>
constexpr auto &	_collapseOnBoundaryTolerance = NA::identifier<na::collapseOnBoundaryTolerance>
constexpr auto &	_collect_garbage = NA::identifier<na::collect_garbage>
constexpr auto &	_colstart = NA::identifier<na::colstart>
constexpr auto &	_components = NA::identifier<na::components>
constexpr auto &	_compute_pde_coefficients = NA::identifier<na::compute_pde_coefficients>
constexpr auto &	_condense = NA::identifier<na::condense>
constexpr auto &	_condenser = NA::identifier<na::condenser>
constexpr auto &	_config = NA::identifier<na::config>
constexpr auto &	_constant_null_space = NA::identifier<na::constant_null_space>
constexpr auto &	_context = NA::identifier<na::context>
constexpr auto &	_context2 = NA::identifier<na::context2>
constexpr auto &	_context_at_compile_time = NA::identifier<na::context_at_compile_time>
constexpr auto &	_convex = NA::identifier<na::convex>
constexpr auto &	_copy_values = NA::identifier<na::copy_values>
constexpr auto &	_copyright = NA::identifier<na::copyright>
constexpr auto &	_curl_expr = NA::identifier<na::curl_expr>
constexpr auto &	_currentElt = NA::identifier<na::currentElt>
constexpr auto &	_data = NA::identifier<na::data>
constexpr auto &	_ddmethod = NA::identifier<na::ddmethod>
constexpr auto &	_dependencies = NA::identifier<na::dependencies>
constexpr auto &	_depends = NA::identifier<na::depends>
constexpr auto &	_desc = NA::identifier<na::desc>
constexpr auto &	_desc_lib = NA::identifier<na::desc_lib>
constexpr auto &	_diag_is_nonzero = NA::identifier<na::diag_is_nonzero>
constexpr auto &	_dim = NA::identifier<na::dim>
constexpr auto &	_directory = NA::identifier<na::directory>
constexpr auto &	_dirichlet_inplace = NA::identifier<na::dirichlet_inplace>
constexpr auto &	_div_expr = NA::identifier<na::div_expr>
constexpr auto &	_do_threshold = NA::identifier<na::do_threshold>
constexpr auto &	_domain = NA::identifier<na::domain>
constexpr auto &	_domainSpace = NA::identifier<na::domainSpace>
constexpr auto &	_dtolerance = NA::identifier<na::dtolerance>
constexpr auto &	_element = NA::identifier<na::element>
constexpr auto &	_element2 = NA::identifier<na::element2>
constexpr auto &	_email = NA::identifier<na::email>
constexpr auto &	_expr = NA::identifier<na::expr>
constexpr auto &	_extended_doftable = NA::identifier<na::extended_doftable>
constexpr auto &	_filename = NA::identifier<na::filename>
constexpr auto &	_files_path = NA::identifier<na::files_path>
constexpr auto &	_fileset = NA::identifier<na::fileset>
constexpr auto &	_final_time = NA::identifier<na::final_time>
constexpr auto &	_force_rebuild = NA::identifier<na::force_rebuild>
constexpr auto &	_forceRelaxation = NA::identifier<na::forceRelaxation>
constexpr auto &	_formA = NA::identifier<na::formA>
constexpr auto &	_format = NA::identifier<na::format>
constexpr auto &	_formB = NA::identifier<na::formB>
constexpr auto &	_freq = NA::identifier<na::freq>
constexpr auto &	_fspace_reuse_policy = NA::identifier<na::fspace_reuse_policy>
	Function-space factory keyword associated with na::fspace_reuse_policy.
constexpr auto &	_funcs = NA::identifier<na::funcs>
constexpr auto &	_gamma = NA::identifier<na::gamma>
constexpr auto &	_geo = NA::identifier<na::geo>
constexpr auto &	_geo_parameters = NA::identifier<na::geo_parameters>
constexpr auto &	_geoentity = NA::identifier<na::geoentity>
constexpr auto &	_geomap = NA::identifier<na::geomap>
constexpr auto &	_geotracking = NA::identifier<na::geotracking>
constexpr auto &	_grad_expr = NA::identifier<na::grad_expr>
constexpr auto &	_gradient = NA::identifier<na::gradient>
constexpr auto &	_gradient_key = NA::identifier<na::gradient_key>
constexpr auto &	_grainsize = NA::identifier<na::grainsize>
constexpr auto &	_h = NA::identifier<na::h>
constexpr auto &	_hmax = NA::identifier<na::hmax>
constexpr auto &	_hmin = NA::identifier<na::hmin>
constexpr auto &	_home = NA::identifier<na::home>
constexpr auto &	_image = NA::identifier<na::image>
constexpr auto &	_imageSpace = NA::identifier<na::imageSpace>
constexpr auto &	_in_memory = NA::identifier<na::in_memory>
constexpr auto &	_init = NA::identifier<na::init>
constexpr auto &	_initial_theta = NA::identifier<na::initial_theta>
constexpr auto &	_initial_time = NA::identifier<na::initial_time>
constexpr auto &	_inputs = NA::identifier<na::inputs>
constexpr auto &	_interval_a = NA::identifier<na::interval_a>
constexpr auto &	_interval_b = NA::identifier<na::interval_b>
constexpr auto &	_jacobian = NA::identifier<na::jacobian>
constexpr auto &	_keep_relation = NA::identifier<na::keep_relation>
constexpr auto &	_keyword = NA::identifier<na::keyword>
constexpr auto &	_kind = NA::identifier<na::kind>
constexpr auto &	_ksp = NA::identifier<na::ksp>
constexpr auto &	_label = NA::identifier<na::label>
constexpr auto &	_latex = NA::identifier<na::latex>
constexpr auto &	_license = NA::identifier<na::license>
constexpr auto &	_local = NA::identifier<na::local>
constexpr auto &	_location = NA::identifier<na::location>
constexpr auto &	_logging = NA::identifier<na::logging>
constexpr auto &	_marker1 = NA::identifier<na::marker1>
constexpr auto &	_marker10 = NA::identifier<na::marker10>
constexpr auto &	_marker11 = NA::identifier<na::marker11>
constexpr auto &	_marker12 = NA::identifier<na::marker12>
constexpr auto &	_marker2 = NA::identifier<na::marker2>
constexpr auto &	_marker3 = NA::identifier<na::marker3>
constexpr auto &	_marker4 = NA::identifier<na::marker4>
constexpr auto &	_marker5 = NA::identifier<na::marker5>
constexpr auto &	_marker6 = NA::identifier<na::marker6>
constexpr auto &	_marker7 = NA::identifier<na::marker7>
constexpr auto &	_marker8 = NA::identifier<na::marker8>
constexpr auto &	_marker9 = NA::identifier<na::marker9>
constexpr auto &	_marker_type = NA::identifier<na::marker_type>
constexpr auto &	_markerAll = NA::identifier<na::markerAll>
constexpr auto &	_markerName = NA::identifier<na::markerName>
constexpr auto &	_matrix = NA::identifier<na::matrix>
constexpr auto &	_matrixA = NA::identifier<na::matrixA>
constexpr auto &	_matrixB = NA::identifier<na::matrixB>
constexpr auto &	_max = NA::identifier<na::max>
constexpr auto &	_max_points_used = NA::identifier<na::max_points_used>
constexpr auto &	_maxit = NA::identifier<na::maxit>
constexpr auto &	_mesh = NA::identifier<na::mesh>
constexpr auto &	_metric = NA::identifier<na::metric>
constexpr auto &	_min = NA::identifier<na::min>
constexpr auto &	_min_theta = NA::identifier<na::min_theta>
constexpr auto &	_model = NA::identifier<na::model>
constexpr auto &	_mpd = NA::identifier<na::mpd>
constexpr auto &	_mpi_communications = NA::identifier<na::mpi_communications>
constexpr auto &	_mu = NA::identifier<na::mu>
constexpr auto &	_n_consecutive_save = NA::identifier<na::n_consecutive_save>
constexpr auto &	_name = NA::identifier<na::name>
constexpr auto &	_ncv = NA::identifier<na::ncv>
constexpr auto &	_near_null_space = NA::identifier<na::near_null_space>
constexpr auto &	_nev = NA::identifier<na::nev>
constexpr auto &	_newElt = NA::identifier<na::newElt>
constexpr auto &	_null_space = NA::identifier<na::null_space>
constexpr auto &	_nx = NA::identifier<na::nx>
constexpr auto &	_ny = NA::identifier<na::ny>
constexpr auto &	_nz = NA::identifier<na::nz>
constexpr auto &	_only_on_boundary_faces = NA::identifier<na::only_on_boundary_faces>
constexpr auto &	_op = NA::identifier<na::op>
constexpr auto &	_opt = NA::identifier<na::opt>
constexpr auto &	_optimize3d_netgen = NA::identifier<na::optimize3d_netgen>
constexpr auto &	_options = NA::identifier<na::options>
constexpr auto &	_order = NA::identifier<na::order>
constexpr auto &	_order_p = NA::identifier<na::order_p>
constexpr auto &	_order_u = NA::identifier<na::order_u>
constexpr auto &	_parallel = NA::identifier<na::parallel>
constexpr auto &	_parameter = NA::identifier<na::parameter>
constexpr auto &	_parameter_values = NA::identifier<na::parameter_values>
constexpr auto &	_parametricnodes = NA::identifier<na::parametricnodes>
constexpr auto &	_params = NA::identifier<na::params>
constexpr auto &	_parent = NA::identifier<na::parent>
constexpr auto &	_partition_file = NA::identifier<na::partition_file>
constexpr auto &	_partitioner = NA::identifier<na::partitioner>
constexpr auto &	_partitioning = NA::identifier<na::partitioning>
constexpr auto &	_partitions = NA::identifier<na::partitions>
constexpr auto &	_path = NA::identifier<na::path>
constexpr auto &	_pattern = NA::identifier<na::pattern>
constexpr auto &	_pattern_block = NA::identifier<na::pattern_block>
constexpr auto &	_pc = NA::identifier<na::pc>
constexpr auto &	_pcfactormatsolverpackage = NA::identifier<na::pcfactormatsolverpackage>
constexpr auto &	_penaldir = NA::identifier<na::penaldir>
constexpr auto &	_periodic = NA::identifier<na::periodic>
constexpr auto &	_periodicity = NA::identifier<na::periodicity>
constexpr auto &	_physic = NA::identifier<na::physic>
constexpr auto &	_physical_are_elementary_regions = NA::identifier<na::physical_are_elementary_regions>
constexpr auto &	_pid = NA::identifier<na::pid>
constexpr auto &	_points_used = NA::identifier<na::points_used>
constexpr auto &	_pointset = NA::identifier<na::pointset>
constexpr auto &	_post = NA::identifier<na::post>
constexpr auto &	_pre = NA::identifier<na::pre>
constexpr auto &	_prec = NA::identifier<na::prec>
constexpr auto &	_prefix = NA::identifier<na::prefix>
constexpr auto &	_prefix_overload = NA::identifier<na::prefix_overload>
constexpr auto &	_print = NA::identifier<na::print>
constexpr auto &	_problem = NA::identifier<na::problem>
constexpr auto &	_projection = NA::identifier<na::projection>
constexpr auto &	_properties = NA::identifier<na::properties>
constexpr auto &	_properties_space = NA::identifier<na::properties_space>
constexpr auto &	_pset = NA::identifier<na::pset>
constexpr auto &	_quad = NA::identifier<na::quad>
constexpr auto &	_quad1 = NA::identifier<na::quad1>
constexpr auto &	_quadptloc = NA::identifier<na::quadptloc>
constexpr auto &	_quality = NA::identifier<na::quality>
constexpr auto &	_range = NA::identifier<na::range>
constexpr auto &	_range_extended = NA::identifier<na::range_extended>
constexpr auto &	_rank_proc_in_files_name = NA::identifier<na::rank_proc_in_files_name>
constexpr auto &	_ray = NA::identifier<na::ray>
constexpr auto &	_rebuild = NA::identifier<na::rebuild>
constexpr auto &	_rebuild_partitions = NA::identifier<na::rebuild_partitions>
constexpr auto &	_rebuild_partitions_filename = NA::identifier<na::rebuild_partitions_filename>
constexpr auto &	_recombine = NA::identifier<na::recombine>
constexpr auto &	_refine = NA::identifier<na::refine>
constexpr auto &	_remove = NA::identifier<na::remove>
constexpr auto &	_repository = NA::identifier<na::repository>
constexpr auto &	_required_elts = NA::identifier<na::required_elts>
constexpr auto &	_required_facets = NA::identifier<na::required_facets>
constexpr auto &	_residual = NA::identifier<na::residual>
constexpr auto &	_respect_partition = NA::identifier<na::respect_partition>
constexpr auto &	_restart = NA::identifier<na::restart>
constexpr auto &	_restart_at_last_save = NA::identifier<na::restart_at_last_save>
constexpr auto &	_restart_path = NA::identifier<na::restart_path>
constexpr auto &	_reuse_jac = NA::identifier<na::reuse_jac>
constexpr auto &	_reuse_prec = NA::identifier<na::reuse_prec>
constexpr auto &	_reverse = NA::identifier<na::reverse>
constexpr auto &	_reverse_load = NA::identifier<na::reverse_load>
constexpr auto &	_rho = NA::identifier<na::rho>
constexpr auto &	_rhs = NA::identifier<na::rhs>
constexpr auto &	_robust = NA::identifier<na::robust>
constexpr auto &	_rowstart = NA::identifier<na::rowstart>
constexpr auto &	_rtolerance = NA::identifier<na::rtolerance>
constexpr auto &	_sampling = NA::identifier<na::sampling>
constexpr auto &	_save = NA::identifier<na::save>
constexpr auto &	_savehdf5 = NA::identifier<na::savehdf5>
constexpr auto &	_scale = NA::identifier<na::scale>
constexpr auto &	_script = NA::identifier<na::script>
constexpr auto &	_selector = NA::identifier<na::selector>
constexpr auto &	_sep = NA::identifier<na::sep>
constexpr auto &	_shape = NA::identifier<na::shape>
constexpr auto &	_shear = NA::identifier<na::shear>
constexpr auto &	_snapthickness = NA::identifier<na::snapthickness>
constexpr auto &	_solution = NA::identifier<na::solution>
constexpr auto &	_solution_key = NA::identifier<na::solution_key>
constexpr auto &	_solve = NA::identifier<na::solve>
constexpr auto &	_solver = NA::identifier<na::solver>
constexpr auto &	_space = NA::identifier<na::space>
constexpr auto &	_space2 = NA::identifier<na::space2>
constexpr auto &	_space_path = NA::identifier<na::space_path>
constexpr auto &	_spectrum = NA::identifier<na::spectrum>
constexpr auto &	_statistics = NA::identifier<na::statistics>
constexpr auto &	_steady = NA::identifier<na::steady>
constexpr auto &	_stolerance = NA::identifier<na::stolerance>
constexpr auto &	_straighten = NA::identifier<na::straighten>
constexpr auto &	_strategy = NA::identifier<na::strategy>
constexpr auto &	_structured = NA::identifier<na::structured>
constexpr auto &	_sub = NA::identifier<na::sub>
constexpr auto &	_subdir = NA::identifier<na::subdir>
constexpr auto &	_substructuring = NA::identifier<na::substructuring>
constexpr auto &	_suffix = NA::identifier<na::suffix>
constexpr auto &	_sum = NA::identifier<na::sum>
constexpr auto &	_tag = NA::identifier<na::tag>
constexpr auto &	_task = NA::identifier<na::task>
constexpr auto &	_test = NA::identifier<na::test>
constexpr auto &	_threading = NA::identifier<na::threading>
constexpr auto &	_threshold = NA::identifier<na::threshold>
constexpr auto &	_time_step = NA::identifier<na::time_step>
constexpr auto &	_tolerance = NA::identifier<na::tolerance>
constexpr auto &	_transform = NA::identifier<na::transform>
constexpr auto &	_transpose = NA::identifier<na::transpose>
constexpr auto &	_trial = NA::identifier<na::trial>
constexpr auto &	_type = NA::identifier<na::type>
constexpr auto &	_update = NA::identifier<na::update>
constexpr auto &	_use_harts = NA::identifier<na::use_harts>
constexpr auto &	_use_script = NA::identifier<na::use_script>
constexpr auto &	_use_tbb = NA::identifier<na::use_tbb>
constexpr auto &	_usenames = NA::identifier<na::usenames>
constexpr auto &	_value = NA::identifier<na::value>
constexpr auto &	_value_on_diagonal = NA::identifier<na::value_on_diagonal>
constexpr auto &	_values = NA::identifier<na::values>
constexpr auto &	_vector = NA::identifier<na::vector>
constexpr auto &	_verbose = NA::identifier<na::verbose>
constexpr auto &	_version = NA::identifier<na::version>
constexpr auto &	_view = NA::identifier<na::view>
constexpr auto &	_vm = NA::identifier<na::vm>
constexpr auto &	_weak_dirichlet = NA::identifier<na::weak_dirichlet>
constexpr auto &	_worldcomm = NA::identifier<na::worldcomm>
constexpr auto &	_worldscomm = NA::identifier<na::worldscomm>
constexpr auto &	_xmax = NA::identifier<na::xmax>
constexpr auto &	_xmin = NA::identifier<na::xmin>
constexpr auto &	_ymax = NA::identifier<na::ymax>
constexpr auto &	_ymin = NA::identifier<na::ymin>
constexpr auto &	_zmax = NA::identifier<na::zmax>
constexpr auto &	_zmin = NA::identifier<na::zmin>
static std::list< int > *	AREAS
MasterStream	cerr
template<size_type Contextv, size_type Value>
constexpr size_type	clear_value_v = clear_value<Contextv,Value>::value
template<size_type Contextv, size_type... Values>
constexpr size_type	clear_values_v = clear_values<Contextv,Values...>::type::value
MasterStream	clog
MasterStream	cout
static std::string *	DEBUG_AREA = 0
static std::map< unsigned int, std::string > *	DebugAreas = 0
BlocksStencilPattern	default_block_pattern (1, 1, size_type(Pattern::HAS_NO_BLOCK_PATTERN))
template<int Dmin = 2, int Dmax = 3>
auto	dim_t = hana::unpack( hana::make_range( hana::int_c<Dmin>, hana::int_c<Dmax + 1> ), hana::make_tuple )
	Geometric dimension identifier collection generator. More...
template<typename T >
constexpr uint16_type	dimension_v = dimension_t<T>::value
FEELPP_TRAITS_OP_CODE	double
const size_type	EXTRACTION_KEEP_ALL_IDS
const size_type	EXTRACTION_KEEP_EDGES_IDS = ( 1 << 1 )
const size_type	EXTRACTION_KEEP_FACES_IDS = ( 1 << 2 )
const size_type	EXTRACTION_KEEP_MARKERNAMES_ONLY_PRESENT = ( 1 << 5 )
const size_type	EXTRACTION_KEEP_MESH_RELATION = ( 1 << 4 )
const size_type	EXTRACTION_KEEP_POINTS_IDS = ( 1 << 0 )
const size_type	EXTRACTION_KEEP_VOLUMES_IDS = ( 1 << 3 )
const double	factor_from_eps = 50
const float	factor_from_eps_fl = 50
template<typename T >
constexpr bool	has_base_rangebase_32_v = has_base_rangebase_32<T>::value
template<typename T >
constexpr bool	has_base_rangebase_64_v = has_base_rangebase_64<T>::value
template<size_type Contextv, size_type Value>
constexpr bool	has_value_v = has_value<Contextv,Value>::value
const int64_type	invalid_flag_type_value = std::numeric_limits<int32_type>::min()
template<typename T >
constexpr bool	is_0d_v = is_0d<T>::value
template<typename T >
constexpr bool	is_1d_v = is_1d<T>::value
template<typename T >
constexpr bool	is_2d_v = is_2d<T>::value
template<typename T >
constexpr bool	is_3d_v = is_3d<T>::value
template<typename C >
constexpr bool	is_conforming = C::value
template<typename T >
constexpr bool	is_eigen_matrix_v = std::is_base_of_v<Eigen::MatrixBase<std::decay_t<T>>,std::decay_t<T> >
template<typename... T>
constexpr bool	is_filter_v = is_filter<T...>::value
template<typename... T>
constexpr bool	is_geoelement_v = is_geoelement<T...>::value
	Helper variable template. More...
template<typename T >
constexpr bool	is_hypercube_v = is_hypercube<T>::value
template<typename T , typename V >
constexpr bool	is_iterable_of_v = is_iterable_of<T, V>::value
template<typename T >
constexpr bool	is_iterable_v = is_iterable<T>::value
template<typename MeshT >
constexpr bool	is_mesh_structured_v = is_mesh_structured<MeshT>::value
	boolean to detect a MeshStructured mesh More...
template<typename RangeT >
constexpr bool	is_range_v = std::is_base_of_v<RangeBase<>,decay_type<RangeT>>
template<typename... T>
constexpr bool	is_reference_convex_v = is_reference_convex<T...>::value
	Helper variable template. More...
template<class T >
constexpr bool	is_shared_ptr_v = is_shared_ptr<T>::value
template<typename T >
constexpr bool	is_simplex_v = is_simplex<T>::value
template<class T >
constexpr bool	is_std_vector_v = is_std_vector_t<T>::value
template<typename T >
constexpr bool	is_tuple_v = is_tuple<T>::value
constexpr auto	is_void = hana::integral(hana::metafunction<std::is_void>)
const uint16_type	MESH_ALL_COMPONENTS = MESH_UPDATE_EDGES | MESH_UPDATE_FACES | MESH_CHECK | MESH_PARTITION | MESH_RENUMBER
const uint16_type	MESH_COMPONENTS_DEFAULTS = MESH_RENUMBER | MESH_CHECK
const std::map< std::string, std::string >	mimeTypes
constexpr multiple_space_t	multiple_space_c {}
template<int Omin = 0, int Omax = FEELPP_INSTANTIATION_ORDER_MAX>
auto	order_t = hana::unpack( hana::make_range( hana::int_c<Omin>, hana::int_c<Omax + 1> ), hana::make_tuple )
	Polynomial order identifier collection generator. More...
template<int Dmin = 2, int Dmax = 3, int Omin = 1, int Omax = FEELPP_INSTANTIATION_ORDER_MAX>
auto	Pc_t
	Continuous Lagrange Function space identifier collection generator. More...
template<int Dmin = 2, int Dmax = 3, int Omin = 1, int Omax = FEELPP_INSTANTIATION_ORDER_MAX>
auto	Pd_t
	Discontinuous Lagrange Function space identifier collection generator. More...
const double	pi = constants::pi<double>()
template<typename RangeT >
constexpr size_type	range_elementtype_v = range_elementtype_t<RangeT>::value
template<typename T >
constexpr uint16_type	real_dimension_v = real_dimension_t<T>::value
template<size_type Contextv, size_type Value>
constexpr size_type	set_value_v = set_value<Contextv,Value>::value
constexpr single_space_t	single_space_c {}
static std::string *	StringNull = 0
static uint16_type	TIMERDATA_INSTANCE_NUMBER = 0
const double	two_pi = constants::two_pi<double>()
template<typename MeshType >
using	is_mesh = typename std::is_base_of< MeshBase<>, decay_type< MeshType > >::type
	if T has base class MeshBase<> (hense if it is a function space) then provides the member constant value equal to true, false otherwise
template<typename MeshType >
using	mesh_t = decay_type< MeshType >
	provides the mesh type if MeshType is a shared_ptr of a Mesh then provides the mesh type More...
template<typename T >
using	is_scalar_field = typename std::is_base_of< ScalarBase, T >::type
	if T has base class ScalarBase then More...
template<typename T >
using	is_vector_field = typename std::is_base_of< VectorialBase, T >::type
	if T has base class VectorialBase then More...
template<typename T >
using	is_tensor2_field = typename std::is_base_of< Tensor2Base, T >::type
	if T has base class Tensor2Base then More...
template<typename T >
using	is_tensor2symm_field = typename std::is_base_of< Tensor2SymmBase, T >::type
	if T has base class Tensor2SymmBase then More...
using	tensor2symm_true = std::integral_constant< bool, true >
using	tensor2symm_false = std::integral_constant< bool, false >
template<typename FuncSpaceType >
using	is_functionspace = typename std::is_base_of< FunctionSpaceBase, decay_type< FuncSpaceType > >::type
	if T has base class FunctionSpaceBase (hense if it is a function space) then provides the member constant value equal to true, false otherwise
template<typename FESpace >
using	functionspace_type = typename mpl::if_< is_functionspace< decay_type< FESpace > >, mpl::identity< decay_type< FESpace > >, mpl::identity< void > >::type::type
	provides the function space type if FESpace is a shared_ptr of a function space then provides the function space type More...
template<typename ElementType >
using	is_functionspace_element = typename std::is_base_of< FunctionSpaceBase::ElementBase, ElementType >::type
	if T has base class ElementBase (hense if it is an element of a function space) then provides the member constant value equal to true, false otherwise
template<typename ElementT >
using	functionspace_element_type = typename mpl::if_< is_functionspace_element< decay_type< ElementT > >, mpl::identity< decay_type< ElementT > >, mpl::identity< void > >::type::type
	provides the function space type if FESpace is a shared_ptr of a function space then provides the function space type More...
template<typename MeshType , int TheTag = 0>
using	elements_mesh_t = typename elements_mesh< MeshType, TheTag >::type
	get the type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	elements_mesh_ptr_t = typename elements_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	elements_mesh_cptr_t = typename elements_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	faces_mesh_t = typename faces_mesh< MeshType, TheTag >::type
	get the type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	faces_mesh_ptr_t = typename faces_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	faces_mesh_cptr_t = typename faces_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	facets_mesh_t = typename facets_mesh< MeshType, TheTag >::type
	get the type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	facets_mesh_ptr_t = typename facets_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	facets_mesh_cptr_t = typename facets_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	edges_mesh_t = typename edges_mesh< MeshType, TheTag >::type
	get the type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	edges_mesh_ptr_t = typename edges_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	edges_mesh_cptr_t = typename edges_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the mesh of topological dimension 2 More...
template<typename MeshType , int TheTag = 0>
using	parent_mesh_t = typename parent_mesh< MeshType, TheTag >::type
	get the type of the mesh of topological dimension d+1 if the real dimension of the mesh is d+1 More...
template<typename MeshType , int TheTag = 0>
using	parent_mesh_ptr_t = typename parent_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the mesh of topological dimension d+1 if the real dimension of the mesh is d+1 More...
template<typename MeshType , int TheTag = 0>
using	parent_mesh_cptr_t = typename parent_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the mesh of topological dimension d+1 if the real dimension of the mesh is d+1 More...
template<typename MeshType , int TheTag = 0>
using	trace_mesh_t = typename trace_mesh< MeshType, TheTag >::type
	get type of the trace of a mesh More...
template<typename MeshType , int TheTag = 0>
using	trace_mesh_ptr_t = typename trace_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the trace of a mesh More...
template<typename MeshType , int TheTag = 0>
using	trace_mesh_cptr_t = typename trace_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the trace of a const mesh More...
template<typename MeshType , int TheTag = 0>
using	trace_trace_mesh_t = typename trace_trace_mesh< MeshType, TheTag >::type
	get type of the trace of the trace of a mesh More...
template<typename MeshType , int TheTag = 0>
using	trace_trace_mesh_ptr_t = typename trace_trace_mesh< MeshType, TheTag >::ptrtype
	get the shared_ptr type of the trace of the trace of a mesh More...
template<typename MeshType , int TheTag = 0>
using	trace_trace_mesh_cptr_t = typename trace_trace_mesh< MeshType, TheTag >::const_ptrtype
	get the shared_ptr type of the trace of the trace of a const mesh More...
template<typename MeshType >
constexpr bool	is_mesh_v = is_mesh<MeshType>::value
	helper variable template for is_mesh
template<typename MeshType >
constexpr bool	is_simplex_mesh_v = is_simplex_v<typename MeshType::shape_type>
template<typename T >
constexpr bool	is_scalar_field_v = is_scalar_field<T>::value
	helper variable template for is_scalar_field
template<typename T >
constexpr bool	is_vector_field_v = is_vector_field<T>::value
	helper variable template for is_vector_field
template<typename T >
constexpr bool	is_tensor2_field_v = is_tensor2_field<T>::value
	helper variable template for is_tensor2_field
template<typename T >
constexpr bool	is_tensor2symm_field_v = is_tensor2symm_field<T>::value
	helper variable template for is_tensor2symm_field
template<typename T >
constexpr bool	is_matrix_field_v = is_tensor2_field_v<T> || is_tensor2symm_field_v<T>
	helper variable template, More...
template<typename FuncSpaceType >
constexpr bool	is_functionspace_v = is_functionspace<FuncSpaceType>::value
	helper variable template for is_functionspace
template<typename ElementType >
constexpr bool	is_functionspace_element_v = is_functionspace_element<ElementType>::value
	helper variable template for is_functionspace_element
template<typename MeshType > requires is_mesh_v<MeshType>
constexpr int	topodim (std::shared_ptr< MeshType > const &m)
template<typename MeshType > requires is_mesh_v<MeshType>
constexpr int	realdim (std::shared_ptr< MeshType > const &m)

Constants
template<typename T >
const T	invalid_v = T(-1)
	get invalid value from type T
const uint8_type	invalid_uint8_type_value = uint8_type( -1 )
	Invalid uint8_type value.
const uint16_type	invalid_uint16_type_value = uint16_type( -1 )
	Invalid uint16_type value.
const uint32_type	invalid_uint32_type_value = uint32_type( -1 )
	Invalid uint32_type value.
const uint64_type	invalid_uint64_type_value = uint64_type( -1 )
	Invalid uint64_type value.
const dim_type	invalid_dim_type_value = dim_type( -1 )
	Invalid dim type value.
const rank_type	invalid_rank_type_value = rank_type( -1 )
	Invalid dim type value.
const size_type	invalid_size_type_value = size_type( -1 )
	Invalid size type value.
const uint16_type	quad_order_from_expression = invalid_uint16_type_value
	Quadrature order deduced from the expression to integrate.
template<typename E >
constexpr auto	to_underlying (E e) noexcept
	get the underlying value of an enum class entry
template<typename E , typename T >
constexpr std::enable_if< std::is_enum< E >::value &&std::is_integral< T >::value, E >::type	to_enum (T value) noexcept

Detailed Description

-*- mode: c++; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; show-trailing-whitespace: t -*-

-*- mode: c++; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; show-trailing-whitespace: t -*- vim:fenc=utf-8:ft=cpp:et:sw=4:ts=4:sts=4

allow automatic type naming of complex expression

include linear algebra backend

file GeoEntity.h

Namespace for general FEEL functions.

This file is part of the Feel++ library

Author(s): Christophe Prud'homme chris.nosp@m.toph.nosp@m.e.pru.nosp@m.dhom.nosp@m.me@fe.nosp@m.elpp.nosp@m..org Date: 27 Nov 2016

Copyright (C) 2016 Feel++ Consortium

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

Copyright

2024 Feel++ Consortium

include function space class include gmsh mesh importer include the header for the variational formulation language (vf) aka FEEL++

This file is part of the Feel library Author(s): Christophe Prud'homme chris.nosp@m.toph.nosp@m.e.pru.nosp@m.dhom.nosp@m.me@fe.nosp@m.elpp.nosp@m..org Date: 2011-12-23 Copyright (C) 2011 Université Joseph Fourier (Grenoble I) Copyright (C) 2011-2016 Feel++ Consortium This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

This file is part of the Feel++ library

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

Typedef Documentation

args_remesh_type

template<typename T >

using Feel::args_remesh_type = typedef NA::arguments< typename na::mesh::template required_as_t<std::shared_ptr<T> >, typename na::metric::template required_as_t<std::string>, typename na::required_elts::template required_as_t<std::vector<std::string> >, typename na::required_facets::template required_as_t<std::vector<std::string> >, typename na::parent::template required_as_t<std::shared_ptr<T> >, typename na::vm::template required_as_t<po::variables_map const&>, typename na::verbose::template required_as_t<int> >

list of arguments type for remesh named parameters functions

Template Parameters

T

is_mesh_structured

template<typename MeshT >

using Feel::is_mesh_structured = typedef std::conditional_t<std::is_base_of_v<MeshStructuredBase, MeshT>, std::true_type, std::false_type>

trait type to detect a MeshStructured mesh

Template Parameters

MeshT

mesh type

operator_interpolation_t

template<typename DomainSpaceType , typename ImageSpaceType , typename IteratorRange = Range<typename ImageSpaceType::mesh_type,MESH_ELEMENTS>, typename InterpType = InterpolationNonConforming>

using Feel::operator_interpolation_t = typedef OperatorInterpolation<DomainSpaceType, ImageSpaceType, range_t<IteratorRange>, InterpType>

get the type of an OperatorInterpolation

operator_interpolation_t<space_1_type,space_2_type,Range<typename space_2_type::mesh_type,MESH_ELEMENTS>, >

P2ch_ptrtype

template<typename Base1 , typename Base2 , typename MeshType >

using Feel::P2ch_ptrtype = typedef std::shared_ptr<P2ch_type<Base1,Base2,MeshType> >

Define the shared_ptr type for Taylor-Hood space.

P2ch_ptrtype<1,Mesh<Simplex<2>>> // defines the shared_ptr type of \f$P2P1\f$ over a mesh of triangles

P2ch_type

template<typename Base1 , typename Base2 , typename MeshType >

using Feel::P2ch_type = typedef FunctionSpace<MeshType, bases<Base1, Base2>, double, Periodicity <NoPeriodicity,NoPeriodicity>, mortars<NoMortar,NoMortar> >

Define the type for P<Order1>P<Order2>

P2ch_type<1,1,Mesh<Simplex<2>>> // generates \f$P1P1\f$ over a mesh of triangles

THch_ptrtype

template<int Order, typename MeshType >

using Feel::THch_ptrtype = typedef std::shared_ptr<FunctionSpace<MeshType, bases<Lagrange<Order+1,Vectorial>,Lagrange<Order,Scalar> >, double, Periodicity <NoPeriodicity,NoPeriodicity>, mortars<NoMortar,NoMortar> > >

Define the shared_ptr type for Taylor-Hood space.

THch_ptrtype<1,Mesh<Simplex<2>>> // defines the shared_ptr type of \f$P2P1\f$ over a mesh of triangles

THch_type

template<int Order, typename MeshType >

using Feel::THch_type = typedef FunctionSpace<MeshType, bases<Lagrange<Order+1,Vectorial>,Lagrange<Order,Scalar> >, double, Periodicity <NoPeriodicity,NoPeriodicity>, mortars<NoMortar,NoMortar> >

Define the type for Taylor-Hood space.

THch_type<1,Mesh<Simplex<2>>> // generates \f$P2P1\f$ over a mesh of triangles

Enumeration Type Documentation

anonymous enum

anonymous enum

Legacy serialized step-state flags, retained for API/archive compatibility. Scheduling and publication state belong to TimeSet::Step, not ExportFieldSet.

Enumerator
STEP_NEW	Sample has not been explicitly marked non-new.
STEP_HAS_DATA	Geometry or field metadata is present.
STEP_ON_DISK	Current field revision has been published.
STEP_IN_MEMORY	Field buffers are marked resident.
STEP_IGNORED	Output frequency suppresses this sample.
STEP_OVERWRITE	Legacy overwrite policy.

ElementsType

enum Feel::ElementsType

entity identifier for mesh iterators

Enumerator
MESH_ELEMENTS	elements
MESH_FACES	faces
MESH_INTERNAL_FACES	internal faces
MESH_EDGES	edges
MESH_INTERNAL_EDGES	internal edges
MESH_POINTS	points

Examples

/data/cemosis/github-actions-runner/actions-runner-feelpp-1/_work/feelpp/feelpp/feelpp/feel/feeldiscr/concepts.hpp.

FunctionSpaceReusePolicy

enum class Feel::FunctionSpaceReusePolicy

strong

Select how a whole-mesh function-space request interacts with the manager.

Enumerator
automatic	Reuse when globally enabled; otherwise preserve always-new behavior.
reuse	Return the retained space, or build and retain it on a cache miss.
rebuild	Build a new space and replace the matching retained entry.
bypass	Build a new space without reading or modifying manager state.

Location

enum class Feel::Location

strong

Enumerator
global	! unknown directory
relative	! global repository
absolute	! relative to current directory
git	! absolute directory given
custom	! relative to git repository ! custom location determined by a callback function

SymmetricTensorOrder

enum class Feel::SymmetricTensorOrder

strong

Output order for packed symmetric tensor components.

Storage and DiagonalFirst are compact orders with 3 components in 2D and 6 components in 3D. The *Tensor6 values describe six-slot exporter tuples used for both 2D and 3D output, with unused 2D z-components left empty by callers.

Enumerator
Storage	Legacy packed storage order: 2D xx,xy,yy; 3D xx,xy,xz,yy,yz,zz.
DiagonalFirst	Compact diagonal-first order: 2D xx,yy,xy; 3D xx,yy,zz,xy,xz,yz.
VtkTensor6	Current VTK tensor-six tuple: xx,yy,zz,xy,yz,xz.
EnsightTensor6	Current Ensight tensor-six tuple: xx,yy,zz,xy,xz,yz.
XdmfTensor6	Current XDMF tensor-six tuple matching 3D storage slots: xx,xy,xz,yy,yz,zz.

SymmetricTensorScaling

enum class Feel::SymmetricTensorScaling

strong

Scaling convention applied to off-diagonal symmetric tensor entries.

Enumerator
Tensor	No shear scaling; off-diagonal entries keep their tensor value.
EngineeringShear	Engineering shear convention; off-diagonal entries are multiplied by 2.
Mandel	Mandel convention; off-diagonal entries are multiplied by sqrt(2).

Function Documentation

absoluteRepository()

Repository::Config Feel::absoluteRepository

(

fs::path

abs_path

)

Create repository config for absolute path location.

Use a fixed absolute path for the repository root. Useful for temporary directories or per-run storage.

Parameters

abs_path

absolute path to use as repository root

Returns

Repository::Config configured with absolute location

allelements()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::allelements

(

MeshType const &

mesh

)

Returns

a pair of iterators to iterate over elements with pid flag

allmarkededgesByType()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::allmarkededgesByType	(	MeshType const &	mesh,
		uint16_type	markerType,
		entity_process_t	ept,
		typename std::enable_if< is_3d< MeshType >::value >::type *	= nullptr
	)

Returns

a pair of iterators to iterate over edges of the mesh marked with __marker

Parameters

mesh	a mesh data structure
__marker	a marker that identifies edges
__pid	process id

Returns

a pair of iterators (begin,end) for the set of marked edges

askPassword()

FEELPP_EXPORT std::string Feel::askPassword

(

std::string const &

message

)

Ask the user to fill a password. The password is hidden with asterisks.

Parameters

message

a message to display to the user

Returns

The (clear) password in a string.

Note

: This function is unix specific.

References getOneChar().

begin()

template<typename MeshType , int MESH_ENTITIES>

auto Feel::begin

(

Range< MeshType, MESH_ENTITIES > &

range

)

get the begin iterator of a range

Template Parameters

MeshType	the mesh type
MESH_ENTITIES	the mesh entities

Parameters

range

the range of elements

Returns

auto

boundaryedges()

template<typename MeshType >

auto Feel::boundaryedges	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over all boundary edges of the mesh

boundaryelements()

template<typename MeshType >

auto Feel::boundaryelements	(	MeshType const &	mesh,
		uint16_type	entity_min_dim = 0,
		uint16_type	entity_max_dim = 2,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements of the mesh which share a face with the boundary

boundaryfaces()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::boundaryfaces	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over all boundary faces of the mesh

boundarypoints()

template<typename MeshType >

auto Feel::boundarypoints	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

the range of iterators [begin,end] over the boundary points of the mesh

Warning

this filter is not parallelized

cantor_pairing() [1/2]

constexpr int Feel::cantor_pairing ( int  a, int  b  )

constexpr

a pairing function is a process to uniquely encode two natural numbers into a single natural number.

Parameters

a
b

Returns

constexpr int

cantor_pairing() [2/2]

template<typename... T>

constexpr int Feel::cantor_pairing ( int  a, int  b, T &&...  ts  )

constexpr

compute cantor pairing recursively for number of natural numbers > 2

Template Parameters

T	integrer type

Parameters

a	integer to be paired with
b	integer to be paired with
ts	remaining pack that will be treated recursively

Returns

constexpr int

checker()

template<typename ... Ts>

Checker Feel::checker

(

Ts &&...

v

)

check create function

Parameters

c_name	name of the checker
solution	to pass to checker and check the numerical results, if empty use checker.solution
gradient	optional expression for the gradient, if empty use checker.gradient if gradient and option checker.gradient are empty then we do not set the gradient expression

cleanupTemporaryDirectory()

void Feel::cleanupTemporaryDirectory

(

const std::string &

extractionDir

)

Remove all files and directories in a directory.

Parameters

extractionDir

directory to clean up

collectionOfMarkedelements()

template<typename MeshType >

std::map< int, Range< MeshType, MESH_ELEMENTS > > Feel::collectionOfMarkedelements	(	MeshType const &	mesh,
		std::any const &	collectionOfMarkersFlag
	)

Returns

a mapping between a id and pair of iterators to iterate over elements of the mesh with marker flag

collectionOfMarkedelementsWithGhostsSplitted()

template<typename MeshType >

auto Feel::collectionOfMarkedelementsWithGhostsSplitted	(	MeshType const &	mesh,
		std::any const &	collectionOfMarkersFlag
	)

Returns

a mapping between a id and pair of (range active element, range ghost elements)

complement()

template<typename IteratorType , typename Predicate >

auto Feel::complement	(	IteratorType &&	it,
		Predicate	pred
	)

Provides the complement of the set of entities given by [begin(it),end(it)] with respect to the negation of predicate pred.

// get all faces not marked by marker1 "R"
auto set = complement( faces(mesh), [&mesh]( auto const& e ) { return e.marker() == mesh->markerName( "R" ); });

concatenate()

template<typename RangeType , typename... Args>

FEELPP_EXPORT auto Feel::concatenate	(	RangeType &&	r,
		Args &&...	args
	)

this function takes a set of iterators over geometrical entities of the same type (e.g.

faces, volumes, edges, points) and generate a data structure that will hold the corresponding reference of mesh elements. This data structure can then be used to iterate over meshes like other mesh filters.

// the following code below merges internal faces with inlet faces
auto subset = concatenate( internalfaces(mesh), markedfaces(mesh,"inlet") );
// it can then be used eg to create a submesh
auto submesh = createSubmesh( mesh, subset );

context()

template<typename... Ts>

auto Feel::context

(

Ts &&...

v

)

get the the geometric mapping context associated to a functionspace

Template Parameters

Ts	argument type variadic list

Parameters

v	argument variadic list

auto Xh=Pch<2>(mesh);
auto ctx = context(_geomap=Xh->gm(),_type=on_elements_t(),_pointset=Xh->fe()->points());

Returns

the context

countWithoutGhost()

template<typename Predicate >

auto Feel::countWithoutGhost

(

Predicate

is_ghost

)

Lambda function factory to count cells excluding ghosts.

Parameters

is_ghost

The function to check if a cell is ghost.

Returns

Lambda function.

createGradedLevelsetMetric()

template<typename SpacePtrType , typename MetricSetter >

bool Feel::createGradedLevelsetMetric	(	SpacePtrType const &	P1h,
		std::string const &	metric_expr,
		MetricSetter	metric_setter,
		std::vector< std::string >	default_markers = {}
	)

Create a Graded Levelset metric.

Template Parameters

SpacePtrType	P1 function space type
MetricSetter	functor that takes a P1 function and set the metric

Parameters

P1h	the function space in which the metric is defined
metric_expr	the expression of the metric
metric_setter	the setter functor
default_markers	the default markers to use if the metric_expr does not contain markers

Returns

true if the metric has been set

false otherwise

customRepository()

Repository::Config Feel::customRepository	(	std::string	reldir,
		std::function< fs::path()>	callback
	)

Create a Repository Config with custom location callback.

The callback will be invoked during Repository::configure() after options are processed. This allows for dynamic repository location based on runtime configuration.

Parameters

reldir	fallback directory (can be used within callback)
callback	function that returns the computed repository path

Returns

Repository::Config configured with custom location

DhPdh()

template<int Order, typename MeshType >

std::shared_ptr< FunctionSpace< MeshType, bases< RaviartThomas< Order >, Lagrange< Order, Scalar, Discontinuous > > > > Feel::DhPdh	(	std::shared_ptr< MeshType >	mesh,
		std::vector< DofTableExtendedType >	dte = std::vector<DofTableExtendedType>( 2, DofTableExtendedType::DEFAULT )
	)

#include <feel/feeldiscr/dhpdh.hpp>
auto Xh = DhPdh<2>( mesh );

dimension()

template<typename T >

constexpr int Feel::dimension ( T const &  t )

constexpr

Returns

topological dimension of a type T

div()

template<typename ElementType >

ElementType Feel::div	(	ElementType const &	v1,
		ElementType const &	v2,
		typename boost::enable_if< boost::is_base_of< FunctionSpaceBase::ElementBase, ElementType > >::type *	dummy = 0
	)

Computes the element wise division of two vectors and eventually in parallel.

Parameters

v1	vector (eventually distributed)
v2	vector (eventually distributed)

Returns

the element wise division product of v1 and v2

edges()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::edges	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over edges of the mesh on processor __pid

Parameters

mesh	a mesh data structure
__pid	process id

Returns

a pair of edge iterators (begin,end)

Referenced by Feel::Mesh3D< Shape, T, IndexT >::localEdgeId().

elements() [1/5]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>

auto Feel::elements	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements with pid flag

Referenced by nlohmann::detail::binary_reader< BasicJsonType, InputAdapterType, SAX >::__attribute__(), Feel::TwoSpacesMap< SpaceType >::build(), etaQ(), expr(), hMeasures(), Feel::FunctionSpace< MeshTypes, BasisTypes, T, PeriodicityType, MortarType >::isMortar(), nsrQ(), Feel::Mesh3D< Shape, T, IndexT >::numLocalTopologicalFaces(), Feel::Mesh0D< Shape, T, IndexT >::numLocalVertices(), projector(), Feel::Localization< MeshType >::setMesh(), and Feel::Localization< MeshType >::updateForUse().

elements() [2/5]

template<typename MeshType , typename EntityRangeType , std::enable_if_t< is_range_v< EntityRangeType >, int > = 0>

auto Feel::elements	(	MeshType const &	mesh,
		EntityRangeType const &	rangeEntity,
		ElementsType	type = ElementsType::MESH_POINTS
	)

Returns

a pair of iterators to iterate over all elements (not ghost) which touch the range of faces or edges rangeEntity by a point/edge/faces (with respect to type arg)

elements() [3/5]

template<typename MeshType , typename RangeType , typename EntityRangeType >

Range< typename RangeType::mesh_t, MESH_ELEMENTS > Feel::elements	(	MeshType const &	mesh,
		RangeType const &	rangeElt,
		EntityRangeType const &	rangeEntity,
		ElementsType	type = ElementsType::MESH_POINTS
	)

Returns

a pair of iterators to iterate over a range of elements 'rangeElt' which touch the range of faces or edges \rangeEntity by a point/edge/faces (with respect to type arg)

elements() [4/5]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>

auto Feel::elements	(	MeshType const &	mesh,
		rank_type	pid,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements with pid flag

elements() [5/5]

template<typename MeshType , typename ExprType , typename... Ts, std::enable_if_t< std::is_base_of_v< MeshBase<>, decay_type< std::remove_pointer_t< MeshType > > >, int > = 0>

Range< MeshType, MESH_ELEMENTS > Feel::elements	(	MeshType const &	mesh,
		vf::Expr< ExprType > const &	expr,
		Ts &&...	v
	)

Returns

a pair of iterators to iterate over elements with pid flag and verified expr > 0 for all nodes of the element

entityMarkers()

template<int EntityCoDim, typename ElementT >

std::optional< std::map< uint16_type, typename ElementT::marker_type > > Feel::entityMarkers	(	ElementT const &	e,
		uint16_type	f
	)

get the map of markers of a entity of a geoelement

Parameters

e	element id to get face markers from
f	entity id in the element

Returns

an optional map of markers for the entity f of the element e

enumerate()

template<typename T , typename TIter = decltype(std::begin(std::declval<T>())), typename = decltype(std::end(std::declval<T>()))>

constexpr auto Feel::enumerate ( T &&  iterable, size_t  start = 0  )

constexpr

create an index associated to a iterable object

Template Parameters

T	type of the iterable
TIter	type of the iterator

Parameters

start	index start
iterable	iterable object to create the index from

Returns

constexpr auto pair index and iterator

etaQ()

template<typename MeshType >

std::shared_ptr< Pdh_element_t< MeshType, 0 > > Feel::etaQ	(	Pdh_ptrtype< MeshType, 0 > const &	Xh,
		std::shared_ptr< MeshType > const &	m
	)

Return default triangle/tetrahedra quality (eta) of a given cell.

The quality measure relates the area of the triangle (a) to its edge lengths (l1, l2, l3). \( \eta = \frac{4\sqrt{3}a}{l_1^2 + l_2^2 + l_3^2} \)

References elements().

expansion() [1/2]

template<typename ElementType , typename CoeffType >

Feel::remove_shared_ptr_type< ElementType > Feel::expansion	(	std::vector< ElementType > const &	b,
		CoeffType const &	c,
		int	M = -1
	)

Given a set of coefficient c and a set of finite element function b, build.

\[ w = \sum_{i=1}^{M} c_i b_i \]

The last argument M allows to build only a subset of the expansion

References expansion(), and unwrap_ptr().

expansion() [2/2]

template<typename ElementType , typename CoeffType >

void Feel::expansion	(	std::vector< ElementType > const &	b,
		CoeffType const &	c,
		Vector< typename Feel::remove_shared_ptr_type< ElementType >::value_type > &	res,
		int	M = -1
	)

Given a set of coefficient c and a set of finite element function b, build.

\[ w = \sum_{i=1}^{M} c_i b_i \]

The last argument M allows to build only a subset of the expansion

References unwrap_ptr().

Referenced by expansion().

expr() [1/2]

template<typename MeshT , typename ExprT , std::enable_if_t< std::is_base_of_v< MeshBase< typename MeshT::index_type >, MeshT > &&std::is_base_of_v< ExprBase, ExprT >, MeshT > * = nullptr>

Pch_element_type< MeshT, 1 > Feel::expr	(	std::shared_ptr< MeshT > const &	mesh,
		ExprT &&	e
	)

create an isotropic metric field based on a scalar expression

Template Parameters

MeshT	MEsh type
ExprT	expression type of the metric

Parameters

mesh	mesh
e	expression

Returns

Pch_element_type<MeshT, 1> continuous piecewise P1 function representing the metric

expr() [2/2]

template<typename SpaceT , typename ExprT , std::enable_if_t< std::is_base_of_v< FunctionSpaceBase, SpaceT > &&std::is_base_of_v< ExprBase, ExprT >, SpaceT > * = nullptr>

SpaceT::element_type Feel::expr	(	std::shared_ptr< SpaceT > const &	Xh,
		ExprT &&	e
	)

create an isotropic metric field based on a scalar expression

Template Parameters

SpaceT	function space type
ExprT	expression type of the metric

Parameters

Xh	function space
e	expression

Returns

Pch_element_type<MeshT, 1> continuous piecewise P1 function representing the metric

References elements().

Referenced by Feel::FeelModels::ModelPhysic< Dim >::addParameter(), Feel::vf::describeSymbolicDependencies(), Feel::vf::diff(), Feel::vf::expr(), Feel::vf::operator+(), Feel::vf::operator-(), and Feel::FeelModels::ModelBase::setModelProperties().

extractZipFile()

bool Feel::extractZipFile	(	const std::string &	zipFilePath,
		const std::string &	extractionDir
	)

Extract a zip file to a directory.

Parameters

zipFilePath	path to the zip file
extractionDir	directory where to extract the zip file

Returns

true if the extraction was successful

false otherwise

faces()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::faces	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over faces of the mesh on processor __pid

Parameters

mesh	a mesh data structure
__pid	process id

Returns

a pair of face iterators (begin,end)

Referenced by Feel::Mesh2D< Shape, T, IndexT >::numPoints().

flat()

template<typename ExprT1 >

Expr< FlatExpr< ExprT1 > > Feel::flat

(

ExprT1 const &

__e1

)

precompute expression tensor

This allows for more efficient bi/linear form assembly

Referenced by Feel::Application::printStats().

getOrCreateFunctionSpace()

template<typename SpaceType , typename MeshType , typename Factory >

std::shared_ptr< SpaceType > Feel::getOrCreateFunctionSpace	(	std::shared_ptr< MeshType > const &	mesh,
		FunctionSpaceManagerOptions const &	options,
		FunctionSpaceReusePolicy	policy,
		Factory &&	factory
	)

Typed factory adapter for the process-wide function-space manager.

Mesh-change observation is connected when the mesh type exposes the expected meshChanged signal. The returned pointer is checked against the requested concrete type.

Template Parameters

SpaceType	concrete function-space type
MeshType	concrete mesh type
Factory	construction callable type

Parameters

mesh	mesh on which the space is defined
options	normalized options that participate in the manager key
policy	requested reuse policy
factory	callable constructing std::shared_ptr<SpaceType>

Returns

retained or newly constructed function space

getOrCreateWholeMeshFunctionSpace()

template<typename SpaceType , typename MeshType , typename Factory >

std::shared_ptr< SpaceType > Feel::getOrCreateWholeMeshFunctionSpace	(	std::shared_ptr< MeshType > const &	mesh,
		DofTableExtendedType	dte,
		FunctionSpaceReusePolicy	policy,
		Factory &&	factory
	)

Get or construct a whole-mesh function space with standard mesh options.

This adapter centralizes the construction options shared by whole-mesh convenience factories. The factory controls only the concrete space's construction details, such as its worlds communicator.

Template Parameters

SpaceType	concrete function-space type
MeshType	concrete mesh type
Factory	construction callable type

Parameters

mesh	mesh on which the space is defined
dte	requested extended-DOF-table mode
policy	requested reuse policy
factory	callable constructing std::shared_ptr<SpaceType>

Returns

retained or newly constructed function space

gitRepository()

Repository::Config Feel::gitRepository

(

fs::path

start_path = "."

)

Create repository config for git location.

Tells Feel++ to detect the nearest .git directory and use <git-root>/feelppdb

Parameters

start_path

starting path for .git search (default: current directory)

Returns

Repository::Config configured with git location

globalRank()

template<typename C >

auto Feel::globalRank

(

C const &

c

)

Returns

the global MPI rank of the data structure c

Referenced by Feel::TwoSpacesMap< SpaceType >::clusterToSequential(), and Feel::WorldComm::isMasterRank().

globalReduce()

template<typename T , typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>

T Feel::globalReduce	(	T	local,
		bool	global,
		RangeT const &	r
	)

Utility function for MPI global reduction.

Parameters

local	The local data to be reduced.
global	Whether to perform global reduction.
r	The range providing the WorldComm.

Returns

Reduced result.

gmtimeFrom()

std::tm Feel::gmtimeFrom

(

std::chrono::system_clock::time_point

tp

)

Return a std::tm in UTC from a given system_clock::time_point.

Example:

auto tp = std::chrono::system_clock::now();
fmt::print("[{:%Y-%m-%d %H:%M:%S}] checkpoint\\n", Feel::gmtimeFrom(tp));

gmtimeNow()

std::tm Feel::gmtimeNow

(

)

Return current time as std::tm in UTC for use with {fmt}.

Example:

#include <feel/feelcore/time_utils.hpp>
#include <fmt/core.h>
#include <fmt/chrono.h>
 
int main()
{
    fmt::print("[{:%Y-%m-%d %H:%M:%S}] hello from Feel++!\\n", Feel::gmtimeNow());
    return 0;
}

gradedfromls()

template<typename SpaceT , typename RangeType , std::enable_if_t< std::is_base_of_v< FunctionSpaceBase, SpaceT > &&is_range_v< decay_type< RangeType > > &&decay_type< RangeType >::entities()==MESH_FACES, SpaceT > * = nullptr>

SpaceT::element_type Feel::gradedfromls	(	std::shared_ptr< SpaceT > const &	Xh,
		RangeType &&	facets,
		double	hclose,
		double	hfar,
		double	cst = 0.
	)

create an isotropic metric field based on a levelset gradation

Template Parameters

SpaceT

function space type

Parameters

Xh	function space
facets	ranges of facets to compute the levelset function based on the distance function to these facets
hclose	mesh size close to the facets
hfar	mesh size far away from the facets
cst	real between 0 and 1 providing where the gradation is constant

Returns

Pch_element_type<MeshT, 1> continuous piecewise P1 function representing the metric

handleExceptions()

void Feel::handleExceptions

(

)

handle exceptions using a Lippincott function this funnction allows to handle the exceptions thrown in Feel++

try {
  Environment env(),
  // Feel++ code here
}
catch( ... )
{
  handleExceptions()
}

hasFaceWithAnyOfTheMarkers()

template<typename EltType >

bool Feel::hasFaceWithAnyOfTheMarkers	(	EltType const &	e,
		std::vector< std::string > const &	flags,
		std::enable_if_t<(dimension_v< EltType > > 0) &&is_geoelement_v< EltType > > *	= nullptr
	)

check if a element as faces with any of the string markers

Template Parameters

EltType

element type to be checked

Parameters

e	element to be checked
flags	vector of strings containing the markers

Returns

bool true if has face with at least one of the markers, false otherwise

References Feel::GeoElement3D< Dim, GEOSHAPE, T, IndexT, UseMeasuresStorage >::id(), and Feel::GeoElement3D< Dim, GEOSHAPE, T, IndexT, UseMeasuresStorage >::numLocalFaces.

hasFaceWithMarker()

template<typename EltType >

bool Feel::hasFaceWithMarker	(	EltType const &	e,
		boost::any const &	flag,
		std::enable_if_t<(dimension_v< EltType > > 0) &&is_geoelement_v< EltType > > *	= nullptr
	)

get if a face of an element has the marker flag

Template Parameters

EltType

type of mesh element

Returns

true if the element e has a face with flag, false otherwise

References Feel::GeoElement3D< Dim, GEOSHAPE, T, IndexT, UseMeasuresStorage >::id(), and Feel::GeoElement3D< Dim, GEOSHAPE, T, IndexT, UseMeasuresStorage >::numLocalFaces.

hMeasures()

template<typename MeshType >
requires is_mesh_v<MeshType>

auto Feel::hMeasures

(

std::shared_ptr< MeshType > const &

m

)

compute h measures statistics over all elements of a shared_ptr<mesh>

Template Parameters

MeshType

type of the mesh

Parameters

m	shared_ptr<mesh>

Returns

auto

References elements(), and hMeasures().

idedelements()

template<typename MeshType >

auto Feel::idedelements	(	MeshType const &	mesh,
		flag_type	flag
	)

Returns

a pair of iterators to iterate over elements with id flag

idedfaces()

template<typename MeshType >

auto Feel::idedfaces	(	MeshType const &	mesh,
		size_type	id
	)

Returns

a pair of iterators to iterate over elements with id id

internaledges()

template<typename MeshType >

auto Feel::internaledges	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over all internal edges of the mesh

internalelements()

template<typename MeshType >

auto Feel::internalelements	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements of the mesh which are strictly within the domain that is to say they do not share a face with the boundary

internalfaces()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::internalfaces	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over all internal faces of the mesh belong to process domain __pid

internalpoints()

template<typename MeshType >

auto Feel::internalpoints	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

the range of iterators [begin,end] over the internal(not on the boundary) points of the mesh

Warning

this filter is not parallelized

interpolate()

template<typename SpaceType , typename FunctionType , typename InterpType >

void Feel::interpolate	(	std::shared_ptr< SpaceType > const &	space,
		FunctionType const &	f,
		InterpType &	interp
	)

Given a space space using a lagrange basis, compute the interpolation interp of f belonging to another function space.

FunctionSpace<mesh_type,fusion::vector<Whatever> > Yh;
FunctionSpace<mesh_type,fusion::vector<Whatever> >::element_type f;
FunctionSpace<mesh_type,fusion::vector<Lagrange<> > > Xh;
FunctionSpace<mesh_type,fusion::vector<Lagrange<> > >::element_type u;
interpolate( Xh, f, u );

interprocessfaces() [1/2]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::interprocessfaces

(

MeshType const &

mesh

)

Returns

a pair of iterators to iterate over all interprocess faces of the mesh belonging to process __pid

interprocessfaces() [2/2]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::interprocessfaces	(	MeshType const &	mesh,
		rank_type	neighbor_pid
	)

Returns

a pair of iterators to iterate over all interprocess faces of the mesh belonging to process __pid

intersect()

template<typename RangeType , typename... Args>

FEELPP_EXPORT auto Feel::intersect	(	RangeType &&	it,
		Args &&...	args
	)

this function takes a set of iterators over geometrical entities of the same type (e.g.

faces, volumes, edges, points) and generate a data structure that will hold the corresponding reference of mesh elements. This data structure can then be used to iterate over meshes like other mesh filters.

// the following code below intersection of internal elements with marked elements omega
auto subset = intersect( internalelements(mesh), markedelements(mesh,"omega") );
// it can then be used eg to create a submesh
auto submesh = createSubmesh( mesh, subset );

ipow()

constexpr int64_t Feel::ipow ( int64_t  base, int  exp, int64_t  result = 1  )

constexpr

compute integer power

uint64_t i = ipow( 2, 3 );

isGhostCell()

template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>

auto Feel::isGhostCell

(

)

Lambda function factory to check if a cell is a ghost.

Template Parameters

RangeT

Type of the range.

Returns

Lambda function.

location() [1/2]

Location Feel::location ( const std::string &  location_string )

noexcept

get the Location enum from string

Parameters

location_string

string encoding the Location

Returns

Location

location() [2/2]

const std::string & Feel::location ( Location  location_enum )

noexcept

get location string from Location enum the string is empty if the Location is unknown

Parameters

location_enum

Returns

const std::string&

Referenced by Feel::vf::SymbolicDiagnosticSourceLocation::from(), and Feel::vf::details::unsupportedSymbolicDifferentiation().

makeMesh()

template<class T , class... Args>

decltype(auto) Feel::makeMesh

(

Args &&...

args

)

See also

makeSharedMesh

makeSharedMesh()

template<class T , class... Args>

std::shared_ptr< Mesh< T > > Feel::makeSharedMesh

(

Args &&...

args

)

Create a shared pointer Mesh<T> from Args.

// create a tetrahedron mesh std::shared_ptr
auto mesh = makeSharedMesh<Simplex<3>>();

makeUniqueMesh()

template<class T , class... Args>

std::unique_ptr< Mesh< T > > Feel::makeUniqueMesh

(

Args &&...

args

)

Create a unique pointer Mesh<T> from Args.

// create a tetrahedron mesh std::unique_ptr
auto mesh = makeUniqueMesh<Simplex<3>>();

marked2elements()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::marked2elements	(	MeshType const &	mesh,
		boost::any const &	markersFlag,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements of the mesh with Marker2 string

marked3elements()

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::marked3elements	(	MeshType const &	mesh,
		boost::any const &	markersFlag,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements of the mesh with Marker3 string

markedelements() [1/2]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::markedelements

(

MeshType const &

mesh

)

Returns

a pair of iterators to iterate over elements of the mesh with marker

References markedelementsByType().

markedelements() [2/2]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::markedelements	(	MeshType const &	mesh,
		boost::any const &	markersFlag,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over elements of the mesh with marker flag

markedelementsByType() [1/3]

template<typename MeshType >

auto Feel::markedelementsByType	(	MeshType const &	mesh,
		uint16_type	markerType,
		boost::any const &	markersFlag,
		rank_type	pid,
		entity_process_t	ept
	)

Returns

a pair of iterators to iterate over elements of the mesh with marker flag

markedelementsByType() [2/3]

template<typename MeshType >

auto Feel::markedelementsByType	(	MeshType const &	mesh,
		uint16_type	markerType,
		entity_process_t	ept
	)

Returns

a pair of iterators to iterate over elements of the mesh with marker flag

Referenced by markedelements().

markedelementsByType() [3/3]

template<typename MeshType >

auto Feel::markedelementsByType	(	MeshType const &	mesh,
		uint16_type	markerType,
		std::initializer_list< boost::any > const &	markersFlag,
		rank_type	pid,
		entity_process_t	ept
	)

Returns

a pair of iterators to iterate over elements of the mesh with marker flag

markedfaces() [1/2]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::markedfaces

(

MeshType const &

mesh

)

Returns

a pair of iterators to iterate over faces of the mesh marked

Parameters

mesh	a mesh data structure
__pid	process id

Returns

a pair of iterators (begin,end) for the set of marked faces

markedfaces() [2/2]

template<typename MeshType , std::enable_if_t< std::is_base_of_v< MeshBase<>, unwrap_ptr_t< MeshType > >, int > = 0>

auto Feel::markedfaces	(	MeshType const &	mesh,
		boost::any const &	markersFlag,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over faces of the mesh marked with __marker

Parameters

mesh	a mesh data structure
markersFlag	a marker that identifies faces

Returns

a pair of iterators (begin,end) for the set of marked faces

markedpoints() [1/2]

template<typename MeshType >

auto Feel::markedpoints	(	MeshType const &	mesh,
		boost::any const &	markersFlag,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Parameters

mesh	a mesh data structure
markersFlag	a marker that identifies points

Returns

the range of iterators [begin,end,container] over the marked points with flag of the mesh

markedpoints() [2/2]

template<typename MeshType >

auto Feel::markedpoints	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

a pair of iterators to iterate over points of the mesh marked

Parameters

mesh	a mesh data structure
__pid	process id

Returns

a pair of iterators (begin,end) for the set of marked points

measurePointElements()

template<typename MeshType >

auto Feel::measurePointElements

(

std::shared_ptr< FunctionSpace< MeshType, bases< Lagrange< MeshType::nOrder, Scalar > > > > &

Xh

)

-> decltype( Xh->element() )

Given a function space Xh, compute the sum of of the measure of the elements shared by a point in the mesh.

This is helfpul for example for a posteriori error estimation.

nelements() [1/4]

template<typename CollectionOfRangeT , std::enable_if_t< is_range_v< typename CollectionOfRangeT::value_type >, int > = 0>

size_type Feel::nelements	(	CollectionOfRangeT const &	its,
		bool	global = false,
		bool	ignoreGhosts = true
	)

Compute the number of elements in a collection of ranges.

Template Parameters

CollectionOfRangeT

Collection type (e.g., list, vector).

Parameters

its	The collection of ranges.
global	Whether to compute the number globally.
ignoreGhosts	Indicates whether the number should be calculated without the ghost entities

Returns

Number of elements.

References global, and nelements().

nelements() [2/4]

template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>

size_type Feel::nelements	(	RangeT const &	its,
		Zone const &	z
	)

Compute the number of elements in a range for a given zone.

Template Parameters

RangeT

Type of the range.

Parameters

its	The range.
z	The zone.

Returns

Number of elements.

nelements() [3/4]

template<typename RangeT , std::enable_if_t< is_filter_v< RangeT >, int > = 0>

size_type Feel::nelements	(	RangeT const &	r,
		bool	global = false,
		bool	ignoreGhosts = true
	)

Compute the number of elements in a range.

Template Parameters

RangeT

Type of the range.

Parameters

r	The range.
global	Whether to compute the number globally.
ignoreGhosts	Indicates whether the number should be calculated without the ghost entities

Returns

Number of elements.

Referenced by nelements().

nelements() [4/4]

template<typename MeshType , int Entities>

FEELPP_DEPRECATED size_type Feel::nelements	(	std::list< Range< MeshType, Entities > > const &	r,
		bool	global,
		bool	ignoreGhosts = true
	)

[Deprecated] Compute the number of elements in a list of ranges.

Template Parameters

MeshType	Type of the mesh.
Entities	The entity type.

Parameters

r	The list of ranges.
global	Whether to compute the number globally.
ignoreGhosts	Indicates whether the number should be calculated without the ghost entities

Returns

Number of elements.

NLOHMANN_JSON_SERIALIZE_ENUM()

Feel::NLOHMANN_JSON_SERIALIZE_ENUM	(	Location	,
		{ { Location::unknown, nullptr }, { Location::global, "global" }, { Location::relative, "relative" }, { Location::absolute, "absolute" }, { Location::git, "git" }, { Location::custom, "custom" } }
	)		const

get the location strings assocation to enum Location

Returns

const std::map<location, std::string>&

normalizeFunctionSpaceDofTable()

DofTableExtendedType Feel::normalizeFunctionSpaceDofTable

(

DofTableExtendedType

dte

)

Normalize an extended-DOF-table option for use in a manager key.

Parameters

dte	requested extended-DOF-table mode

Returns

VERTICES for DEFAULT, otherwise dte

nsrQ()

template<typename MeshType >

std::shared_ptr< Pdh_element_t< MeshType, 0 > > Feel::nsrQ	(	Pdh_ptrtype< MeshType, 0 > const &	Xh,
		std::shared_ptr< MeshType > const &	m
	)

Return the normalized shape ratio (NSR) for a given element.

it is referred as the radius ratio, as it is described by the ratio between the inradius (r) and the circumradius (R). \(\rho = \frac{dr}{R}\) where d is the dimension

References elements().

operator*() [1/2]

template<typename SpaceType , typename VectorType , typename ElemContType >

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > Feel::operator*	(	Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	a,
		typename SpaceType::value_type const &	s
	)

operator * with a scalar on the right

Template Parameters

SpaceType	space type
VectorType	representation type
ElemContType	type of elements

Parameters

a	linear form
s	representation type

Returns

LinearForm<SpaceType, VectorType, ElemContType>

operator*() [2/2]

template<typename SpaceType , typename VectorType , typename ElemContType >

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > Feel::operator*	(	typename SpaceType::value_type const &	s,
		Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	a
	)

operator * with a scalar on the left

Template Parameters

SpaceType	space type
VectorType	representation type
ElemContType	type of container of elements

Parameters

s	scalar
a	linear form

Returns

LinearForm<SpaceType, VectorType, ElemContType>

operator+()

template<typename SpaceType , typename VectorType , typename ElemContType >

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > Feel::operator+	(	Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	a,
		Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	b
	)

operator + with two linear forms

Template Parameters

SpaceType	space type
VectorType	representation type
ElemContType	type of element

Parameters

a	linear form
b	linear form

Returns

LinearForm<SpaceType, VectorType, ElemContType>

Examples

/data/cemosis/github-actions-runner/actions-runner-feelpp-1/_work/feelpp/feelpp/feelpp/feel/feelvf/concepts.hpp.

operator-() [1/2]

template<typename SpaceType , typename VectorType , typename ElemContType >

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > Feel::operator-

(

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &

a

)

unary minus operator

Template Parameters

SpaceType	space type
VectorType	representation type
ElemContType	type of container of elements

Parameters

a	linear form

Returns

LinearForm<SpaceType, VectorType, ElemContType>

operator-() [2/2]

template<typename SpaceType , typename VectorType , typename ElemContType >

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > Feel::operator-	(	Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	a,
		Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	b
	)

operator - with two linear forms

Template Parameters

SpaceType	space type
VectorType	representation type
ElemContType	type of element

Parameters

a	linear form
b	linear form

Returns

LinearForm<SpaceType, VectorType, ElemContType>

operator/()

template<typename SpaceType , typename VectorType , typename ElemContType >

Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > Feel::operator/	(	Feel::vf::detail::LinearForm< SpaceType, VectorType, ElemContType > const &	a,
		typename SpaceType::value_type const &	s
	)

operator / with a scalar

Template Parameters

SpaceType	space type
VectorType	representation type
ElemContType	type of container of elements

Parameters

a	linear form
s	scalar

Returns

LinearForm<SpaceType, VectorType, ElemContType>

operator<<() [1/2]

FEELPP_EXPORT std::ostream & Feel::operator<<	(	std::ostream &	os,
		AboutData const &	about
	)

outpout stream an AboutData structure

Parameters

os	ostream to use to stream the about data
about	data to stream

Returns

the ostream

operator<<() [2/2]

template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 >

std::ostream & Feel::operator<<	(	std::ostream &	os,
		FunctionSpace< A0, A1, A2, A3, A4 > const &	Xh
	)

iostream operator to print some information about the function space Xh

auto Xh = Pch<2>(mesh);
// Xh is a pointer
std::cout << "Xh:" << *Xh << "\n";

operatorSteklPc()

template<typename space_type >

std::shared_ptr< OperatorSteklovPc< space_type > > Feel::operatorSteklPc	(	std::shared_ptr< space_type > const &	space,
		typename OperatorSteklovPc< space_type >::backend_ptrtype const &	backend = Backend<double>::build( BACKEND_PETSC )
	)

this function returns a OperatorSteklovPc shared_ptr with

Parameters

pace
backend

operatorTrace()

template<typename self_type >

std::shared_ptr< OperatorTrace< self_type > > Feel::operatorTrace

(

std::shared_ptr< self_type > const &

domainspace

)

this function returns a OperatorTrace shared_ptr with

Parameters

traceSpace

References Feel::vf::trace().

opLagrangeP1_impl()

template<typename space_type >

std::shared_ptr< OperatorLagrangeP1< space_type > > Feel::opLagrangeP1_impl	(	std::shared_ptr< space_type > const &	Xh,
		typename OperatorLagrangeP1< space_type >::backend_ptrtype const &	backend,
		std::string	pathMeshLagP1,
		std::string	prefix,
		bool	rebuild,
		bool	parallel,
		size_type	meshUpdate
	)

Returns

the P1 Lagrange adaptor associated to the space Xh

oseen_options()

po::options_description Feel::oseen_options	(	std::string const &	prefix,
		OseenDefaults	defaults
	)

Returns

the command lines options of the oseen solver

P2ch()

template<typename Base1 , typename Base2 , typename MeshType >

P2ch_ptrtype< Base1, Base2, MeshType > Feel::P2ch	(	std::shared_ptr< MeshType >	mesh,
		std::vector< DofTableExtendedType >	dte = std::vector<DofTableExtendedType>( 2, DofTableExtendedType::DEFAULT )
	)

Given a mesh and polynomial order \(k\)(template argument), build a product function space of \([P_{k}]^d \times P_{l}]\) where $d$ is the dimension of the associated mesh.

This kind of function space can be used for Stokes problems where the first space is associated to the velocity and the second one to the pressure.

auto Xh = P2ch<2,1>( mesh );

partitionMesh()

template<typename MeshType >

std::unique_ptr< MeshPartitionSet< MeshType > > Feel::partitionMesh	(	std::shared_ptr< MeshType >	mesh,
		rank_type	nGlobalParts,
		std::vector< Range< MeshType, MESH_ELEMENTS > >	partitionByRange = std::vector<Range<MeshType,MESH_ELEMENTS>>(),
		json const &	partconfig = json()
	)

partition a mesh and provide a helper data struct navigate in the newly partitioned mesh

Returns

a std::unique_ptr to a MeshPartitionSet

References partitionMesh().

Referenced by partitionMesh().

Pch() [1/2]

template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>

Pch_ptrtype< MeshType, Order, T, Pts, Tag > Feel::Pch	(	std::shared_ptr< MeshType > const &	mesh,
		DofTableExtendedType	dte = DofTableExtendedType::DEFAULT
	)

Build a whole-mesh continuous scalar Lagrange function space.

The request uses FunctionSpaceReusePolicy::automatic. It therefore reuses a managed space when global reuse is enabled and otherwise preserves the historical always-new behavior.

Template Parameters

Order	polynomial order
T	coefficient value type
Pts	interpolation point-set family
MeshType	concrete mesh type
Tag	basis tag used to distinguish otherwise identical spaces

Parameters

mesh	mesh on which the function space is defined
dte	extended DOF-table mode

Returns

continuous scalar function space

Pch() [2/2]

template<int Order, typename T = double, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts>
requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )

auto Feel::Pch

(

Ts &&...

v

)

Build a whole-mesh continuous scalar Lagrange space using named arguments.

Supported arguments are the required _mesh and the optional _extended_doftable and _fspace_reuse_policy keywords. The reuse policy defaults to FunctionSpaceReusePolicy::automatic.

Template Parameters

Order	polynomial order
T	coefficient value type
Pts	interpolation point-set family
Tag	basis tag used to distinguish otherwise identical spaces
Ts	named-argument types

Parameters

v	named arguments controlling mesh, DOF table, and reuse policy

Returns

continuous scalar function space

Pchv() [1/2]

template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , typename T = double, int Tag = 0>

Pchv_ptrtype< MeshType, Order, Pts, T, Tag > Feel::Pchv	(	std::shared_ptr< MeshType > const &	mesh,
		DofTableExtendedType	dte = DofTableExtendedType::DEFAULT
	)

Build a whole-mesh continuous vector Lagrange function space.

The request uses FunctionSpaceReusePolicy::automatic. It therefore reuses a managed space when global reuse is enabled and otherwise preserves the historical always-new behavior.

Template Parameters

Order	polynomial order
Pts	interpolation point-set family
MeshType	concrete mesh type
T	coefficient value type
Tag	basis tag used to distinguish otherwise identical spaces

Parameters

mesh	mesh on which the function space is defined
dte	extended DOF-table mode

Returns

continuous vector function space

Pchv() [2/2]

template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename T = double, int Tag = 0, typename... Ts>
requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )

auto Feel::Pchv

(

Ts &&...

v

)

Build a whole-mesh continuous vector Lagrange space using named arguments.

Supported arguments are the required _mesh and the optional _extended_doftable and _fspace_reuse_policy keywords. The reuse policy defaults to FunctionSpaceReusePolicy::automatic.

Template Parameters

Order	polynomial order
Pts	interpolation point-set family
T	coefficient value type
Tag	basis tag used to distinguish otherwise identical spaces
Ts	named-argument types

Parameters

v	named arguments controlling mesh, DOF table, and reuse policy

Returns

continuous vector function space

Pdh() [1/2]

template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType >

Pdh_ptrtype< MeshType, Order, Pts > Feel::Pdh	(	std::shared_ptr< MeshType > const &	mesh,
		DofTableExtendedType	dte = DofTableExtendedType::DEFAULT
	)

Build a whole-mesh discontinuous scalar Lagrange function space.

The request uses FunctionSpaceReusePolicy::automatic. It therefore reuses a managed space when global reuse is enabled and otherwise preserves the historical always-new behavior.

Template Parameters

Order	polynomial order
Pts	interpolation point-set family
MeshType	concrete mesh type

Parameters

mesh	mesh on which the function space is defined
dte	extended DOF-table mode

Returns

discontinuous scalar function space

Pdh() [2/2]

template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename... Ts>
requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )

auto Feel::Pdh

(

Ts &&...

v

)

Build a whole-mesh discontinuous scalar Lagrange space using named arguments.

Supported arguments are the required _mesh and the optional _extended_doftable and _fspace_reuse_policy keywords. The reuse policy defaults to FunctionSpaceReusePolicy::automatic.

Template Parameters

Order	polynomial order
Pts	interpolation point-set family
Ts	named-argument types

Parameters

v	named arguments controlling mesh, DOF table, and reuse policy

Returns

discontinuous scalar function space

Pdhv() [1/2]

template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, typename MeshType , int Tag = 0>

Pdhv_ptrtype< MeshType, Order, Pts, Tag > Feel::Pdhv	(	std::shared_ptr< MeshType >	mesh,
		DofTableExtendedType	dte = DofTableExtendedType::DEFAULT
	)

Build a whole-mesh discontinuous vector Lagrange function space.

The request uses FunctionSpaceReusePolicy::automatic. It therefore reuses a managed space when global reuse is enabled and otherwise preserves the historical always-new behavior.

Template Parameters

Order	polynomial order
Pts	interpolation point-set family
MeshType	concrete mesh type
Tag	basis tag used to distinguish otherwise identical spaces

Parameters

mesh	mesh on which the function space is defined
dte	extended DOF-table mode

Returns

discontinuous vector function space

Pdhv() [2/2]

template<int Order, template< class, uint16_type, class > class Pts = PointSetFekete, int Tag = 0, typename... Ts>
requires ( sizeof...( Ts ) != 0 ) && ( NA::is_named_argument_v<Ts> && ... )

auto Feel::Pdhv

(

Ts &&...

v

)

Build a whole-mesh discontinuous vector Lagrange space using named arguments.

Supported arguments are the required _mesh and the optional _extended_doftable and _fspace_reuse_policy keywords. The reuse policy defaults to FunctionSpaceReusePolicy::automatic.

Template Parameters

Order	polynomial order
Pts	interpolation point-set family
Tag	basis tag used to distinguish otherwise identical spaces
Ts	named-argument types

Parameters

v	named arguments controlling mesh, DOF table, and reuse policy

Returns

discontinuous vector function space

points()

template<typename MeshType >

auto Feel::points	(	MeshType const &	mesh,
		entity_process_t	ept = entity_process_t::LOCAL_ONLY
	)

Returns

the range of iterators [begin,end] over the points of the mesh

Warning

this filter is not parallelized

prod()

template<typename ElementType >

ElementType Feel::prod	(	ElementType const &	v1,
		ElementType const &	v2,
		typename boost::enable_if< boost::is_base_of< FunctionSpaceBase::ElementBase, ElementType > >::type *	dummy = 0
	)

Computes the element wise product of two vectors and eventually in parallel.

Parameters

v1	vector (eventually distributed)
v2	vector (eventually distributed)

Returns

the element wise product of v1 and v2

product()

template<typename... SpaceList>

ProductSpaces< SpaceList... > Feel::product

(

SpaceList...

spaces

)

compile time product of function spaces

Parameters

spaces

expansion of arbitrary number of spaces

Returns

the compile time product

product2() [1/2]

template<typename T , typename... SpaceList>

ProductSpaces2< T, SpaceList... > Feel::product2	(	SpaceList...	spaces,
		std::shared_ptr< ProductSpace< T, true > > const &	ps
	)

mixed compile time and runtime product of function space

Parameters

spaces	expansion of arbitrary number of function spaces
ps	dynamic product of function spaces of the same type

Returns

the space product

product2() [2/2]

template<typename T , typename... SpaceList>

ProductSpaces2< T, SpaceList... > Feel::product2	(	std::shared_ptr< ProductSpace< T, true > > const &	ps,
		SpaceList...	spaces
	)

mixed compile time and runtime product of function space

Parameters

spaces	expansion of arbitrary number of function spaces
ps	dynamic product of function spaces of the same type

Returns

the space product

projector()

template<typename TDomainSpace , typename TDualImageSpace >

std::shared_ptr< Projector< TDomainSpace, TDualImageSpace > > Feel::projector	(	std::shared_ptr< TDomainSpace > const &	domainspace,
		std::shared_ptr< TDualImageSpace > const &	imagespace,
		typename Projector< TDomainSpace, TDualImageSpace >::backend_ptrtype const &	abackend = Backend<double>::build( soption( _name="backend" ) ),
		ProjectorType	proj_type = L2,
		double	epsilon = 0.01,
		double	gamma = 20,
		DirichletType	dirichlet_type = WEAK
	)

this function returns a Projector shared_ptr with

Parameters

domainSpace
imageSpace
backend

References elements(), and form1().

rank() [1/2]

template<typename C >

auto Feel::rank

(

C const &

c

)

Returns

the local MPI rank of the data structure c

Referenced by Feel::WorldComm::isActive(), and Feel::WorldComm::split().

rank() [2/2]

template<typename RangeT , std::enable_if_t< is_range_v< RangeT >, int > = 0>

rank_type Feel::rank

(

RangeT const &

range

)

get the rank of a range of entities

Template Parameters

S
ITERATOR
CONTAINER

Parameters

range

Returns

int the rank of the entity range

Examples

/data/cemosis/github-actions-runner/actions-runner-feelpp-1/_work/feelpp/feelpp/feelpp/feel/feelvf/concepts.hpp.

References range().

Referenced by Feel::Environment::startLogging().

real_dimension()

template<typename T >

constexpr int Feel::real_dimension ( T const &  t )

constexpr

Returns

real dimension of a type T

remesh_options()

Feel::po::options_description Feel::remesh_options

(

std::string const &

prefix

)

build command line options for remesh

Parameters

prefix

Returns

Feel::po::options_description

remeshImpl()

template<typename MeshT >

std::tuple< std::shared_ptr< MeshT >, int > Feel::remeshImpl	(	std::shared_ptr< MeshT > const &	r,
		std::string const &	metric_expr,
		std::vector< std::string > const &	req_elts,
		std::vector< std::string > const &	req_facets,
		std::shared_ptr< MeshT > const &	parent,
		nl::json const &	params
	)

given a metric and required elements/facets, remesh a mesh

Template Parameters

MeshT

type of the mesh to be remeshed

Parameters

r	mesh to be remeshed
metric_expr	metric expression
req_elts	required elements set
req_facets	required facets set
parent	parent mesh (possibly nullptr)

Returns

std::shared_ptr<MeshT>

sanitize()

std::vector< std::string > Feel::sanitize

(

std::vector< std::string > const &

s

)

trim a vector of strings removing all leading and trailing spaces and replace all special characters " ;:," inside the block by a _

Parameters

s	a vector of strings

subelements()

template<typename EltType >

fusion::result_of::accumulate< typenameEltType::functionspace_type::functionspace_vector_type, fusion::vector<>, Feel::detail::CreateElementVector< EltType > >::type Feel::subelements	(	EltType const &	e,
		std::vector< std::string > const &	n
	)

extract subelements from an element of a product of spaces

Parameters

e	an element of a product of spaces
n	a vector of string to name the sub elements

Returns

a vector of subelements

sum()

template<typename FE1 , class BinaryOperation , typename VectorType = typename Backend<typename functionspace_type<FE1>::value_type>::vector_type, typename ElemContType = VectorType>

Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType > Feel::sum	(	std::vector< Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType > > const &	v,
		BinaryOperation	op,
		Feel::vf::detail::LinearForm< FE1, VectorType, ElemContType >	init = Feel::vf::detail::LinearForm<FE1,VectorType,ElemContType>()
	)

sum of linear forms

Template Parameters

FE1
BinaryOperation
VectorUblas<typename	functionspace_type<FE1>::value_type>

Parameters

v	vector of linear forms
op	is the binary operation to apply
init	is the initial value

Returns

LinearForm<FE1,ElemContType>

support()

template<typename SpaceT >
requires is_functionspace_v<SpaceT>

constexpr SpaceT::template GetMeshSupport< typenameSpaceT::mesh_ptrtype, 0 >::ptrtype Feel::support ( std::shared_ptr< SpaceT > const &  X )

constexpr

Returns

the support of a function space

symmetricTensorComponentCount() [1/2]

template<SymmetricTensorFormatLike FormatT>

constexpr uint16_type Feel::symmetricTensorComponentCount ( uint16_type  n, FormatT const &  format  )

constexpr

Number of output components for a dimension/format pair.

Template Parameters

FormatT

Type satisfying SymmetricTensorFormatLike.

Parameters

n	Tensor dimension, currently 2 or 3.
format	Tensor format carrying order and scaling.

Returns

Number of output components implied by format.order.

Exceptions

std::invalid_argument

if n is unsupported.

symmetricTensorComponentCount() [2/2]

constexpr uint16_type Feel::symmetricTensorComponentCount ( uint16_type  n, SymmetricTensorOrder  order  )

constexpr

Number of output components for a dimension/order pair.

Compact orders return 3 components in 2D and 6 in 3D. Tensor-six exporter orders always return 6 components.

Parameters

n	Tensor dimension, currently 2 or 3.
order	Requested component order.

Returns

Number of output components.

Exceptions

std::invalid_argument

if n is unsupported.

symmetricTensorComponentLabel() [1/2]

template<SymmetricTensorFormatLike FormatT>

constexpr char const * Feel::symmetricTensorComponentLabel ( uint16_type  outputSlot, uint16_type  n, FormatT const &  format  )

constexpr

Component label for an output slot in a format object.

Template Parameters

FormatT

Type satisfying SymmetricTensorFormatLike.

Parameters

outputSlot	Slot in the requested output order.
n	Tensor dimension, currently 2 or 3.
format	Tensor format carrying order and scaling.

Returns

Static label such as "xx", "xy", or "zz".

Exceptions

std::invalid_argument

if n or outputSlot is out of range.

symmetricTensorComponentLabel() [2/2]

constexpr char const * Feel::symmetricTensorComponentLabel ( uint16_type  outputSlot, uint16_type  n, SymmetricTensorOrder  order  )

constexpr

Component label for an output slot.

Parameters

outputSlot	Slot in the requested output order.
n	Tensor dimension, currently 2 or 3.
order	Requested output order.

Returns

Static label such as "xx", "xy", or "zz".

Exceptions

std::invalid_argument

if n or outputSlot is out of range.

symmetricTensorComponentScale()

template<typename T = double>

constexpr T Feel::symmetricTensorComponentScale ( uint16_type  i, uint16_type  j, uint16_type  n, SymmetricTensorScaling  scaling  )

constexpr

Scaling factor for a tensor component.

Template Parameters

T	Floating-point-like return type.

Parameters

i	Row component index.
j	Column component index.
n	Tensor dimension, currently 2 or 3.
scaling	Requested shear scaling convention.

Returns

Scaling factor for component (i,j).

Exceptions

std::invalid_argument

if n, i, or j is out of range.

symmetricTensorInvalidSlot()

constexpr uint16_type Feel::symmetricTensorInvalidSlot ( )

constexpr

Sentinel value for unused entries in fixed-size mapping arrays.

Returns

The maximum value of uint16_type, never a valid output slot.

symmetricTensorIsShearComponent()

constexpr bool Feel::symmetricTensorIsShearComponent ( uint16_type  i, uint16_type  j, uint16_type  n  )

constexpr

Check whether a tensor component is off-diagonal.

Parameters

i	Row component index.
j	Column component index.
n	Tensor dimension, currently 2 or 3.

Returns

true when i != j.

Exceptions

std::invalid_argument

if n, i, or j is out of range.

symmetricTensorIsShearStorageSlot()

constexpr bool Feel::symmetricTensorIsShearStorageSlot ( uint16_type  storageSlot, uint16_type  n  )

constexpr

Check whether a compact storage slot represents an off-diagonal component.

Parameters

storageSlot	Compact storage slot.
n	Tensor dimension, currently 2 or 3.

Returns

true when the slot maps to an off-diagonal component.

Exceptions

std::invalid_argument

if n or storageSlot is out of range.

symmetricTensorIsTensor6Order()

constexpr bool Feel::symmetricTensorIsTensor6Order ( SymmetricTensorOrder  order )

constexpr

Check whether an order describes a six-component exporter tuple.

Parameters

order

Symmetric tensor order.

Returns

true for VTK, Ensight, and XDMF tensor-six orders.

symmetricTensorOrderName()

constexpr char const * Feel::symmetricTensorOrderName ( SymmetricTensorOrder  order )

constexpr

Stable metadata name for a symmetric tensor output order.

Parameters

order

Symmetric tensor order.

Returns

String literal matching the enum value name.

Exceptions

std::invalid_argument

if order is unsupported.

symmetricTensorOutputSlot() [1/2]

template<SymmetricTensorFormatLike FormatT>

constexpr uint16_type Feel::symmetricTensorOutputSlot ( uint16_type  i, uint16_type  j, uint16_type  n, FormatT const &  format  )

constexpr

Map a symmetric tensor component to an output slot for a format object.

Template Parameters

FormatT

Type satisfying SymmetricTensorFormatLike.

Parameters

i	Row component index.
j	Column component index.
n	Tensor dimension, currently 2 or 3.
format	Tensor format carrying order and scaling.

Returns

Output slot for component (i,j) using format.order.

Exceptions

std::invalid_argument

if n, i, or j is out of range.

symmetricTensorOutputSlot() [2/2]

constexpr uint16_type Feel::symmetricTensorOutputSlot ( uint16_type  i, uint16_type  j, uint16_type  n, SymmetricTensorOrder  order  )

constexpr

Map a symmetric tensor component to an output slot.

Parameters

i	Row component index.
j	Column component index.
n	Tensor dimension, currently 2 or 3.
order	Requested output order.

Returns

Output slot for component (i,j).

Exceptions

std::invalid_argument

if n, i, or j is out of range.

symmetricTensorOutputSlotFromStorage() [1/2]

template<SymmetricTensorFormatLike FormatT>

constexpr uint16_type Feel::symmetricTensorOutputSlotFromStorage ( uint16_type  storageSlot, uint16_type  n, FormatT const &  format  )

constexpr

Map a compact storage slot to an output slot for a format object.

Template Parameters

FormatT

Type satisfying SymmetricTensorFormatLike.

Parameters

storageSlot	Compact storage slot in the legacy field storage order.
n	Tensor dimension, currently 2 or 3.
format	Tensor format carrying order and scaling.

Returns

Output slot for storageSlot using format.order.

Exceptions

std::invalid_argument

if n or storageSlot is out of range.

symmetricTensorOutputSlotFromStorage() [2/2]

constexpr uint16_type Feel::symmetricTensorOutputSlotFromStorage ( uint16_type  storageSlot, uint16_type  n, SymmetricTensorOrder  order  )

constexpr

Map a compact storage slot to an output slot.

For compact output orders, the output slot is in a compact vector. For tensor-six exporter orders, the output slot is in the six-component tuple.

Parameters

storageSlot	Compact storage slot in the legacy field storage order.
n	Tensor dimension, currently 2 or 3.
order	Requested output order.

Returns

Output slot for storageSlot.

Exceptions

std::invalid_argument

if n or storageSlot is out of range.

symmetricTensorScale()

template<typename T = double>

constexpr T Feel::symmetricTensorScale ( bool  isShear, SymmetricTensorScaling  scaling  )

constexpr

Scaling factor for a diagonal or off-diagonal component.

Template Parameters

T	Floating-point-like return type.

Parameters

isShear	Whether the component is off-diagonal.
scaling	Requested shear scaling convention.

Returns

1 for tensor scaling and all diagonal components, 2 for engineering shear, and sqrt(2) for Mandel shear.

Exceptions

std::invalid_argument

if scaling is unsupported.

symmetricTensorScalingName()

constexpr char const * Feel::symmetricTensorScalingName ( SymmetricTensorScaling  scaling )

constexpr

Stable metadata name for a symmetric tensor scaling convention.

Parameters

scaling

Symmetric tensor scaling convention.

Returns

String literal matching the enum value name.

Exceptions

std::invalid_argument

if scaling is unsupported.

symmetricTensorStorageComponent()

constexpr std::array< uint16_type, 2 > Feel::symmetricTensorStorageComponent ( uint16_type  storageSlot, uint16_type  n  )

constexpr

Component indices represented by a compact packed-storage slot.

Parameters

storageSlot	Compact storage slot.
n	Tensor dimension, currently 2 or 3.

Returns

{i,j} with i <= j.

Exceptions

std::invalid_argument

if n or storageSlot is out of range.

symmetricTensorStorageComponentCount()

constexpr uint16_type Feel::symmetricTensorStorageComponentCount ( uint16_type  n )

constexpr

Number of compact packed-storage components for a symmetric tensor.

Parameters

n	Tensor dimension, currently 2 or 3.

Returns

3 in 2D and 6 in 3D.

Exceptions

std::invalid_argument

if n is unsupported.

symmetricTensorStorageIndex()

constexpr uint16_type Feel::symmetricTensorStorageIndex ( uint16_type  i, uint16_type  j, uint16_type  n  )

constexpr

Legacy compact packed-storage slot for a symmetric tensor component.

This is the public field-level wrapper around Feel::detail::symmetricIndex. It preserves the current storage order: 2D xx,xy,yy and 3D xx,xy,xz,yy,yz,zz.

Parameters

i	Row component index.
j	Column component index.
n	Tensor dimension, currently 2 or 3.

Returns

Compact packed-storage slot.

Exceptions

std::invalid_argument

if n, i, or j is out of range.

symmetricTensorStorageScale()

template<typename T = double>

constexpr T Feel::symmetricTensorStorageScale ( uint16_type  storageSlot, uint16_type  n, SymmetricTensorScaling  scaling  )

constexpr

Scaling factor for a compact storage slot.

Template Parameters

T	Floating-point-like return type.

Parameters

storageSlot	Compact storage slot in the legacy field storage order.
n	Tensor dimension, currently 2 or 3.
scaling	Requested shear scaling convention.

Returns

Scaling factor for the component represented by storageSlot.

Exceptions

std::invalid_argument

if n or storageSlot is out of range.

symmetricTensorStorageToOutputMap()

constexpr std::array< uint16_type, 6 > Feel::symmetricTensorStorageToOutputMap ( uint16_type  n, SymmetricTensorOrder  order  )

constexpr

Fixed-size compact-storage-to-output-slot map.

The first symmetricTensorStorageComponentCount(n) entries are valid. Any remaining entries are filled with symmetricTensorInvalidSlot().

Parameters

n	Tensor dimension, currently 2 or 3.
order	Requested output order.

Returns

Six-entry mapping array from compact storage slot to output slot.

Exceptions

std::invalid_argument

if n is unsupported.

symmetricTensorSupportedDimension()

constexpr bool Feel::symmetricTensorSupportedDimension ( uint16_type  n )

constexpr

Check whether a tensor dimension is supported by these helpers.

Parameters

n	Tensor dimension.

Returns

true for dimensions 2 and 3, false otherwise.

THch()

template<int Order, typename MeshType >

THch_ptrtype< Order, MeshType > Feel::THch	(	std::shared_ptr< MeshType >	mesh,
		std::vector< DofTableExtendedType >	dte = std::vector<DofTableExtendedType>( 2,DofTableExtendedType::DEFAULT )
	)

Given a mesh and polynomial order \(k\)(template argument), build a product function space of \([P_{k+1}]^d \times P_{k}]\) where $d$ is the dimension of the associated mesh.

This kind of function space can be used for Stokes problems where the first space is associated to the velocity and the second one to the pressure.

auto Xh = THch<2>( mesh );

throw_with_trace()

template<class E >

void Feel::throw_with_trace

(

const E &

e

)

helper class for throwing any exception with stacktrace:

Template Parameters

E	exception type

Parameters

e	exception thown

type_space_t()

template<typename T >

constexpr hana::integral_constant< int,(decay_type< T >::nSpaces==1)?1:2 > Feel::type_space_t ( T &&  t )

constexpr

Returns

single_space_t if the space is not a cartesian product, multiple_space_t otherwise

type_spaces_t()

template<typename T1 , typename T2 >

constexpr hana::integral_constant< int,(decay_type< T1 >::nSpaces==1 &&decay_type< T2 >::nSpaces==1)?1:2 > Feel::type_spaces_t ( T1 &&  t1, T2 &&  t2  )

constexpr

Returns

single_spaces_t if the spaces aren't cartesian products, multiple_space_t otherwise

unwrap_ptr()

template<typename C >

unwrap_ptr_t< C > const & Feel::unwrap_ptr

(

C const &

c

)

Returns

the c++ objet pointed by c++ pointer or shared_ptr or same object otherwise

Referenced by Feel::Bdf< SpaceType >::deepCopy(), expansion(), and hMeasures().

Variable Documentation

dim_t

template<int Dmin = 2, int Dmax = 3>

auto Feel::dim_t = hana::unpack( hana::make_range( hana::int_c<Dmin>, hana::int_c<Dmax + 1> ), hana::make_tuple )

Geometric dimension identifier collection generator.

Template Parameters

Dmin	minimal geometric dimension
Dmax	maximal geometric dimension

EXTRACTION_KEEP_ALL_IDS

const size_type Feel::EXTRACTION_KEEP_ALL_IDS

Initial value:

= ( EXTRACTION_KEEP_POINTS_IDS |
                                            EXTRACTION_KEEP_EDGES_IDS |
                                            EXTRACTION_KEEP_FACES_IDS |
                                            EXTRACTION_KEEP_VOLUMES_IDS )

is_geoelement_v

template<typename... T>

constexpr bool Feel::is_geoelement_v = is_geoelement<T...>::value

constexpr

Helper variable template.

Returns

true is T is a GeoElement<n>D at compilation time, false otherwise

is_mesh_structured_v

template<typename MeshT >

constexpr bool Feel::is_mesh_structured_v = is_mesh_structured<MeshT>::value

constexpr

boolean to detect a MeshStructured mesh

Template Parameters

MeshT

mesh type

is_reference_convex_v

template<typename... T>

constexpr bool Feel::is_reference_convex_v = is_reference_convex<T...>::value

constexpr

Helper variable template.

Returns

true is T is a Reference convex at compilation time, false otherwise

order_t

template<int Omin = 0, int Omax = FEELPP_INSTANTIATION_ORDER_MAX>

auto Feel::order_t = hana::unpack( hana::make_range( hana::int_c<Omin>, hana::int_c<Omax + 1> ), hana::make_tuple )

Polynomial order identifier collection generator.

Template Parameters

Omin	minimal polynomial order
Omax	maximal polynomial order

Pc_t

template<int Dmin = 2, int Dmax = 3, int Omin = 1, int Omax = FEELPP_INSTANTIATION_ORDER_MAX>

auto Feel::Pc_t

Initial value:

= hana::transform( hana::cartesian_product( hana::make_tuple( dim_t<Dmin, Dmax>, order_t<Omin, Omax> ) ), []( auto x )
                              { return hana::append( x, fmt::format( [] {   struct FMT_COMPILE_STRING : fmt::detail::compiled_string { using char_type [[maybe_unused]] = fmt::remove_cvref_t<decltype("P{}"[0])>; [[maybe_unused]] constexpr explicit operator fmt::basic_string_view<char_type>() const { return fmt::detail_exported::compile_string_to_view<char_type>("P{}"); } }; return FMT_COMPILE_STRING(); }(), std::decay_t<decltype( hana::at_c<1>( x ) )>::value ) ); } )

Continuous Lagrange Function space identifier collection generator.

Template Parameters

Dmin	minimal geometric dimension
Dmax	maximal geometric dimension
Omin	minimal polynomial order
Omax	maximal polynomial order

Pd_t

template<int Dmin = 2, int Dmax = 3, int Omin = 1, int Omax = FEELPP_INSTANTIATION_ORDER_MAX>

auto Feel::Pd_t

Initial value:

= hana::transform( hana::cartesian_product( hana::make_tuple( dim_t<Dmin, Dmax>, order_t<Omin, Omax> ) ), []( auto x )
                              { return hana::append( x, fmt::format( [] {   struct FMT_COMPILE_STRING : fmt::detail::compiled_string { using char_type [[maybe_unused]] = fmt::remove_cvref_t<decltype("Pd{}"[0])>; [[maybe_unused]] constexpr explicit operator fmt::basic_string_view<char_type>() const { return fmt::detail_exported::compile_string_to_view<char_type>("Pd{}"); } }; return FMT_COMPILE_STRING(); }(), std::decay_t<decltype( hana::at_c<1>( x ) )>::value ) ); } )

Discontinuous Lagrange Function space identifier collection generator.

Template Parameters

Dmin	minimal geometric dimension
Dmax	maximal geometric dimension
Omin	minimal polynomial order
Omax	maximal polynomial order