MoFEM Namespace Reference

implementation of Data Operators for Forces and Sources More...

Classes
struct	AccelerationCubitBcData
	Definition of the acceleration bc data structure. More...
struct	BaseFEDofEntity
	keeps basic information about indexed dofs for the finite element More...
struct	BaseFunction
	Base class if inherited used to calculate base functions. More...
struct	BaseFunctionCtx
	Base class used to exchange data between element data structures and class calculating base functions. More...
struct	BasicEntity
	this struct keeps basic methods for moab entity More...
struct	BasicEntityData
	Basic data. like access to moab interface and basic tag handlers. More...
struct	BasicMethod
	Data structure to exchange data between mofem and User Loop Methods.It allows to exchange data between MoFEM and user functions. It stores information about multi-indices. More...
struct	BitFEId_mi_tag
struct	BitFieldId_mi_tag
struct	BitFieldId_space_mi_tag
struct	BitLevelCoupler
	Interface set parent for vertices, edges, triangles and tetrahedrons. More...
struct	BitProblemId_mi_tag
struct	Block_BodyForces
	Body force data structure. More...
struct	BlockData
struct	BlockSetAttributes
	Arbitrary block attributes data structure. More...
struct	CfgCubitBcData
	Definition of the cfd_bc data structure. More...
struct	ComposedProblemsData
struct	Composite_Cubit_msId_And_MeshSetType_mi_tag
struct	Composite_Ent_and_ShortId_mi_tag
struct	Composite_EntType_and_ParentEntType_mi_tag
struct	Composite_EntType_and_Space_mi_tag
struct	Composite_mi_tag
struct	Composite_Name_And_Ent_And_EntDofIdx_mi_tag
struct	Composite_Name_And_Ent_mi_tag
struct	Composite_Name_And_HasLocalIdx_mi_tag
struct	Composite_Name_And_Part_mi_tag
struct	Composite_Name_And_Type_mi_tag
struct	Composite_Name_Ent_And_CoeffIdx_mi_tag
struct	Composite_Name_Ent_And_Part_mi_tag
struct	Composite_Name_Ent_Order_And_CoeffIdx_mi_tag
struct	Composite_Name_Part_And_CoeffIdx_mi_tag
struct	Composite_Name_Type_And_Side_Number_mi_tag
struct	Composite_ParentEnt_And_BitsOfRefinedEdges_mi_tag
struct	Composite_ParentEnt_And_EntType_mi_tag
struct	Composite_Part_And_Ent_mi_tag
struct	Composite_Part_And_Order_mi_tag
struct	Composite_SeriesID_And_Step_mi_tag
struct	Composite_SeriesName_And_Step_mi_tag
struct	Composite_SeriesName_And_Time_mi_tag
struct	Composite_Unique_mi_tag
struct	CoordSys
	Structure for Coordinate system of two-point tensorScientific computing applications deal in physical quantities expressed as tensors: scalars such as temperature, vectors such as velocity, and second-order tensors such as stress. In practice, these are formally tensor fields: a tensor field assigns a tensor to each point in a mathematical space (typically a Euclidean space or manifold). More...
struct	CoordSysName_mi_tag
struct	CoordSystemsManager
struct	Core
	Core (interface) classThis is the implementation of abstract MoFEM::Interface class. Similarly to the convention used in MoAB, we use small letters to name function of purely abstract classes. This is an exception used only here. For more details about naming functions see Coding practice. More...
struct	CreateRowComressedADJMatrix
	Create compressed matrix. More...
struct	CubitMeshSets
	this struct keeps basic methods for moab meshset about material and boundary conditions More...
struct	CubitMeshSets_change_add_bit_to_cubit_bc_type
	change meshset type More...
struct	CubitMeshSets_change_attributes
struct	CubitMeshSets_change_attributes_data_structure
struct	CubitMeshSets_change_bc_data_structure
struct	CubitMeshSets_change_name
	change meshset name More...
struct	CubitMeshSets_mask_meshset_mi_tag
struct	CubitMeshSets_mi_tag
	MultiIndex Tag for field id. More...
struct	CubitMeshSets_name
struct	CutMeshInterface
	Interface to cut meshes. More...
struct	DataForcesAndSurcesCore
	data structure for finite element entityIt keeps that about indices of degrees of freedom, dofs data, base functions functions, entity side number, type of entities, approximation order, etc. More...
struct	DataOperator
	base operator to do operations at Gauss Pt. level More...
struct	DefaultElementAdjacency
	default adjacency map More...
struct	DerivedDataForcesAndSurcesCore
	this class derive data form other data structure More...
struct	DisplacementCubitBcData
	Definition of the displacement bc data structure. More...
struct	DMCtx
	PETSc Discrete Manager data structure. More...
struct	Dof_shared_ptr_change
struct	DofEntity
	keeps information about DOF on the entity More...
struct	DofEntity_active_change
struct	EdgeElementForcesAndSurcesCore
	Edge finite elementUser is implementing own operator at Gauss points level, by own object derived from EdgeElementForcesAndSurcesCoreL::UserDataOperator. Arbitrary number of operator added pushing objects to rowOpPtrVector and rowColOpPtrVector. More...
struct	EdgePolynomialBase
	Calculate base functions on tetrahedral. More...
struct	Ent_Ent_mi_tag
struct	Ent_FiniteElement_mi_tag
struct	Ent_mi_tag
struct	Ent_Owner_mi_tag
struct	Ent_ParallelStatus
struct	EntFiniteElement
	Finite element data for entitiy. More...
struct	Entity_update_part_proc
struct	Entity_update_pcomm_data
struct	EntMethod
	Data structure to exchange data between mofem and User Loop Methods on entities.It allows to exchange data between MoFEM and user functions. It stores information about multi-indices. More...
struct	EntPolynomialBaseCtx
	Class used to pass element data to calculate base functions on tet,triangle,edge. More...
struct	EntType_mi_tag
struct	EqBit
struct	FaceElementForcesAndSourcesCore
	Face finite elementUser is implementing own operator at Gauss point level, by own object derived from FaceElementForcesAndSourcesCoreL::UserDataOperator. Arbitrary number of operator added pushing objects to OpPtrVector. More...
struct	FatPrismElementForcesAndSurcesCore
	FatPrism finite elementUser is implementing own operator at Gauss points level, by own object derived from FatPrismElementForcesAndSurcesCoreL::UserDataOperator. Arbitrary number of operator added pushing objects to rowOpPtrVector and rowColOpPtrVector. More...
struct	FatPrismPolynomialBase
	Calculate base functions on tetrahedralFIXME: Need moab and mofem finite element structure to work (that not perfect) More...
struct	FatPrismPolynomialBaseCtx
	Class used to pass element data to calculate base functions on fat prism. More...
struct	FEDofEntity
	keeps information about indexed dofs for the finite element More...
struct	FEEnt_mi_tag
struct	FEMethod
	structure for User Loop Methods on finite elementsIt can be used to calculate stiffness matrices, residuals, load vectors etc. It is low level class however in some class users looking for speed and efficiency, can use it directly. More...
struct	FENumeredDofEntity
	keeps information about indexed dofs for the finite element More...
struct	Field
	Provide data structure for (tensor) field approximation.The Field is intended to provide support for fields, with a strong bias towards supporting first and best the capabilities required for scientific computing applications. Since we work with discrete spaces, data structure has to carry information about type of approximation space, its regularity. More...
struct	FieldChangeCoordinateSystem
	Set field coordinate system. More...
struct	FieldEntity
	Struct keeps handle to entity in the field. More...
struct	FieldEntity_change_order
	structure to chane FieldEntity order More...
struct	FieldEntityEntFiniteElementAdjacencyMap
	FieldEntityEntFiniteElementAdjacencyMap of mofem finite element and entities. More...
struct	FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat
struct	FieldName_mi_tag
	MultiIndex Tag for field name. More...
struct	FieldSeries
	Structure for recording (time) series. More...
struct	FieldSeriesStep
	Structure for keeping time and step. More...
struct	FiniteElement
	user adjacency function table More...
struct	FiniteElement_change_bit_add
	Add field to data. More...
struct	FiniteElement_change_bit_off
	Unset field from data. More...
struct	FiniteElement_col_change_bit_add
	Add field to column. More...
struct	FiniteElement_col_change_bit_off
	Unset field from column. More...
struct	FiniteElement_Meshset_mi_tag
struct	FiniteElement_name_mi_tag
struct	FiniteElement_row_change_bit_add
	Add field to row. More...
struct	FiniteElement_row_change_bit_off
	Unset field from row. More...
struct	FlatPrismElementForcesAndSurcesCore
	FlatPrism finite elementUser is implementing own operator at Gauss points level, by own object derived from FlatPrismElementForcesAndSurcesCoreL::UserDataOperator. Arbitrary number of operator added pushing objects to rowOpPtrVector and rowColOpPtrVector. More...
struct	FlatPrismPolynomialBase
	Calculate base functions on tetrahedralFIXME: Need moab and mofem finite element structure to work (that not perfect) More...
struct	FlatPrismPolynomialBaseCtx
	Class used to pass element data to calculate base functions on flat prism. More...
struct	ForceCubitBcData
	Definition of the force bc data structure. More...
struct	ForcesAndSurcesCore
	structure to get information form mofem into DataForcesAndSurcesCore More...
struct	GenericAttributeData
	Generic attribute data structure. More...
struct	GenericCubitBcData
	Generic bc data structure. More...
struct	HashBit
struct	HeatFluxCubitBcData
	Definition of the heat flux bc data structure. More...
struct	Idx_mi_tag
struct	Interface
	InterfaceThis interface is used by user to: More...
struct	interface_DofEntity
	Interface to DofEntity. More...
struct	interface_EntFiniteElement
	interface to EntFiniteElement More...
struct	interface_Field
	Pointer interface for MoFEM::Field. More...
struct	interface_FieldEntity
	Interface to FieldEntityinterface to FieldEntity. More...
struct	interface_FieldSeries
struct	interface_FiniteElement
	Inetface for FE. More...
struct	interface_NumeredDofEntity
	interface to NumeredDofEntity More...
struct	interface_NumeredEntFiniteElement
	interface for NumeredEntFiniteElement More...
struct	interface_RefElement
	intrface to RefElement More...
struct	interface_RefEntity
	interface to RefEntity More...
struct	JacobiPolynomial
	Calculating Legendre base functions. More...
struct	JacobiPolynomialCtx
	Class used to give arguments to Legendre base functions. More...
struct	KernelLobattoPolynomial
	Calculating Lobatto base functions. More...
struct	KernelLobattoPolynomialCtx
	Class used to give arguments to Kernel Lobatto base functions. More...
struct	KeyFromKey
struct	KspCtx
	Interface for linear (KSP) solver. More...
struct	KspMethod
	data structure for ksp (linear solver) contextStruture stores context data which are set in functions run by PETSc SNES functions. More...
struct	LegendrePolynomial
	Calculating Legendre base functions. More...
struct	LegendrePolynomialCtx
	Class used to give arguments to Legendre base functions. More...
struct	LobattoPolynomial
	Calculating Lobatto base functions. More...
struct	LobattoPolynomialCtx
	Class used to give arguments to Lobatto base functions. More...
struct	LtBit
struct	Mat_Elastic
	Elastic material data structure. More...
struct	Mat_Elastic_EberleinHolzapfel1
	Mat_Elastic with Fibres. More...
struct	Mat_Elastic_TransIso
	Transverse Isotropic material data structure. More...
struct	Mat_Interf
	Linear interface data structure. More...
struct	Mat_Moisture
	moisture transport material data structure More...
struct	Mat_Thermal
	Thermal material data structure. More...
struct	MedInterface
	Interface for load MED files. More...
struct	MeshRefinement
	Mesh refinement interface. More...
struct	Meshset_mi_tag
struct	MeshsetsManager
	Interface for managing meshsets containing materials and boundary conditions. More...
struct	MoFEMException
struct	MOFEMuuid
	MoFEM interface unique ID. More...
struct	NodeMergerInterface
	merge node from two bit levels More...
struct	NumeredDofEntity
	keeps information about indexed dofs for the problem More...
struct	NumeredDofEntity_local_idx_change
struct	NumeredDofEntity_mofem_index_change
struct	NumeredDofEntity_mofem_part_and_all_index_change
struct	NumeredDofEntity_part_change
struct	NumeredEntFiniteElement
	Partitioned (Indexed) Finite Element in Problem. More...
struct	NumeredEntFiniteElement_change_part
	Change finite element part. More...
struct	OpCalculateInvJacForFace
	Calculate inverse of jacobian for face element. More...
struct	OpCalculateInvJacForFatPrism
	Calculate inverse of jacobian for face element. More...
struct	OpCalculateInvJacForFlatPrism
	Calculate inverse of jacobian for face element. More...
struct	OpCalculateScalarFieldGradient
	Get field gradients at integration pts for scalar filed rank 0, i.e. vector field. More...
struct	OpCalculateScalarFieldGradient_General
	Evaluate field gradient values for scalar field, i.e. gradient is tensor rank 1 (vector) More...
struct	OpCalculateScalarFieldGradient_General< Tensor_Dim, double, ublas::row_major, ublas::unbounded_array< double > >
	Evaluate field gradient values for scalar field, i.e. gradient is tensor rank 1 (vector), specialization. More...
struct	OpCalculateScalarFieldValues
	Get value at integration points for scalar field. More...
struct	OpCalculateScalarFieldValues_General
	Calculate field values for tenor field rank 0, i.e. scalar field. More...
struct	OpCalculateTensor2FieldValues_General
	Calculate field values for tenor field rank 2. More...
struct	OpCalculateVectorFieldGradient
	Get field gradients at integration pts for scalar filed rank 0, i.e. vector field. More...
struct	OpCalculateVectorFieldGradient_General
	Evaluate field gradient values for vector field, i.e. gradient is tensor rank 2. More...
struct	OpCalculateVectorFieldGradient_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, ublas::unbounded_array< double > >
struct	OpCalculateVectorFieldValues
	Get values at integration pts for tensor filed rank 1, i.e. vector field. More...
struct	OpCalculateVectorFieldValues_General
	Calculate field values for tenor field rank 1, i.e. vector field. More...
struct	OpCalculateVectorFieldValues_General< Tensor_Dim, double, ublas::row_major, ublas::unbounded_array< double > >
	Calculate field values (template specialization) for tensor field rank 1, i.e. vector field. More...
struct	OpGetCoordsAndNormalsOnFace
	Calculate normals at Gauss points of triangle element. More...
struct	OpGetCoordsAndNormalsOnPrism
	calculate normals at Gauss points of triangle element More...
struct	OpGetDataAndGradient
	Get field values and gradients at Gauss points. More...
struct	OpGetHoTangentOnEdge
	Calculate tangent vector on edge form HO geometry approximation. More...
struct	OpSetContravariantPiolaTransform
	apply contravariant (Piola) transfer to Hdiv space More...
struct	OpSetContravariantPiolaTransoformOnTriangle
	transform Hdiv base fluxes from reference element to physical triangle More...
struct	OpSetCovariantPiolaTransform
	apply covariant transfer to Hcurl space More...
struct	OpSetCovariantPiolaTransoformOnEdge
	transform Hcurl base fluxes from reference element to physical edge More...
struct	OpSetCovariantPiolaTransoformOnTriangle
	transform Hcurl base fluxes from reference element to physical triangle More...
struct	OpSetHoContravariantPiolaTransform
	Apply contravariant (Piola) transfer to Hdiv space for HO geometr. More...
struct	OpSetHoCovariantPiolaTransform
	Apply covariant (Piola) transfer to Hcurl space for HO geometry. More...
struct	OpSetHoInvJacH1
	transform local reference derivatives of shape function to global derivatives if higher order geometry is given More...
struct	OpSetHoInvJacHdivAndHcurl
	transform local reference derivatives of shape function to global derivatives if higher order geometry is given More...
struct	OpSetInvJacH1
	Transform local reference derivatives of shape function to global derivatives. More...
struct	OpSetInvJacH1ForFace
	Transform local reference derivatives of shape functions to global derivatives. More...
struct	OpSetInvJacH1ForFatPrism
	Transform local reference derivatives of shape functions to global derivatives. More...
struct	OpSetInvJacH1ForFlatPrism
	Transform local reference derivatives of shape functions to global derivatives. More...
struct	OpSetInvJacHcurlFace
	brief Transform local reference derivatives of shape function to global derivatives for face More...
struct	OpSetInvJacHdivAndHcurl
	brief Transform local reference derivatives of shape function to global derivatives More...
struct	Order_mi_tag
	MultiIndex Tag for field order. More...
struct	ParentEntType_mi_tag
struct	Part_mi_tag
struct	PetscGlobalIdx_mi_tag
struct	PetscLocalIdx_mi_tag
struct	PressureCubitBcData
	Definition of the pressure bc data structure. More...
struct	PrismInterface
	Make interface on given faces and create flat prism in that space. More...
struct	PrismsFromSurfaceInterface
	merge node from two bit levels More...
struct	Problem
	keeps basic data about problemThis is low level structure with information about problem, what elements compose problem and what dofs are on rows and columns. More...
struct	Problem_mi_tag
struct	ProblemChangeRefLevelBitAdd
	add ref level to problem More...
struct	ProblemChangeRefLevelBitDofMaskSet
	set prof dof bit ref mask More...
struct	ProblemChangeRefLevelBitSet
	set ref level to problem More...
struct	ProblemClearNumeredFiniteElementsChange
	clear problem finite elements More...
struct	ProblemFiniteElementChangeBitAdd
	add finite element to problem More...
struct	ProblemFiniteElementChangeBitUnSet
	remove finite element from problem More...
struct	ProblemsManager
	Problem manager is used to build and partition problems . More...
struct	ProblemZeroNbColsChange
	zero nb. of dofs in col More...
struct	ProblemZeroNbRowsChange
	zero nb. of dofs in row More...
struct	Proc_mi_tag
struct	Projection10NodeCoordsOnField
	Projection of edge entities with one mid-node on hierarchical basis. More...
struct	ProjectionFieldOn10NodeTet
struct	RefElement
	keeps data about abstract refined finite element More...
struct	RefElement_change_parent
	change parentUsing this function with care. Some other multi-indices can deponent on this. More...
struct	RefElement_EDGE
	keeps data about abstract EDGE finite element More...
struct	RefElement_MESHSET
	keeps data about abstract MESHSET finite element More...
struct	RefElement_PRISM
	keeps data about abstract PRISM finite element More...
struct	RefElement_TET
	keeps data about abstract TET finite element More...
struct	RefElement_TRI
	keeps data about abstract TRI finite element More...
struct	RefElement_VERTEX
	keeps data about abstract VERTEX finite element More...
struct	RefEntity
	Struct keeps handle to refined handle. More...
struct	RefEntity_change_add_bit
	ref mofem entity, change bit More...
struct	RefEntity_change_and_bit
	ref mofem entity, change bit More...
struct	RefEntity_change_left_shift
	ref mofem entity, left shift More...
struct	RefEntity_change_parent
	change parentUse this function with care. Some other multi-indices can deponent on this. More...
struct	RefEntity_change_remove_parent
	ref mofem entity, remove parent More...
struct	RefEntity_change_right_shift
	ref mofem entity, right shift More...
struct	RefEntity_change_set_bit
	ref mofem entity, change bit More...
struct	RefEntity_change_set_nth_bit
	ref mofem entity, change bit More...
struct	RefEntity_change_xor_bit
	ref mofem entity, change bit More...
struct	SeriesID_mi_tag
struct	SeriesName_mi_tag
struct	SeriesRecorder
struct	SideNumber_mi_tag
struct	Simple
	Simple interface for fast problem set-up. More...
struct	SnesCtx
	Interface for nonlinear (SNES) solver. More...
struct	SnesMethod
	data structure for snes (nonlinear solver) contextStructure stores context data which are set in functions run by PETSc SNES functions. More...
struct	TemperatureCubitBcData
	Definition of the temperature bc data structure. More...
struct	TetGenInterface
	use TetGen to generate mesh More...
struct	TetPolynomialBase
	Calculate base functions on tetrahedral. More...
struct	TriPolynomialBase
	Calculate base functions on triangle. More...
struct	TsCtx
	Interface for Time Stepping (TS) solver. More...
struct	TSMethod
	data structure for TS (time stepping) contextStructure stores context data which are set in functions run by PETSc Time Stepping functions. More...
struct	unbounded_array< double >>
struct	Unique_Ent_mi_tag
struct	Unique_FiniteElement_mi_tag
struct	Unique_mi_tag
struct	UnknownInterface
	base class for all interface classes More...
struct	VelocityCubitBcData
	Definition of the velocity bc data structure. More...
struct	Version
struct	VertexElementForcesAndSourcesCore
	Vertex finite elementUser is implementing own operator at Gauss points level, by own object derived from VertexElementForcesAndSourcesCoreL::UserDataOperator. Arbitrary number of operator added pushing objects to rowOpPtrVector and rowColOpPtrVector. More...
struct	VolumeElementForcesAndSourcesCore
	Volume finite elementUser is implementing own operator at Gauss point level, by class derived from VolumeElementForcesAndSourcesCore::UserDataOperator. Arbitrary number of operator can be added by pushing objects to OpPtrVector. More...
struct	VolumeElementForcesAndSourcesCoreOnSide
	Volume element used to integrate on skeleton. More...

Typedefs
typedef ErrorCode	MoABErrorCode
typedef int	DofIdx
	Index of DOF. More...
typedef int	FEIdx
	Index of the element. More...
typedef int	EntIdx
	Index of DOF on the entity. More...
typedef int	EntPart
	Partition owning entity. More...
typedef double	FieldData
	Field data type. More...
typedef int	ApproximationOrder
	Approximation on the entity. More...
typedef int	FieldCoefficientsNumber
	Number of field coefficients. More...
typedef uint128_t	UId
	Unique Id. More...
typedef int	ShortId
	Unique Id in the field. More...
typedef std::bitset< BITREFEDGES_SIZE >	BitRefEdges
typedef std::bitset< BITREFLEVEL_SIZE >	BitRefLevel
	Bit structure attached to each entity identifying to what mesh entity is attached. More...
typedef std::bitset< BITFIELDID_SIZE >	BitFieldId
typedef std::bitset< BITFEID_SIZE >	BitFEId
typedef std::bitset< BITPROBLEMID_SIZE >	BitProblemId
typedef std::bitset< BITINTERFACEUID_SIZE >	BitIntefaceId
typedef std::bitset< 32 >	CubitBCType
typedef ublas::unbounded_array< int, std::allocator< int > >	IntAllacator
typedef ublas::unbounded_array< double, std::allocator< double > >	DoubleAllacator
typedef ublas::unbounded_array< double, std::allocator< double > >	DoubleMatrixAllacator
typedef ublas::vector< int, IntAllacator >	VectorInt
typedef ublas::vector< double, DoubleAllacator >	VectorDouble
typedef ublas::matrix< double, ublas::row_major, DoubleMatrixAllacator >	MatrixDouble
typedef ublas::matrix< double, ublas::row_major, ublas::bounded_array< double, 9 > >	MatrixDouble3by3
typedef ublas::vector< double, ublas::bounded_array< double, 3 > >	VectorDouble3
typedef ublas::vector< double, ublas::shallow_array_adaptor< double > >	VectorAdaptor
typedef ublas::matrix< double, ublas::row_major, ublas::shallow_array_adaptor< double > >	MatrixAdaptor
typedef ublas::vector< int, ublas::shallow_array_adaptor< int > >	VectorIntAdaptor
typedef std::vector< boost::shared_ptr< MatrixDouble > >	ShapeFunctionBasesVector
typedef ublas::unbounded_array< boost::shared_ptr< const FEDofEntity >, std::allocator< boost::shared_ptr< const FEDofEntity > >>	DofsAllacator
typedef ublas::vector< boost::shared_ptr< const FEDofEntity >, DofsAllacator >	VectorDofs
typedef CubitMeshSet_multiIndex::index< CubitMeshSets_mi_tag >::type	CubitMeshsetByType
typedef CubitMeshSet_multiIndex::index< CubitMeshSets_mask_meshset_mi_tag >::type	CubitMeshsetByMask
typedef CubitMeshSet_multiIndex::index< CubitMeshSets_name >::type	CubitMeshsetByName
typedef CubitMeshSet_multiIndex::index< CubitMeshSets_mi_tag >::type	CubitMeshsetById
typedef multi_index_container< CubitMeshSets, indexed_by< hashed_unique< tag< Meshset_mi_tag >, member< CubitMeshSets, EntityHandle,&CubitMeshSets::meshset > >, ordered_non_unique< tag< CubitMeshSets_mi_tag >, const_mem_fun< CubitMeshSets, unsigned long int,&CubitMeshSets::getBcTypeULong > >, ordered_non_unique< tag< CubitMeshSets_mask_meshset_mi_tag >, const_mem_fun< CubitMeshSets, unsigned long int,&CubitMeshSets::getMaksedBcTypeULong > >, ordered_non_unique< tag< CubitMeshSets_name >, const_mem_fun< CubitMeshSets, std::string,&CubitMeshSets::getName > >, hashed_unique< tag< Composite_Cubit_msId_And_MeshSetType_mi_tag >, composite_key< CubitMeshSets, const_mem_fun< CubitMeshSets, int,&CubitMeshSets::getMeshsetId >, const_mem_fun< CubitMeshSets, unsigned long int,&CubitMeshSets::getMaksedBcTypeULong > > > >>	CubitMeshSet_multiIndex
	Stores data about meshsets (see CubitMeshSets) storing data about boundary conditions, interfaces, sidesets, nodests, blocksets. More...
typedef multi_index_container< boost::shared_ptr< CoordSys >, indexed_by< ordered_unique< tag< Meshset_mi_tag >, member< CoordSys, EntityHandle,&CoordSys::meshSet > >, ordered_unique< tag< CoordSysName_mi_tag >, const_mem_fun< CoordSys, boost::string_ref,&CoordSys::getNameRef > > > >	CoordSys_multiIndex
typedef DofEntity_multiIndex::index< FieldName_mi_tag >::type	DofEntityByFieldName
	Dof entity multi-index by field name. More...
typedef DofEntity_multiIndex::index< Composite_Name_And_Ent_mi_tag >::type	DofEntityByNameAndEnt
	Dof entity multi-index by field name and entity. More...
typedef DofEntity_multiIndex::index< Composite_Name_And_Type_mi_tag >::type	DofEntityByNameAndType
	Dof entity multi-index by field name and entity type. More...
typedef multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< const_mem_fun< DofEntity, UId,&DofEntity::getGlobalUniqueId > > > >	DofEntity_multiIndex_uid_view
	multi-index view on DofEntity by uid More...
typedef multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< const_mem_fun< DofEntity, UId,&DofEntity::getGlobalUniqueId > >, ordered_non_unique< const_mem_fun< DofEntity, char,&DofEntity::getActive > > > >	DofEntity_multiIndex_active_view
	multi-index view on DofEntity activity More...
typedef multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_non_unique< const_mem_fun< DofEntity, ApproximationOrder,&DofEntity::getDofOrder > > > >	DofEntity_multiIndex_order_view
	multi-index view on DofEntity order More...
typedef multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_non_unique< const_mem_fun< DofEntity::interface_type_RefEntity, EntityType,&DofEntity::getEntType > > > >	DofEntity_multiIndex_ent_type_view
	multi-index view on DofEntity type More...
typedef FEDofEntity_multiIndex::index< FieldName_mi_tag >::type	FEDofEntityByFieldName
	Finite element DoF multi-index by field name. More...
typedef FEDofEntity_multiIndex::index< Composite_Name_And_Ent_mi_tag >::type	FEDofEntityByNameAndEnt
	Dof entity multi-index by field name and entity. More...
typedef FEDofEntity_multiIndex::index< Composite_Name_And_Type_mi_tag >::type	FEDofEntityByNameAndType
	Dof entity multi-index by field name and entity type. More...
typedef FENumeredDofEntity_multiIndex::index< FieldName_mi_tag >::type	FENumeredDofEntityByFieldName
	Finite element numbered DoF multi-index by field name. More...
typedef FENumeredDofEntity_multiIndex::index< Composite_Name_And_Ent_mi_tag >::type	FENumeredDofEntityByNameAndEnt
	Dof entity multi-index by field name and entity. More...
typedef FENumeredDofEntity_multiIndex::index< Composite_Name_And_Type_mi_tag >::type	FENumeredDofEntityByNameAndType
	Dof entity multi-index by field name and entity type. More...
typedef FENumeredDofEntity_multiIndex::index< Unique_mi_tag >::type	FENumeredDofEntityByUId
	Dof entity multi-index by UId. More...
typedef FENumeredDofEntity_multiIndex::index< Ent_mi_tag >::type	FENumeredDofEntityByEnt
	Numbered DoF multi-index by entity. More...
typedef NumeredDofEntity_multiIndex::index< FieldName_mi_tag >::type	NumeredDofEntityByFieldName
	Numbered DoF multi-index by field name. More...
typedef NumeredDofEntity_multiIndex::index< Unique_mi_tag >::type	NumeredDofEntityByUId
	Numbered DoF multi-index by UId. More...
typedef NumeredDofEntity_multiIndex::index< PetscLocalIdx_mi_tag >::type	NumeredDofEntityByLocalIdx
	Numbered DoF multi-index by local index. More...
typedef NumeredDofEntity_multiIndex::index< Ent_mi_tag >::type	NumeredDofEntityByEnt
	Numbered DoF multi-index by entity. More...
typedef NumeredDofEntity_multiIndex::index< Composite_Name_Ent_And_Part_mi_tag >::type	NumeredDofEntityByNameEntAndPart
	Numbered DoF multi-index by name entity and partition. More...
typedef multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_unique< const_mem_fun< NumeredDofEntity::interface_type_DofEntity, const UId, &NumeredDofEntity::getGlobalUniqueId > > >>	NumeredDofEntity_multiIndex_uid_view_ordered
typedef multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< hashed_unique< const_mem_fun< NumeredDofEntity, DofIdx,&NumeredDofEntity::getDofIdx > > >>	NumeredDofEntity_multiIndex_idx_view_hashed
typedef multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_non_unique< const_mem_fun< NumeredDofEntity, DofIdx,&NumeredDofEntity::getPetscLocalDofIdx > > >>	NumeredDofEntity_multiIndex_petsc_local_dof_view_ordered_non_unique
typedef multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_non_unique< const_mem_fun< NumeredDofEntity, DofIdx,&NumeredDofEntity::getPetscGlobalDofIdx > > >>	NumeredDofEntity_multiIndex_petsc_global_dof_view_ordered_non_unique
typedef multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_unique< member< NumeredDofEntity, const DofIdx,&NumeredDofEntity::petscGloablDofIdx > > > >	NumeredDofEntity_multiIndex_global_index_view
typedef multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< hashed_unique< tag< Ent_mi_tag >, member< RefEntity::BasicEntity, EntityHandle,&RefEntity::ent > >, ordered_non_unique< tag< Ent_Ent_mi_tag >, const_mem_fun< RefEntity, EntityHandle,&RefEntity::getParentEnt > >, ordered_non_unique< tag< EntType_mi_tag >, const_mem_fun< RefEntity::BasicEntity, EntityType,&RefEntity::getEntType > >, ordered_non_unique< tag< ParentEntType_mi_tag >, const_mem_fun< RefEntity, EntityType,&RefEntity::getParentEntType > >, ordered_non_unique< tag< Composite_EntType_and_ParentEntType_mi_tag >, composite_key< RefEntity, const_mem_fun< RefEntity::BasicEntity, EntityType,&RefEntity::getEntType >, const_mem_fun< RefEntity, EntityType,&RefEntity::getParentEntType > > >, ordered_non_unique< tag< Composite_ParentEnt_And_EntType_mi_tag >, composite_key< RefEntity, const_mem_fun< RefEntity, EntityHandle,&RefEntity::getParentEnt >, const_mem_fun< RefEntity::BasicEntity, EntityType,&RefEntity::getEntType > > > >>	RefEntity_multiIndex
typedef multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< hashed_unique< const_mem_fun< RefEntity, EntityHandle,&RefEntity::getParentEnt > >, hashed_unique< tag< Composite_EntType_and_ParentEntType_mi_tag >, composite_key< boost::shared_ptr< RefEntity >, const_mem_fun< RefEntity, EntityHandle,&RefEntity::getRefEnt >, const_mem_fun< RefEntity, EntityHandle,&RefEntity::getParentEnt > > > >>	RefEntity_multiIndex_view_by_parent_entity
	multi-index view of RefEntity by parent entity More...
typedef FieldEntity_multiIndex::index< FieldName_mi_tag >::type	FieldEntityByFieldName
	Entity nulti index by field name. More...
typedef multi_index_container< boost::shared_ptr< FieldEntity >, indexed_by< sequenced<>, hashed_non_unique< tag< Ent_mi_tag >, const_mem_fun< FieldEntity, EntityHandle,&FieldEntity::getEnt > > >>	FieldEntity_multiIndex_ent_view
typedef interface_RefElement< RefElement >	ptrWrapperRefElement
typedef multi_index_container< ptrWrapperRefElement, indexed_by< hashed_unique< tag< Ent_mi_tag >, const_mem_fun< ptrWrapperRefElement::interface_type_RefEntity, EntityHandle, &ptrWrapperRefElement::getRefEnt > >, ordered_non_unique< tag< Ent_Ent_mi_tag >, const_mem_fun< ptrWrapperRefElement::interface_type_RefEntity, EntityHandle, &ptrWrapperRefElement::getParentEnt > >, ordered_non_unique< tag< EntType_mi_tag >, const_mem_fun< ptrWrapperRefElement::interface_type_RefEntity, EntityType, &ptrWrapperRefElement::getEntType > >, ordered_non_unique< tag< Composite_ParentEnt_And_BitsOfRefinedEdges_mi_tag >, composite_key< ptrWrapperRefElement, const_mem_fun< ptrWrapperRefElement::interface_type_RefEntity, EntityHandle, &ptrWrapperRefElement::getParentEnt >, const_mem_fun< ptrWrapperRefElement::interface_type_RefElement, int, &ptrWrapperRefElement::getBitRefEdgesUlong > > >, hashed_unique< tag< Composite_EntType_and_ParentEntType_mi_tag >, composite_key< ptrWrapperRefElement, const_mem_fun< ptrWrapperRefElement::interface_type_RefEntity, EntityHandle, &ptrWrapperRefElement::getRefEnt >, const_mem_fun< ptrWrapperRefElement::interface_type_RefEntity, EntityHandle, &ptrWrapperRefElement::getParentEnt > > > >>	RefElement_multiIndex
typedef boost::function< PetscErrorCode(Interface &moab, const Field &field_ptr, const EntFiniteElement &fe_ptr, Range &adjacency)>	ElementAdjacencyFunct
	user adjacency function More...
typedef EntFiniteElement_multiIndex::index< FiniteElement_name_mi_tag >::type	EntFiniteElementbyName
	Entity finite element multi-index by finite element name. More...
typedef NumeredEntFiniteElement_multiIndex::index< FiniteElement_name_mi_tag >::type	NumeredEntFiniteElementbyName
	Entity finite element multi-index by finite element name. More...
typedef NumeredEntFiniteElement_multiIndex::index< Composite_Name_And_Part_mi_tag >::type	NumeredEntFiniteElementbyNameAndPart
	Entity finite element multi-index by finite element name and partition. More...
typedef int(*	FieldOrderTable[MBMAXTYPE]) (const int order)
	user adjacency function table More...
typedef int(*	FieldOrderFunct) (const int order)
	user adjacency function More...
typedef multi_index_container< boost::shared_ptr< Field >, indexed_by< ordered_unique< tag< BitFieldId_mi_tag >, const_mem_fun< Field, const BitFieldId &,&Field::getId >, LtBit< BitFieldId > >> >	Field_multiIndex_view
typedef multi_index_container< FieldSeries, indexed_by< ordered_unique< tag< SeriesID_mi_tag >, const_mem_fun< FieldSeries, EntityID,&FieldSeries::get_meshset_id > >, ordered_unique< tag< SeriesName_mi_tag >, const_mem_fun< FieldSeries, boost::string_ref,&FieldSeries::getNameRef > > >>	Series_multiIndex
	Series multi index. More...
typedef multi_index_container< FieldSeriesStep, indexed_by< ordered_unique< tag< Composite_SeriesID_And_Step_mi_tag >, composite_key< FieldSeriesStep, const_mem_fun< FieldSeriesStep::interface_type_FieldSeries, EntityID, &FieldSeriesStep::get_meshset_id >, member< FieldSeriesStep, int,&FieldSeriesStep::step_number > > >, ordered_unique< tag< Composite_SeriesName_And_Step_mi_tag >, composite_key< FieldSeriesStep, const_mem_fun< FieldSeriesStep::interface_type_FieldSeries, boost::string_ref, &FieldSeriesStep::getNameRef >, member< FieldSeriesStep, int,&FieldSeriesStep::step_number > > >, ordered_non_unique< tag< SeriesName_mi_tag >, const_mem_fun< FieldSeriesStep::interface_type_FieldSeries, boost::string_ref, &FieldSeriesStep::getNameRef > >, ordered_non_unique< tag< Composite_SeriesName_And_Time_mi_tag >, composite_key< FieldSeriesStep, const_mem_fun< FieldSeriesStep::interface_type_FieldSeries, boost::string_ref, &FieldSeriesStep::getNameRef >, const_mem_fun< FieldSeriesStep, double,&FieldSeriesStep::get_time > > > >>	SeriesStep_multiIndex
	Step multi index. More...

Functions
template<class X >
std::string	toString (X x)
PetscErrorCode	PetscOptionsGetInt (PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
PetscErrorCode	PetscOptionsGetReal (PetscOptions *, const char pre[], const char name[], PetscReal *dval, PetscBool *set)
PetscErrorCode	PetscOptionsGetScalar (PetscOptions *, const char pre[], const char name[], PetscScalar *dval, PetscBool *set)
PetscErrorCode	PetscOptionsGetString (PetscOptions *, const char pre[], const char name[], char str[], size_t size, PetscBool *set)
PetscErrorCode	PetscOptionsGetBool (PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
PetscErrorCode	PetscOptionsGetRealArray (PetscOptions *, const char pre[], const char name[], PetscReal dval[], PetscInt *nmax, PetscBool *set)
PetscErrorCode	PetscOptionsGetEList (PetscOptions *, const char pre[], const char name[], const char *const *list, PetscInt next, PetscInt *value, PetscBool *set)
PetscErrorCode	PetscOptionsGetIntArray (PetscOptions options, const char pre[], const char name[], PetscInt dvalue[], PetscInt *nmax, PetscBool *set)
PetscErrorCode	PetscOptionsGetScalarArray (PetscOptions options, const char pre[], const char name[], PetscScalar dvalue[], PetscInt *nmax, PetscBool *set)
void	tet_type_6 (moab::Interface &moab, const EntityHandle *conn, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
int	tet_type_5 (moab::Interface &moab, const EntityHandle *conn, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
int	tet_type_4 (const EntityHandle *conn, const int *split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
int	tet_type_3 (const EntityHandle *conn, const int *split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
int	tet_type_2 (const EntityHandle *conn, const int *split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
void	tet_type_1 (const EntityHandle *conn, const int split_edge, const EntityHandle edge_new_node, EntityHandle *new_tets_conn)
PetscErrorCode	tri_type_3 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_tris_conn)
PetscErrorCode	prism_type_1 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_prism_conn)
PetscErrorCode	prism_type_2 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_prism_conn)
PetscErrorCode	prism_type_3 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_prism_conn)
PetscErrorCode	Hcurl_EdgeBaseFunctions_MBTET (int *sense, int *p, double *N, double *diffN, double *edgeN[], double *diff_edgeN[], int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Edge based H-curl base functions on tetrahedral. More...
PetscErrorCode	Hcurl_EdgeBaseFunctions_MBTET_ON_EDGE (int sense, int p, double *N, double *diffN, double *edgeN, double *diff_edgeN, int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Edge based H-curl base functions on edge. More...
PetscErrorCode	Hcurl_EdgeBaseFunctions_MBTET_ON_FACE (int *sense, int *p, double *N, double *diffN, double *edgeN[], double *diff_edgeN[], int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Edge based H-curl base functions on face. More...
PetscErrorCode	Hcurl_EdgeBasedFaceFunctions_MBTET (int *faces_nodes, int *p, double *N, double *diffN, double *phi_f_e[4][3], double *diff_phi_f_e[4][3], int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face edge base functions of Hcurl space on tetrahedral. More...
PetscErrorCode	Hcurl_EdgeBasedFaceFunctions_MBTET_ON_FACE (int *faces_nodes, int p, double *N, double *diffN, double *phi_f_e[3], double *diff_phi_f_e[3], int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face edge base functions of Hcurl space. More...
PetscErrorCode	Hcurl_BubbleFaceFunctions_MBTET (int *faces_nodes, int *p, double *N, double *diffN, double *phi_f[4], double *diff_phi_f[4], int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face edge base functions of Hcurl space on face on tetrahedral. More...
PetscErrorCode	Hcurl_BubbleFaceFunctions_MBTET_ON_FACE (int *faces_nodes, int p, double *N, double *diffN, double *phi_f, double *diff_phi_f, int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face edge base functions of Hcurl space on face. More...
PetscErrorCode	Hcurl_FaceInteriorFunctions_MBTET (int *faces_nodes, int p, double *N, double *diffN, double *phi_v, double *diff_phi_v, int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face base interior function. More...
PetscErrorCode	Hcurl_VolumeInteriorFunctions_MBTET (int p, double *N, double *diffN, double *phi_v, double *diff_phi_v, int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Volume interior function. More...
PetscErrorCode	Hcurl_FaceFunctions_MBTET (int *face_nodes, int *p, double *N, double *diffN, double *phi_f[4], double *diff_phi_f[4], int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face H-curl functions. More...
PetscErrorCode	Hcurl_FaceFunctions_MBTET_ON_FACE (int *faces_nodes, int p, double *N, double *diffN, double *phi_f, double *diff_phi_f, int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face H-curl functions. More...
PetscErrorCode	Hcurl_VolumeFunctions_MBTET (int p, double *N, double *diffN, double *phi_v, double *diff_phi_v, int nb_integration_pts, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	H-curl volume base functions. More...
PetscErrorCode	Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET (int *faces_nodes, int *p, double *N, double *diffN, double *phi_f_e[4][3], double *diff_phi_f_e[4][3], int gdim, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Hdiv base functions, Edge-based face functions by Ainsworth [1]. More...
PetscErrorCode	Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET_ON_FACE (int *faces_nodes, int p, double *N, double *diffN, double *phi_f_e[3], double *diff_phi_f_e[3], int gdim, int nb, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Hdiv base functions, Edge-based face functions by Ainsworth [1]. More...
PetscErrorCode	Hdiv_Ainsworth_FaceBubbleShapeFunctions (int *faces_nodes, int *p, double *N, double *diffN, double *phi_f[], double *diff_phi_f[], int gdim, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face bubble functions by Ainsworth [1]. More...
PetscErrorCode	Hdiv_Ainsworth_FaceBubbleShapeFunctions_ON_FACE (int *faces_nodes, int p, double *N, double *diffN, double *phi_f, double *diff_phi_f, int gdim, int nb, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Face bubble functions by Ainsworth [1]. More...
PetscErrorCode	Hdiv_Ainsworth_EdgeBasedVolumeShapeFunctions_MBTET (int p, double *N, double *diffN, double *phi_v_e[6], double *diff_phi_v_e[6], int gdim, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Hdiv base function, Edge-based interior (volume) functions by Ainsworth [1]. More...
PetscErrorCode	Hdiv_Ainsworth_FaceBasedVolumeShapeFunctions_MBTET (int p, double *N, double *diffN, double *phi_v_f[], double *diff_phi_v_f[], int gdim, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
PetscErrorCode	Hdiv_Ainsworth_VolumeBubbleShapeFunctions_MBTET (int p, double *N, double *diffN, double *phi_v, double *diff_phi_v, int gdim, PetscErrorCode(*base_polynomials)(int p, double s, double *diff_s, double *L, double *diffL, const int dim))
	Interior bubble functions by Ainsworth [1]. More...
PetscErrorCode	Hdiv_Demkowicz_Face_MBTET_ON_FACE (int *faces_nodes, int p, double *N, double *diffN, double *phi_f, double *diff_phi_f, int gdim, int nb)
PetscErrorCode	Hdiv_Demkowicz_Interior_MBTET (int p, double *N, double *diffN, int p_face[], double *phi_f[4], double *diff_phi_f[4], double *phi_v, double *diff_phi_v, int gdim)
void	tet_type_6 (Interface &moab, const EntityHandle *conn, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
int	tet_type_5 (Interface &moab, const EntityHandle *conn, const EntityHandle *edge_new_nodes, EntityHandle *new_tets_conn)
template<int Tensor_Dim, class T , class L , class A >
PetscErrorCode	invertTensor3by3 (ublas::matrix< T, L, A > &jac_data, ublas::vector< T, A > &det_data, ublas::matrix< T, L, A > &inv_jac_data)
	Calculate inverse of tensor rank 2 at integration points. More...
template<>
PetscErrorCode	invertTensor3by3< 3, double, ublas::row_major, ublas::unbounded_array< double > > (MatrixDouble &jac_data, VectorDouble &det_data, MatrixDouble &inv_jac_data)
template<class T1 , class T2 >
PetscErrorCode	determinantTensor3by3 (T1 &t, T2 &det)
	Calculate determinant. More...
template<class T1 , class T2 , class T3 >
PetscErrorCode	invertTensor3by3 (T1 &t, T2 &det, T3 &inv_t)
	Calculate matrix inverse. More...
template<class T , class A >
FTensor::Tensor0< T * >	getTensor0FormData (ublas::vector< T, A > &data)
	Get tensor rank 0 (scalar) form data vectorExample how to use it. More...
template<>
FTensor::Tensor0< double * >	getTensor0FormData< double, ublas::unbounded_array< double > > (ublas::vector< double, ublas::unbounded_array< double > > &data)
template<int Tensor_Dim, class T , class L , class A >
FTensor::Tensor1< T *, Tensor_Dim >	getTensor1FormData (ublas::matrix< T, L, A > &data)
	Get tensor rank 1 (vector) form data matrix. More...
template<int Tensor_Dim>
FTensor::Tensor1< double *, Tensor_Dim >	getTensor1FormData (MatrixDouble &data)
	Get tensor rank 1 (vector) form data matrix (specialization) More...
template<>
FTensor::Tensor1< double *, 3 >	getTensor1FormData< 3, double, ublas::row_major, ublas::unbounded_array< double > > (MatrixDouble &data)
template<>
FTensor::Tensor1< double *, 2 >	getTensor1FormData< 2, double, ublas::row_major, ublas::unbounded_array< double > > (MatrixDouble &data)
template<int Tensor_Dim0, int Tensor_Dim1, class T , class L , class A >
FTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 >	getTensor2FormData (ublas::matrix< T, L, A > &data)
	Get tensor rank 2 (matrix) form data matrix. More...
template<>
FTensor::Tensor2< double *, 3, 3 >	getTensor2FormData (MatrixDouble &data)
	Get tensor rank 2 (matrix) form data matrix (specialization) More...
template<>
FTensor::Tensor2< double *, 3, 2 >	getTensor2FormData (MatrixDouble &data)
	Get tensor rank 2 (matrix) form data matrix (specialization) More...
template<int Tensor_Dim0, int Tensor_Dim1>
FTensor::Tensor2< double *, Tensor_Dim0, Tensor_Dim1 >	getTensor2FormData (MatrixDouble &data)
	Get tensor rank 2 (matrix) form data matrix (specialization) More...
template<>
FTensor::Tensor2< double *, 3, 3 >	getTensor2FormData< 3, 3, double, ublas::row_major, ublas::unbounded_array< double > > (MatrixDouble &data)
template<>
FTensor::Tensor2< double *, 3, 2 >	getTensor2FormData< 3, 2, double, ublas::row_major, ublas::unbounded_array< double > > (MatrixDouble &data)
template<class T >
void	cOnstructor (DataForcesAndSurcesCore *data, EntityType type, T)
std::ostream &	operator<< (std::ostream &os, const DataForcesAndSurcesCore::EntData &e)
std::ostream &	operator<< (std::ostream &os, const DataForcesAndSurcesCore &e)
PetscErrorCode	print_verison ()
std::ostream &	operator<< (std::ostream &os, const MedInterface::FieldData &field_data)
struct	__attribute__ ((__packed__)) SideNumber
	keeps information about side number for the finite element More...
int	fNBENTITY_GENERIC (int P)
int	fNBENTITYSET_NOFIELD (int P)
int	fNBVERTEX_L2 (int P)
int	fNBVOLUMETET_L2 (int P)
int	fNBFACETRI_L2 (int P)
int	fNBEDGE_L2 (int P)
int	fNBVERTEX_H1 (int P)
	number of approx. functions for H1 space on vertex More...
int	fNBEDGE_H1 (int P)
	number of approx. functions for H1 space on edge More...
int	fNBFACETRI_H1 (int P)
	number of approx. functions for H1 space on face More...
int	fNBFACEQUAD_H1 (int P)
int	fNBVOLUMETET_H1 (int P)
	number of approx. functions for H1 space on volume More...
int	fNBVOLUMEPRISM_H1 (int P)
int	fNBVERTEX_HCURL (int P)
	number of approx. functions for HCURL space on vertex More...
int	fNBEDGE_HCURL (int P)
int	fNBFACETRI_HCURL (int P)
int	fNBVOLUMETET_HCURL (int P)
int	fNBVERTEX_HDIV (int P)
	number of approx. functions for HDIV space on vertex More...
int	fNBEDGE_HDIV (int P)
	number of approx. functions for HDIV space on edge More...
int	fNBFACETRI_AINSWORTH_HDIV (int P)
	number of approx. functions for HDIV space on face More...
int	fNBVOLUMETET_AINSWORTH_HDIV (int P)
	number of approx. functions for HDIV space on volume More...
int	fNBFACETRI_DEMKOWICZ_HDIV (int P)
int	fNBVOLUMETET_DEMKOWICZ_HDIV (int P)
	number of approx. functions for HDIV space on volume More...
PetscErrorCode	test_moab (Interface &moab, const EntityHandle ent)
	Test MoAB entity handle if has structure as is assumed by MoFEM. More...
std::ostream &	operator<< (std::ostream &os, const CubitMeshSets &e)
std::ostream &	operator<< (std::ostream &os, const DisplacementCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const ForceCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const VelocityCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const AccelerationCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const TemperatureCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const PressureCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const HeatFluxCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const CfgCubitBcData &e)
std::ostream &	operator<< (std::ostream &os, const BlockSetAttributes &e)
std::ostream &	operator<< (std::ostream &os, const Mat_Elastic &e)
std::ostream &	operator<< (std::ostream &os, const Mat_Elastic_EberleinHolzapfel1 &e)
std::ostream &	operator<< (std::ostream &os, const Mat_Thermal &e)
std::ostream &	operator<< (std::ostream &os, const Mat_Moisture &e)
std::ostream &	operator<< (std::ostream &os, const Block_BodyForces &e)
std::ostream &	operator<< (std::ostream &os, const Mat_Elastic_TransIso &e)
std::ostream &	operator<< (std::ostream &os, const Mat_Interf &e)
std::ostream &	operator<< (std::ostream &os, const Field &e)
std::ostream &	operator<< (std::ostream &os, const FieldEntityEntFiniteElementAdjacencyMap &e)
std::ostream &	operator<< (std::ostream &os, const DofEntity &e)
std::ostream &	operator<< (std::ostream &os, const NumeredDofEntity &e)
std::ostream &	operator<< (std::ostream &os, const FEDofEntity &e)
std::ostream &	operator<< (std::ostream &os, const FENumeredDofEntity &e)
void *	get_tag_ptr (SequenceManager *sequence_manager, Tag th, EntityHandle ent, int *tag_size)
PetscErrorCode	getPatentEnt (Interface &moab, Range ents, std::vector< EntityHandle > vec_patent_ent)
std::ostream &	operator<< (std::ostream &os, const RefEntity &e)
std::ostream &	operator<< (std::ostream &os, const FieldEntity &e)
std::ostream &	operator<< (std::ostream &os, const RefElement &e)
std::ostream &	operator<< (std::ostream &os, const RefElement_TET &e)
std::ostream &	operator<< (std::ostream &os, const RefElement_TRI &e)
std::ostream &	operator<< (std::ostream &os, const RefElement_EDGE &e)
std::ostream &	operator<< (std::ostream &os, const RefElement_VERTEX &e)
std::ostream &	operator<< (std::ostream &os, const FiniteElement &e)
std::ostream &	operator<< (std::ostream &os, const EntFiniteElement &e)
std::ostream &	operator<< (std::ostream &os, const Problem &e)
std::ostream &	operator<< (std::ostream &os, const FieldSeries &e)
std::ostream &	operator<< (std::ostream &os, const FieldSeriesStep &e)
PetscErrorCode	KspRhs (KSP ksp, Vec f, void *ctx)
	Run over elements in the lists. More...
PetscErrorCode	KspMat (KSP ksp, Mat A, Mat B, void *ctx)
	Run over elenents in the list. More...
PetscErrorCode	SnesRhs (SNES snes, Vec x, Vec f, void *ctx)
	This is MoFEM implementation for the right hand side (residual vector) evaluation in SNES solver. More...
PetscErrorCode	SnesMat (SNES snes, Vec x, Mat A, Mat B, void *ctx)
	This is MoFEM implementation for the left hand side (tangent matrix) evaluation in SNES solver. More...
PetscErrorCode	f_TSSetIFunction (TS ts, PetscReal t, Vec u, Vec u_t, Vec F, void *ctx)
PetscErrorCode	f_TSSetIJacobian (TS ts, PetscReal t, Vec u, Vec u_t, PetscReal a, Mat A, Mat B, void *ctx)
PetscErrorCode	f_TSMonitorSet (TS ts, PetscInt step, PetscReal t, Vec u, void *ctx)

Variables
DEPRECATED typedef Problem	MoFEMProblem
const EntityHandle	no_handle = 0
const int	prism_adj_edges [] = { 6,7,8, -1,-1,-1, 0,1,2 }
const int	prism_edges_conn [6][2] = { {0,1},{1,2},{2,0}, {3,4}, {4,5}, {5,3} }

Detailed Description

implementation of Data Operators for Forces and Sources

name space of MoFEM library functions and classes

Create adjacent matrices using different indices.

file DataOperators.cpp

The MoFEM package is copyrighted by Lukasz Kaczmarczyk. It can be freely used for educational and research purposes by other institutions. If you use this softwre pleas cite my work.

MoFEM 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 3 of the License, or (at your option) any later version.

MoFEM 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 MoFEM. If not, see http://www.gnu.org/licenses/

MoFEM 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 MoFEM. If not, see http://www.gnu.org/licenses/

Typedef Documentation

ApproximationOrder

typedef int MoFEM::ApproximationOrder

Approximation on the entity.

Definition at line 30 of file Common.hpp.

BitFEId

typedef std::bitset<BITFEID_SIZE> MoFEM::BitFEId

Definition at line 48 of file Common.hpp.

BitFieldId

typedef std::bitset<BITFIELDID_SIZE> MoFEM::BitFieldId

Definition at line 47 of file Common.hpp.

BitIntefaceId

typedef std::bitset<BITINTERFACEUID_SIZE> MoFEM::BitIntefaceId

Definition at line 50 of file Common.hpp.

BitProblemId

typedef std::bitset<BITPROBLEMID_SIZE> MoFEM::BitProblemId

Definition at line 49 of file Common.hpp.

BitRefEdges

typedef std::bitset<BITREFEDGES_SIZE> MoFEM::BitRefEdges

Definition at line 40 of file Common.hpp.

BitRefLevel

typedef std::bitset<BITREFLEVEL_SIZE> MoFEM::BitRefLevel

Bit structure attached to each entity identifying to what mesh entity is attached.

Examples:

MagneticElement.hpp, and Remodeling.hpp.

Definition at line 45 of file Common.hpp.

CoordSys_multiIndex

typedef multi_index_container< boost::shared_ptr<CoordSys>, indexed_by< ordered_unique< tag<Meshset_mi_tag>, member<CoordSys,EntityHandle,&CoordSys::meshSet> >, ordered_unique< tag<CoordSysName_mi_tag>, const_mem_fun<CoordSys,boost::string_ref,&CoordSys::getNameRef> > > > MoFEM::CoordSys_multiIndex

Definition at line 140 of file CoordSysMultiIndices.hpp.

CubitBCType

MoFEM::CubitBCType

bc & material meshsets

Definition at line 122 of file Common.hpp.

CubitMeshSet_multiIndex

MoFEM::CubitMeshSet_multiIndex

Stores data about meshsets (see CubitMeshSets) storing data about boundary conditions, interfaces, sidesets, nodests, blocksets.

Parameters

Meshset_mi_tag	index by meshset handle
CubitMeshSets_mi_tag	index by bc type, see CubitBC
CubitMeshSets_mask_meshset_mi_tag	index by NODESET, SIDESET, BLOCKSET only
CubitMeshSets_name	index by meshset name
Composite_Cubit_msId_And_MeshSetType_mi_tag	index by meshset id and type NODESET, SIDESET or BLOCKSET

Example:

MeshsetsManager *m_mng;
ierr = m_field.query_interface(m_mng); CHKERRQ(ierr);
CubitMeshSet_multiIndex &meshsets_index = m_mng->etMeshsetsMultindex();

CubitMeshSet_multiIndex::index<CubitMeshSets_mask_meshset_mi_tag>::type::iterator mit,hi_mit;
mit = meshsets_index.get<CubitMeshSets_mask_meshset_mi_tag>().lower_bound(BLOCKSET);
hi_mit = meshsets_index.get<CubitMeshSets_mask_meshset_mi_tag>().upper_bound(BLOCKSET);
// Make a loop over all BLOCKSET
for(;mit!=hi_mit;mit++) {
  int id = mit->getMeshsetId();            // get blockset id
  EntityHandle handle = mit->getMeshset(); // get block meshset
  std::vector< double > attributes;
  // get block attributes
  ierr = mit->getAttributes(attributes); CHKERRQ(ierr);
  // do something
}

Definition at line 406 of file BCMultiIndices.hpp.

CubitMeshsetById

typedef CubitMeshSet_multiIndex::index<CubitMeshSets_mi_tag>::type MoFEM::CubitMeshsetById

Definition at line 30 of file MeshsetsManager.hpp.

CubitMeshsetByMask

typedef CubitMeshSet_multiIndex::index<CubitMeshSets_mask_meshset_mi_tag>::type MoFEM::CubitMeshsetByMask

Definition at line 26 of file MeshsetsManager.hpp.

CubitMeshsetByName

typedef CubitMeshSet_multiIndex::index<CubitMeshSets_name>::type MoFEM::CubitMeshsetByName

Definition at line 28 of file MeshsetsManager.hpp.

CubitMeshsetByType

typedef CubitMeshSet_multiIndex::index<CubitMeshSets_mi_tag>::type MoFEM::CubitMeshsetByType

Definition at line 24 of file MeshsetsManager.hpp.

DofIdx

typedef int MoFEM::DofIdx

Index of DOF.

Definition at line 25 of file Common.hpp.

DofsAllacator

typedef ublas::unbounded_array< boost::shared_ptr<const FEDofEntity>, std::allocator<boost::shared_ptr<const FEDofEntity> >> MoFEM::DofsAllacator

Definition at line 32 of file DataStructures.hpp.

DoubleAllacator

typedef ublas::unbounded_array<double,std::allocator<double> > MoFEM::DoubleAllacator

Definition at line 126 of file Common.hpp.

DoubleMatrixAllacator

typedef ublas::unbounded_array<double,std::allocator<double> > MoFEM::DoubleMatrixAllacator

Definition at line 127 of file Common.hpp.

EntIdx

typedef int MoFEM::EntIdx

Index of DOF on the entity.

Definition at line 27 of file Common.hpp.

EntPart

typedef int MoFEM::EntPart

Partition owning entity.

Definition at line 28 of file Common.hpp.

FEIdx

typedef int MoFEM::FEIdx

Index of the element.

Definition at line 26 of file Common.hpp.

Field_multiIndex_view

typedef multi_index_container< boost::shared_ptr<Field>, indexed_by< ordered_unique< tag<BitFieldId_mi_tag>, const_mem_fun<Field,const BitFieldId&,&Field::getId>, LtBit<BitFieldId> >> > MoFEM::Field_multiIndex_view

Definition at line 451 of file FieldMultiIndices.hpp.

FieldCoefficientsNumber

typedef int MoFEM::FieldCoefficientsNumber

Number of field coefficients.

Definition at line 31 of file Common.hpp.

FieldData

typedef double MoFEM::FieldData

Field data type.

Definition at line 29 of file Common.hpp.

FieldEntity_multiIndex_ent_view

typedef multi_index_container< boost::shared_ptr<FieldEntity>, indexed_by< sequenced<>, hashed_non_unique< tag<Ent_mi_tag>, const_mem_fun<FieldEntity,EntityHandle,&FieldEntity::getEnt> > >> MoFEM::FieldEntity_multiIndex_ent_view

Definition at line 908 of file EntsMultiIndices.hpp.

IntAllacator

typedef ublas::unbounded_array<int,std::allocator<int> > MoFEM::IntAllacator

Definition at line 125 of file Common.hpp.

MatrixAdaptor

typedef ublas::matrix<double,ublas::row_major,ublas::shallow_array_adaptor<double> > MoFEM::MatrixAdaptor

Examples:

SmallStrainPlasticity.hpp.

Definition at line 138 of file Common.hpp.

MatrixDouble

typedef ublas::matrix<double,ublas::row_major, DoubleMatrixAllacator > MoFEM::MatrixDouble

Examples:

MagneticElement.hpp, PoissonOperators.hpp, Remodeling.hpp, and SmallStrainPlasticity.hpp.

Definition at line 132 of file Common.hpp.

MatrixDouble3by3

typedef ublas::matrix<double,ublas::row_major,ublas::bounded_array<double,9> > MoFEM::MatrixDouble3by3

Definition at line 133 of file Common.hpp.

MoABErrorCode

typedef ErrorCode MoFEM::MoABErrorCode

Examples:

elasticity.cpp, MagneticElement.hpp, and SmallStrainPlasticity.hpp.

Definition at line 23 of file Common.hpp.

NumeredDofEntity_multiIndex_global_index_view

typedef multi_index_container< boost::shared_ptr<NumeredDofEntity>, indexed_by< ordered_unique< member<NumeredDofEntity,const DofIdx,&NumeredDofEntity::petscGloablDofIdx> > > > MoFEM::NumeredDofEntity_multiIndex_global_index_view

Definition at line 863 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_idx_view_hashed

typedef multi_index_container< boost::shared_ptr<NumeredDofEntity>, indexed_by< hashed_unique< const_mem_fun<NumeredDofEntity,DofIdx,&NumeredDofEntity::getDofIdx> > >> MoFEM::NumeredDofEntity_multiIndex_idx_view_hashed

Definition at line 743 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_petsc_global_dof_view_ordered_non_unique

typedef multi_index_container< boost::shared_ptr<NumeredDofEntity>, indexed_by< ordered_non_unique< const_mem_fun<NumeredDofEntity,DofIdx,&NumeredDofEntity::getPetscGlobalDofIdx> > >> MoFEM::NumeredDofEntity_multiIndex_petsc_global_dof_view_ordered_non_unique

Definition at line 759 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_petsc_local_dof_view_ordered_non_unique

typedef multi_index_container< boost::shared_ptr<NumeredDofEntity>, indexed_by< ordered_non_unique< const_mem_fun<NumeredDofEntity,DofIdx,&NumeredDofEntity::getPetscLocalDofIdx> > >> MoFEM::NumeredDofEntity_multiIndex_petsc_local_dof_view_ordered_non_unique

Definition at line 751 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_uid_view_ordered

typedef multi_index_container< boost::shared_ptr<NumeredDofEntity>, indexed_by< ordered_unique< const_mem_fun< NumeredDofEntity::interface_type_DofEntity, const UId, &NumeredDofEntity::getGlobalUniqueId > > >> MoFEM::NumeredDofEntity_multiIndex_uid_view_ordered

Definition at line 734 of file DofsMultiIndices.hpp.

ptrWrapperRefElement

typedef interface_RefElement<RefElement> MoFEM::ptrWrapperRefElement

Definition at line 187 of file FEMultiIndices.hpp.

ShapeFunctionBasesVector

typedef std::vector<boost::shared_ptr<MatrixDouble> > MoFEM::ShapeFunctionBasesVector

Definition at line 141 of file Common.hpp.

ShortId

typedef int MoFEM::ShortId

Unique Id in the field.

Definition at line 36 of file Common.hpp.

UId

typedef uint128_t MoFEM::UId

Unique Id.

Definition at line 35 of file Common.hpp.

VectorAdaptor

typedef ublas::vector<double,ublas::shallow_array_adaptor<double> > MoFEM::VectorAdaptor

Examples:

SmallStrainPlasticity.hpp.

Definition at line 137 of file Common.hpp.

VectorDofs

typedef ublas::vector< boost::shared_ptr<const FEDofEntity>,DofsAllacator> MoFEM::VectorDofs

Definition at line 35 of file DataStructures.hpp.

VectorDouble

typedef ublas::vector<double,DoubleAllacator > MoFEM::VectorDouble

Examples:

MagneticElement.hpp, PoissonOperators.hpp, Remodeling.hpp, and SmallStrainPlasticity.hpp.

Definition at line 131 of file Common.hpp.

VectorDouble3

typedef ublas::vector<double,ublas::bounded_array<double,3> > MoFEM::VectorDouble3

Definition at line 134 of file Common.hpp.

VectorInt

typedef ublas::vector<int,IntAllacator > MoFEM::VectorInt

Definition at line 130 of file Common.hpp.

VectorIntAdaptor

typedef ublas::vector<int,ublas::shallow_array_adaptor<int> > MoFEM::VectorIntAdaptor

Definition at line 139 of file Common.hpp.

Function Documentation

cOnstructor()

template<class T >

void MoFEM::cOnstructor	(	DataForcesAndSurcesCore *	data,
		EntityType	type,
		T
	)

Definition at line 142 of file DataStructures.cpp.

                                                                  {

  data->dataOnEntities[MBENTITYSET].push_back(new T());

  switch (type) {
    case MBTET:
    data->dataOnEntities[MBVERTEX].push_back(new T());
    for(int ee = 0;ee<6;ee++) {
      data->dataOnEntities[MBEDGE].push_back(new T());
    }
    for(int ff = 0;ff<4;ff++) {
      data->dataOnEntities[MBTRI].push_back(new T());
    }
    data->dataOnEntities[MBTET].push_back(new T());
    break;
    case MBTRI:
    data->dataOnEntities[MBVERTEX].push_back(new T());
    for(int ee = 0;ee<3;ee++) {
      data->dataOnEntities[MBEDGE].push_back(new T());
    }
    data->dataOnEntities[MBTRI].push_back(new T());
    break;
    case MBEDGE:
    data->dataOnEntities[MBVERTEX].push_back(new T());
    data->dataOnEntities[MBEDGE].push_back(new T());
    break;
    case MBVERTEX:
    data->dataOnEntities[MBVERTEX].push_back(new T());
    break;
    case MBPRISM:
    data->dataOnEntities[MBVERTEX].push_back(new T());
    for(int ee = 0;ee<9;ee++) {
      data->dataOnEntities[MBEDGE].push_back(new T());
    }
    for(int ff = 0;ff<5;ff++) {
      data->dataOnEntities[MBQUAD].push_back(new T());
    }
    for(int ff = 0;ff<5;ff++) {
      data->dataOnEntities[MBTRI].push_back(new T());
    }
    data->dataOnEntities[MBPRISM].push_back(new T());
    break;
    default:
    throw MoFEMException(MOFEM_NOT_IMPLEMENTED);
  }

}

f_TSMonitorSet()

PetscErrorCode MoFEM::f_TSMonitorSet	(	TS	ts,
		PetscInt	step,
		PetscReal	t,
		Vec	u,
		void *	ctx
	)

Definition at line 176 of file TsCtx.cpp.

                                                                               {
  PetscFunctionBegin;
  PetscErrorCode ierr;
  TsCtx* ts_ctx = (TsCtx*)ctx;
  PetscLogEventBegin(ts_ctx->USER_EVENT_TsCtxRHSFunction,0,0,0,0);
  ierr = VecGhostUpdateBegin(u,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(u,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = ts_ctx->mField.set_local_ghost_vector(ts_ctx->problemName,COL,u,INSERT_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  //preproces
  TsCtx::basic_method_to_do::iterator bit = ts_ctx->preProcess_Monitor.begin();
  for(;bit!=ts_ctx->preProcess_Monitor.end();bit++) {
    (*bit)->ts_u = u;
    (*bit)->ts_t = t;
    (*bit)->ts_step = step;
    (*bit)->ts_F = PETSC_NULL;
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSSETIJACOBIAN);
    ierr = (*bit)->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,*(*(bit))); CHKERRQ(ierr);
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSNONE); CHKERRQ(ierr); CHKERRQ(ierr);
  }
  TsCtx::loops_to_do_type::iterator lit = ts_ctx->loops_to_do_Monitor.begin();
  for(;lit!=ts_ctx->loops_to_do_Monitor.end();lit++) {
    lit->second->ts_u = u;
    lit->second->ts_t = t;
    lit->second->ts_step = step;
    lit->second->ts_F = PETSC_NULL;
    ierr = lit->second->set_ts_ctx(TSMethod::CTX_TSTSMONITORSET);
    ierr = lit->second->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.loop_finite_elements(ts_ctx->problemName,lit->first,*(lit->second),ts_ctx->bH); CHKERRQ(ierr);
    ierr = lit->second->set_ts_ctx(TSMethod::CTX_TSNONE);
  }
  //post process
  bit = ts_ctx->postProcess_Monitor.begin();
  for(;bit!=ts_ctx->postProcess_Monitor.end();bit++) {
    (*bit)->ts_u = u;
    (*bit)->ts_t = t;
    (*bit)->ts_step = step;
    (*bit)->ts_F = PETSC_NULL;
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSSETIJACOBIAN);
    ierr = (*bit)->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,*(*(bit))); CHKERRQ(ierr);
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSNONE); CHKERRQ(ierr);
  }
  PetscLogEventEnd(ts_ctx->USER_EVENT_TsCtxRHSFunction,0,0,0,0);
  PetscFunctionReturn(0);
}

f_TSSetIFunction()

PetscErrorCode MoFEM::f_TSSetIFunction	(	TS	ts,
		PetscReal	t,
		Vec	u,
		Vec	u_t,
		Vec	F,
		void *	ctx
	)

Definition at line 49 of file TsCtx.cpp.

                                                                                 {
  PetscFunctionBegin;
  PetscErrorCode ierr;
  TsCtx* ts_ctx = (TsCtx*)ctx;
  PetscLogEventBegin(ts_ctx->USER_EVENT_TsCtxIFunction,0,0,0,0);
  ierr = VecGhostUpdateBegin(u,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(u,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateBegin(u_t,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(u_t,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = ts_ctx->mField.set_local_ghost_vector(ts_ctx->problemName,COL,u,INSERT_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  ierr = VecZeroEntries(F); CHKERRQ(ierr);
  ierr = VecGhostUpdateBegin(F,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(F,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  int step;
  ierr = TSGetTimeStepNumber(ts,&step); CHKERRQ(ierr);
  //preprocess
  TsCtx::basic_method_to_do::iterator bit = ts_ctx->preProcess_IFunction.begin();
  for(;bit!=ts_ctx->preProcess_IFunction.end();bit++) {
    (*bit)->ts_u = u;
    (*bit)->ts_u_t = u_t;
    (*bit)->ts_F = F;
    (*bit)->ts_t = t;
    (*bit)->ts_step = step;
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSSETIFUNCTION);
    ierr = (*bit)->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,*(*(bit)));  CHKERRQ(ierr);
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSNONE);
  }
  //fe loops
  TsCtx::loops_to_do_type::iterator lit = ts_ctx->loops_to_do_IFunction.begin();
  for(;lit!=ts_ctx->loops_to_do_IFunction.end();lit++) {
    lit->second->ts_u = u;
    lit->second->ts_u_t = u_t;
    lit->second->ts_F = F;
    lit->second->ts_t = t;
    lit->second->ts_step = step;
    ierr = lit->second->set_ts_ctx(TSMethod::CTX_TSSETIFUNCTION);
    ierr = lit->second->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.loop_finite_elements(ts_ctx->problemName,lit->first,*(lit->second),ts_ctx->bH); CHKERRQ(ierr);
    ierr = lit->second->set_ts_ctx(TSMethod::CTX_TSNONE);
  }
  //post process
  bit = ts_ctx->postProcess_IFunction.begin();
  for(;bit!=ts_ctx->postProcess_IFunction.end();bit++) {
    (*bit)->ts_u = u;
    (*bit)->ts_u_t = u_t;
    (*bit)->ts_F = F;
    (*bit)->ts_t = t;
    (*bit)->ts_step = step;
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSSETIFUNCTION);
    ierr = (*bit)->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,*(*(bit)));  CHKERRQ(ierr);
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSNONE);
  }
  ierr = VecGhostUpdateBegin(F,ADD_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(F,ADD_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  ierr = VecAssemblyBegin(F); CHKERRQ(ierr);
  ierr = VecAssemblyEnd(F); CHKERRQ(ierr);
  PetscLogEventEnd(ts_ctx->USER_EVENT_TsCtxIFunction,0,0,0,0);
  PetscFunctionReturn(0);
}

f_TSSetIJacobian()

PetscErrorCode MoFEM::f_TSSetIJacobian	(	TS	ts,
		PetscReal	t,
		Vec	u,
		Vec	u_t,
		PetscReal	a,
		Mat	A,
		Mat	B,
		void *	ctx
	)

Definition at line 110 of file TsCtx.cpp.

                                                                                                   {
  PetscFunctionBegin;
  PetscErrorCode ierr;
  TsCtx* ts_ctx = (TsCtx*)ctx;
  PetscLogEventBegin(ts_ctx->USER_EVENT_TsCtxIFunction,0,0,0,0);
  ierr = VecGhostUpdateBegin(u,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(u,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateBegin(u_t,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(u_t,INSERT_VALUES,SCATTER_FORWARD); CHKERRQ(ierr);
  ierr = ts_ctx->mField.set_local_ghost_vector(ts_ctx->problemName,COL,u,INSERT_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  if(ts_ctx->zeroMatrix) {
    ierr = MatZeroEntries(B); CHKERRQ(ierr);
  }
  int step;
  ierr = TSGetTimeStepNumber(ts,&step); CHKERRQ(ierr);
  //preproces
  TsCtx::basic_method_to_do::iterator bit = ts_ctx->preProcess_IJacobian.begin();
  for(;bit!=ts_ctx->preProcess_IJacobian.end();bit++) {
    (*bit)->ts_u = u;
    (*bit)->ts_u_t = u_t;
    (*bit)->ts_A = A;
    (*bit)->ts_B = B;
    (*bit)->ts_t = t;
    (*bit)->ts_a = a;
    (*bit)->ts_step = step;
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSSETIJACOBIAN);
    ierr = (*bit)->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,*(*(bit))); CHKERRQ(ierr);
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSNONE); CHKERRQ(ierr); CHKERRQ(ierr);
  }
  TsCtx::loops_to_do_type::iterator lit = ts_ctx->loops_to_do_IJacobian.begin();
  for(;lit!=ts_ctx->loops_to_do_IJacobian.end();lit++) {
    lit->second->ts_u = u;
    lit->second->ts_u_t = u_t;
    lit->second->ts_A = A;
    lit->second->ts_B = B;
    lit->second->ts_t = t;
    lit->second->ts_a = a;
    lit->second->ts_step = step;
    ierr = lit->second->set_ts_ctx(TSMethod::CTX_TSSETIJACOBIAN);
    ierr = lit->second->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.loop_finite_elements(ts_ctx->problemName,lit->first,*(lit->second),ts_ctx->bH); CHKERRQ(ierr);
    ierr = lit->second->set_ts_ctx(TSMethod::CTX_TSNONE); CHKERRQ(ierr);
  }
  //post process
  bit = ts_ctx->postProcess_IJacobian.begin();
  for(;bit!=ts_ctx->postProcess_IJacobian.end();bit++) {
    (*bit)->ts_u = u;
    (*bit)->ts_u_t = u_t;
    (*bit)->ts_A = A;
    (*bit)->ts_B = B;
    (*bit)->ts_t = t;
    (*bit)->ts_a = a;
    (*bit)->ts_step = step;
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSSETIJACOBIAN);
    ierr = (*bit)->set_ts(ts); CHKERRQ(ierr);
    ierr = ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,*(*(bit))); CHKERRQ(ierr);
    ierr = (*bit)->set_ts_ctx(TSMethod::CTX_TSNONE); CHKERRQ(ierr);
  }
  if(ts_ctx->zeroMatrix) {
    ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);
    ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);
  }
  PetscLogEventEnd(ts_ctx->USER_EVENT_TsCtxIFunction,0,0,0,0);
  PetscFunctionReturn(0);
}

fNBEDGE_H1()

int MoFEM::fNBEDGE_H1

(

int

P

)

number of approx. functions for H1 space on edge

Definition at line 39 of file CoreDataStructures.hpp.

{ return NBEDGE_H1(P); }

fNBEDGE_HCURL()

int MoFEM::fNBEDGE_HCURL

(

int

P

)

Definition at line 50 of file CoreDataStructures.hpp.

{ return NBEDGE_HCURL(P); }

fNBEDGE_HDIV()

int MoFEM::fNBEDGE_HDIV

(

int

P

)

number of approx. functions for HDIV space on edge

Definition at line 59 of file CoreDataStructures.hpp.

{ (void)P; return NBEDGE_HDIV(P); }

fNBEDGE_L2()

int MoFEM::fNBEDGE_L2

(

int

P

)

Definition at line 33 of file CoreDataStructures.hpp.

{ return NBEDGE_L2(P); }

fNBENTITY_GENERIC()

int MoFEM::fNBENTITY_GENERIC

(

int

P

)

Definition at line 27 of file CoreDataStructures.hpp.

{ (void)P; return 0; }

fNBENTITYSET_NOFIELD()

int MoFEM::fNBENTITYSET_NOFIELD

(

int

P

)

Definition at line 28 of file CoreDataStructures.hpp.

{ (void)P; return 1; }

fNBFACEQUAD_H1()

int MoFEM::fNBFACEQUAD_H1

(

int

P

)

Definition at line 42 of file CoreDataStructures.hpp.

{ return NBFACEQUAD_H1(P); }

fNBFACETRI_AINSWORTH_HDIV()

int MoFEM::fNBFACETRI_AINSWORTH_HDIV

(

int

P

)

number of approx. functions for HDIV space on face

Definition at line 61 of file CoreDataStructures.hpp.

{ return NBFACETRI_AINSWORTH_HDIV(P); }

fNBFACETRI_DEMKOWICZ_HDIV()

int MoFEM::fNBFACETRI_DEMKOWICZ_HDIV

(

int

P

)

Definition at line 65 of file CoreDataStructures.hpp.

{ return NBFACETRI_DEMKOWICZ_HDIV(P); }

fNBFACETRI_H1()

int MoFEM::fNBFACETRI_H1

(

int

P

)

number of approx. functions for H1 space on face

Definition at line 41 of file CoreDataStructures.hpp.

{ return NBFACETRI_H1(P); }

fNBFACETRI_HCURL()

int MoFEM::fNBFACETRI_HCURL

(

int

P

)

Definition at line 51 of file CoreDataStructures.hpp.

{ return NBFACETRI_HCURL(P); }

fNBFACETRI_L2()

int MoFEM::fNBFACETRI_L2

(

int

P

)

Definition at line 32 of file CoreDataStructures.hpp.

{ return NBFACETRI_L2(P); }

fNBVERTEX_H1()

int MoFEM::fNBVERTEX_H1

(

int

P

)

number of approx. functions for H1 space on vertex

Definition at line 37 of file CoreDataStructures.hpp.

{ return (P==1) ? 1 : 0; }

fNBVERTEX_HCURL()

int MoFEM::fNBVERTEX_HCURL

(

int

P

)

number of approx. functions for HCURL space on vertex

Definition at line 49 of file CoreDataStructures.hpp.

{ (void)P; return 0; }

fNBVERTEX_HDIV()

int MoFEM::fNBVERTEX_HDIV

(

int

P

)

number of approx. functions for HDIV space on vertex

zero number of digrees of freedom on vertex for that space

Definition at line 57 of file CoreDataStructures.hpp.

{ (void)P; return 0; }

fNBVERTEX_L2()

int MoFEM::fNBVERTEX_L2

(

int

P

)

Definition at line 30 of file CoreDataStructures.hpp.

{ (void)P; return 0; }

fNBVOLUMEPRISM_H1()

int MoFEM::fNBVOLUMEPRISM_H1

(

int

P

)

Definition at line 45 of file CoreDataStructures.hpp.

{ return NBVOLUMEPRISM_H1(P); }

fNBVOLUMETET_AINSWORTH_HDIV()

int MoFEM::fNBVOLUMETET_AINSWORTH_HDIV

(

int

P

)

number of approx. functions for HDIV space on volume

Definition at line 63 of file CoreDataStructures.hpp.

{ return NBVOLUMETET_AINSWORTH_HDIV(P); }

fNBVOLUMETET_DEMKOWICZ_HDIV()

int MoFEM::fNBVOLUMETET_DEMKOWICZ_HDIV

(

int

P

)

number of approx. functions for HDIV space on volume

Definition at line 67 of file CoreDataStructures.hpp.

{ return NBVOLUMETET_DEMKOWICZ_HDIV(P); }

fNBVOLUMETET_H1()

int MoFEM::fNBVOLUMETET_H1

(

int

P

)

number of approx. functions for H1 space on volume

Definition at line 44 of file CoreDataStructures.hpp.

{ return NBVOLUMETET_H1(P); }

fNBVOLUMETET_HCURL()

int MoFEM::fNBVOLUMETET_HCURL

(

int

P

)

Definition at line 52 of file CoreDataStructures.hpp.

{ return NBVOLUMETET_HCURL(P); }

fNBVOLUMETET_L2()

int MoFEM::fNBVOLUMETET_L2

(

int

P

)

Definition at line 31 of file CoreDataStructures.hpp.

{ return NBVOLUMETET_L2(P); }

get_tag_ptr()

void* MoFEM::get_tag_ptr	(	SequenceManager *	sequence_manager,
		Tag	th,
		EntityHandle	ent,
		int *	tag_size
	)

Definition at line 45 of file EntsMultiIndices.cpp.

                                                                                                  {
  ApproximationOrder *ret_val;
  if(th->get_storage_type()==MB_TAG_SPARSE) {
    rval = static_cast<SparseTag*>(th)->get_data(
      sequence_manager,&error,&ent,1,(const void**)&ret_val,tag_size
    ); MOAB_THROW(rval);
    return ret_val;
  } else {
    rval = static_cast<DenseTag*>(th)->get_data(
      sequence_manager,&error,&ent,1,(const void**)&ret_val,tag_size
    ); MOAB_THROW(rval);
    return ret_val;
  }
}

getPatentEnt()

PetscErrorCode MoFEM::getPatentEnt	(	Interface &	moab,
		Range	ents,
		std::vector< EntityHandle >	vec_patent_ent
	)

Definition at line 124 of file EntsMultiIndices.cpp.

                                                                                               {
  MoABErrorCode rval;
  PetscFunctionBegin;
  Tag th_ref_parent_handle;
  rval = moab.tag_get_handle("_RefParentHandle",th_ref_parent_handle); CHKERRQ_MOAB(rval);
  vec_patent_ent.resize(ents.size());
  rval = moab.tag_get_data(th_ref_parent_handle,ents,&*vec_patent_ent.begin()); CHKERRQ_MOAB(rval);
  PetscFunctionReturn(0);
}

getTensor0FormData< double, ublas::unbounded_array< double > >()

template<>

FTensor::Tensor0< double * > MoFEM::getTensor0FormData< double, ublas::unbounded_array< double > >

(

ublas::vector< double, ublas::unbounded_array< double > > &

data

)

Definition at line 66 of file DataStructures.cpp.

  {
  return FTensor::Tensor0<double*>(&*data.data().begin());
}

getTensor1FormData< 2, double, ublas::row_major, ublas::unbounded_array< double > >()

template<>

FTensor::Tensor1< double *, 2 > MoFEM::getTensor1FormData< 2, double, ublas::row_major, ublas::unbounded_array< double > >

(

MatrixDouble &

data

)

Definition at line 83 of file DataStructures.cpp.

  {
  if(data.size1()!=2) {
    THROW_MESSAGE("Wrong size of data matrix");
  }
  return FTensor::Tensor1<double*,2>(&data(0,0),&data(1,0));
}

getTensor1FormData< 3, double, ublas::row_major, ublas::unbounded_array< double > >()

template<>

FTensor::Tensor1< double *, 3 > MoFEM::getTensor1FormData< 3, double, ublas::row_major, ublas::unbounded_array< double > >

(

MatrixDouble &

data

)

Definition at line 73 of file DataStructures.cpp.

  {
  if(data.size1()!=3) {
    THROW_MESSAGE("Wrong size of data matrix");
  }
  return FTensor::Tensor1<double*,3>(&data(0,0),&data(1,0),&data(2,0));
}

getTensor2FormData< 3, 2, double, ublas::row_major, ublas::unbounded_array< double > >()

template<>

FTensor::Tensor2<double*,3,2> MoFEM::getTensor2FormData< 3, 2, double, ublas::row_major, ublas::unbounded_array< double > >

(

MatrixDouble &

data

)

Definition at line 105 of file DataStructures.cpp.

  {
  if(data.size1()!=6) {
    THROW_MESSAGE("Wrong size of data matrix");
  }
  return FTensor::Tensor2<double*,3,2>(
    &data(0,0),&data(1,0),&data(2,0),&data(3,0),&data(4,0),&data(5,0)
  );
}

getTensor2FormData< 3, 3, double, ublas::row_major, ublas::unbounded_array< double > >()

template<>

FTensor::Tensor2<double*,3,3> MoFEM::getTensor2FormData< 3, 3, double, ublas::row_major, ublas::unbounded_array< double > >

(

MatrixDouble &

data

)

Definition at line 93 of file DataStructures.cpp.

  {
  if(data.size1()!=9) {
    THROW_MESSAGE("Wrong size of data matrix");
  }
  return FTensor::Tensor2<double*,3,3>(
    &data(0,0),&data(1,0),&data(2,0),&data(3,0),&data(4,0),&data(5,0),&data(6,0),&data(7,0),&data(8,0)
  );
}

Hcurl_BubbleFaceFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_BubbleFaceFunctions_MBTET	(	int *	faces_nodes,
		int *	p,
		double *	N,
		double *	diffN,
		double *	phi_f[4],
		double *	diff_phi_f[4],
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face edge base functions of Hcurl space on face on tetrahedral.

On each face we have P*(P-1) base functions and are 4 faces.

See NBFACETRI_EDGE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	array shape functions evaluated at each integration point
diffN	derivatives of nodal shape functions
phi_f[4]	calculated shape functions for each face
diff_phi_v[4]	derivatives of shape functions for each face
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 499 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  // double coords[] = { 0,0,0, 1,0,0, 0,1,0, 0,0,1 };
  // FTensor::Tensor1<double*,3> t_coords[4] = {
  //   FTensor::Tensor1<double*,3>(&coords[0],&coords[ 1],&coords[ 2]),
  //   FTensor::Tensor1<double*,3>(&coords[3],&coords[ 4],&coords[ 5]),
  //   FTensor::Tensor1<double*,3>(&coords[6],&coords[ 7],&coords[ 8]),
  //   FTensor::Tensor1<double*,3>(&coords[9],&coords[10],&coords[11])
  // };
  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };
  FTensor::Tensor1<double,3> t_diff_ksi0i,t_diff_ksi0j;
  FTensor::Tensor1<double,3> diff_beta_0ij;

  FTensor::Tensor1<double,3> tou_0i;
  FTensor::Tensor1<double,3> tou_0j;

  for(int ff = 0;ff!=4;ff++) {

    if(NBFACETRI_FACE_HCURL(p[ff])==0) continue;

    int n0 = faces_nodes[3*ff+0];
    int n1 = faces_nodes[3*ff+1];
    int n2 = faces_nodes[3*ff+2];

    // tou_0i(i) = t_coords[n1](i)-t_coords[n0](i);
    // tou_0j(i) = t_coords[n2](i)-t_coords[n0](i);
    tou_0i(i) = t_node_diff_ksi[n1](i)-t_node_diff_ksi[n0](i);
    tou_0j(i) = t_node_diff_ksi[n2](i)-t_node_diff_ksi[n0](i);

    t_diff_ksi0i(i) = t_node_diff_ksi[n1](i)-t_node_diff_ksi[n0](i);
    t_diff_ksi0j(i) = t_node_diff_ksi[n2](i)-t_node_diff_ksi[n0](i);

    double psi_l_0i[p[ff]+1],diff_psi_l_0i[3*p[ff]+3];
    double psi_l_0j[p[ff]+1],diff_psi_l_0j[3*p[ff]+3];

    FTensor::Tensor1<double*,3> t_phi_f(
      &phi_f[ff][0],&phi_f[ff][1],&phi_f[ff][2],3
    );
    FTensor::Tensor2<double*,3,3> t_diff_phi_f(
      &diff_phi_f[ff][0],&diff_phi_f[ff][3],&diff_phi_f[ff][6],
      &diff_phi_f[ff][1],&diff_phi_f[ff][4],&diff_phi_f[ff][7],
      &diff_phi_f[ff][2],&diff_phi_f[ff][5],&diff_phi_f[ff][8],9
    );
    FTensor::Tensor1<double,3> t_b;

    for(int ii = 0;ii!=nb_integration_pts;ii++) {

      const int node_shift = ii*4;
      const double beta_0ij = N[node_shift+n0]*N[node_shift+n1]*N[node_shift+n2];
      diff_beta_0ij(i) =
      t_node_diff_ksi[n0](i)*N[node_shift+n1]*N[node_shift+n2]+
      N[node_shift+n0]*t_node_diff_ksi[n1](i)*N[node_shift+n2]+
      N[node_shift+n0]*N[node_shift+n1]*t_node_diff_ksi[n2](i);

      const double ksi_0i = N[node_shift+n1]-N[node_shift+n0];
      ierr = base_polynomials(p[ff],ksi_0i,&t_diff_ksi0i(0),psi_l_0i,diff_psi_l_0i,3); CHKERRQ(ierr);
      const double ksi_0j = N[node_shift+n2]-N[node_shift+n0];
      ierr = base_polynomials(p[ff],ksi_0j,&t_diff_ksi0j(0),psi_l_0j,diff_psi_l_0j,3); CHKERRQ(ierr);

      int cc = 0;
      for(int oo = 0;oo<=(p[ff]-3);oo++) {
        FTensor::Tensor1<double*,3> t_diff_psi_l_0i(
          &diff_psi_l_0i[0],&diff_psi_l_0i[p[ff]+1],&diff_psi_l_0i[2*p[ff]+2],1
        );
        for(int pp0 = 0;pp0<=oo;pp0++) {
          const int pp1 = oo-pp0;
          if(pp1>=0) {
            FTensor::Tensor1<double*,3> t_diff_psi_l_0j(
              &diff_psi_l_0j[pp1],&diff_psi_l_0j[p[ff]+1+pp1],&diff_psi_l_0j[2*p[ff]+2+pp1],1
            );
            // base functions
            const double a = beta_0ij*psi_l_0i[pp0]*psi_l_0j[pp1];
            t_phi_f(i) = a*tou_0i(i);
            ++t_phi_f;
            ++cc;
            t_phi_f(i) = a*tou_0j(i);
            ++t_phi_f;
            ++cc;
            // diff base functions
            t_b(j) =
            diff_beta_0ij(j)*psi_l_0i[pp0]*psi_l_0j[pp1]+
            beta_0ij*t_diff_psi_l_0i(j)*psi_l_0j[pp1]+
            beta_0ij*psi_l_0i[pp0]*t_diff_psi_l_0j(j);
            t_diff_phi_f(i,j) = t_b(j)*tou_0i(i);
            ++t_diff_phi_f;
            t_diff_phi_f(i,j) = t_b(j)*tou_0j(i);
            ++t_diff_phi_f;
            ++t_diff_psi_l_0i;
          }
        }
      }
      const int nb_base_fun_on_face = NBFACETRI_FACE_HCURL(p[ff]);
      if(cc!=nb_base_fun_on_face) {
        SETERRQ2(
          PETSC_COMM_SELF,
          MOFEM_DATA_INCONSISTENCY,
          "Wrong number of base functions %d != %d",
          cc,nb_base_fun_on_face
        );
      }

    }

  }
  PetscFunctionReturn(0);
}

Hcurl_BubbleFaceFunctions_MBTET_ON_FACE()

PetscErrorCode MoFEM::Hcurl_BubbleFaceFunctions_MBTET_ON_FACE	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_f,
		double *	diff_phi_f,
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face edge base functions of Hcurl space on face.

On each face we have P*(P-1) base functions and are 4 faces.

See NBFACETRI_EDGE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	array shape functions evaluated at each integration point
diffN	derivatives of nodal shape functions
phi_f[4]	calculated shape functions for each face
diff_phi_v[4]	derivatives of shape functions for each face
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 619 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  double zero = 0;
  FTensor::Tensor2<double*,3,3> t_node_diff_ksi(
    &diffN[0],&diffN[ 1],&zero,
    &diffN[2],&diffN[ 3],&zero,
    &diffN[4],&diffN[ 5],&zero
  );

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',2> j;

  if(NBFACETRI_FACE_HCURL(p)==0) PetscFunctionReturn(0);

  FTensor::Number<0> N0;
  FTensor::Number<1> N1;
  FTensor::Number<2> N2;

  const int node0 = faces_nodes[0];
  const int node1 = faces_nodes[1];
  const int node2 = faces_nodes[2];

  FTensor::Tensor1<double,3> tou_0i;
  FTensor::Tensor1<double,3> tou_0j;

  tou_0i(i) = t_node_diff_ksi(N1,i)-t_node_diff_ksi(N0,i);;
  tou_0j(i) = t_node_diff_ksi(N2,i)-t_node_diff_ksi(N0,i);;

  double psi_l_0i[p+1],psi_l_0j[p+1];
  double diff_psi_l_0i[2*p+2],diff_psi_l_0j[2*p+2];
  FTensor::Tensor1<double*,3> t_phi_f(&phi_f[0],&phi_f[1],&phi_f[2],3);
  FTensor::Tensor2<double*,3,2> t_diff_phi_f(
    &diff_phi_f[HCURL0_0],&diff_phi_f[HCURL0_1],
    &diff_phi_f[HCURL1_0],&diff_phi_f[HCURL1_1],
    &diff_phi_f[HCURL2_0],&diff_phi_f[HCURL2_1],6
  );

  double diff_ksi_0i[] = {
    t_node_diff_ksi(node1,0)-t_node_diff_ksi(node0,0),
    t_node_diff_ksi(node1,1)-t_node_diff_ksi(node0,1)
  };
  double diff_ksi_0j[] = {
    t_node_diff_ksi(node2,0)-t_node_diff_ksi(node0,0),
    t_node_diff_ksi(node2,1)-t_node_diff_ksi(node0,1)
  };

  for(int ii = 0;ii!=nb_integration_pts;ii++) {

    const int node_shift = ii*3;
    const double n0 = N[node_shift+node0];
    const double n1 = N[node_shift+node1];
    const double n2 = N[node_shift+node2];

    const double beta_0ij = n0*n1*n2;
    FTensor::Tensor1<double,2> diff_beta_0ij(
      t_node_diff_ksi(node0,0)*n1*n2+n0*t_node_diff_ksi(node1,0)*n2+n0*n1*t_node_diff_ksi(node2,0),
      t_node_diff_ksi(node0,1)*n1*n2+n0*t_node_diff_ksi(node1,1)*n2+n0*n1*t_node_diff_ksi(node2,1)
    );

    const double ksi_0i = N[node_shift+node1]-N[node_shift+node0];
    ierr = base_polynomials(p,ksi_0i,diff_ksi_0i,psi_l_0i,diff_psi_l_0i,2); CHKERRQ(ierr);
    const double ksi_0j = N[node_shift+node2]-N[node_shift+node0];
    ierr = base_polynomials(p,ksi_0j,diff_ksi_0j,psi_l_0j,diff_psi_l_0j,2); CHKERRQ(ierr);

    int cc = 0;
    FTensor::Tensor1<double,2> t_diff_a;
    for(int oo = 0;oo<=(p-3);oo++) {
      for(int pp0 = 0;pp0<=oo;pp0++) {
        const int pp1 = oo-pp0;
        if(pp1>=0) {
          FTensor::Tensor1<double,2> t_diff_psi_l_0i(
            diff_psi_l_0i[0+pp0],diff_psi_l_0i[p+1+pp0]
          );
          FTensor::Tensor1<double,2> t_diff_psi_l_0j(
            diff_psi_l_0j[0+pp1],diff_psi_l_0j[p+1+pp1]
          );
          const double a = beta_0ij*psi_l_0i[pp0]*psi_l_0j[pp1];
          t_diff_a(j) =
          diff_beta_0ij(j)*psi_l_0i[pp0]*psi_l_0j[pp1]+
          beta_0ij*psi_l_0i[pp0]*t_diff_psi_l_0j(j)+
          beta_0ij*psi_l_0j[pp1]*t_diff_psi_l_0i(j);

          t_phi_f(i) = a*tou_0i(i);
          t_diff_phi_f(i,j) = tou_0i(i)*t_diff_a(j);
          ++t_phi_f;
          ++t_diff_phi_f;
          ++cc;
          t_phi_f(i) = a*tou_0j(i);
          t_diff_phi_f(i,j) = tou_0j(i)*t_diff_a(j);
          ++t_phi_f;
          ++t_diff_phi_f;
          ++cc;
        }
      }
    }

    const int nb_base_fun_on_face = NBFACETRI_FACE_HCURL(p);
    if(cc!=nb_base_fun_on_face) {
      SETERRQ2(
        PETSC_COMM_SELF,
        MOFEM_DATA_INCONSISTENCY,
        "Wrong number of base functions %d != %d",
        cc,nb_base_fun_on_face
      );
    }

  }

  PetscFunctionReturn(0);
}

Hcurl_EdgeBasedFaceFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_EdgeBasedFaceFunctions_MBTET	(	int *	faces_nodes,
		int *	p,
		double *	N,
		double *	diffN,
		double *	phi_f_e[4][3],
		double *	diff_phi_f_e[4][3],
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face edge base functions of Hcurl space on tetrahedral.

On each edge we have (P-1) base functions, and each face has 3 edges and are 4 faces on tetrahedral.

See NBFACETRI_EDGE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	array shape functions evaluated at each integration point
diffN	derivatives of nodal shape functions
phi_f[4]	calculated shape functions for each face
diff_phi_v[4]	derivatives of shape functions for each face
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 328 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;
  const int edges[3][2] = { {0,1}, {1,2}, {2,0} };

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };
  FTensor::Tensor1<double,3> t_edge_diff_ksi;
  FTensor::Tensor1<double,3> t_diff_beta_e;

  for(int ff = 0;ff!=4;ff++) {

    const int o_nodes[3] = {
      faces_nodes[3*ff+2],faces_nodes[3*ff+0],faces_nodes[3*ff+1]
    };
    FTensor::Tensor1<double*,3> t_opposite_node_diff[3] = {
      FTensor::Tensor1<double*,3>(&diffN[3*o_nodes[0]+0],&diffN[3*o_nodes[0]+1],&diffN[3*o_nodes[0]+2]),
      FTensor::Tensor1<double*,3>(&diffN[3*o_nodes[1]+0],&diffN[3*o_nodes[1]+1],&diffN[3*o_nodes[1]+2]),
      FTensor::Tensor1<double*,3>(&diffN[3*o_nodes[2]+0],&diffN[3*o_nodes[2]+1],&diffN[3*o_nodes[2]+2])
    };
    double psi_l[p[ff]+1],diff_psi_l[3*p[ff]+3];

    const int nb_base_fun_on_face = NBFACETRI_EDGE_HCURL(p[ff]);
    // cerr << nb_base_fun_on_face << " " << p[ff] << endl;
    if(nb_base_fun_on_face==0) continue;

    for(int ee = 0;ee!=3;ee++) {

      FTensor::Tensor1<double*,3> t_face_edge_base(
        &phi_f_e[ff][ee][0],&phi_f_e[ff][ee][1],&phi_f_e[ff][ee][2],3
      );
      FTensor::Tensor2<double*,3,3> t_diff_face_edge_base(
        &diff_phi_f_e[ff][ee][0],&diff_phi_f_e[ff][ee][3],&diff_phi_f_e[ff][ee][6],
        &diff_phi_f_e[ff][ee][1],&diff_phi_f_e[ff][ee][4],&diff_phi_f_e[ff][ee][7],
        &diff_phi_f_e[ff][ee][2],&diff_phi_f_e[ff][ee][5],&diff_phi_f_e[ff][ee][8],9
      );
      const int en[] = { faces_nodes[3*ff+edges[ee][0]],faces_nodes[3*ff+edges[ee][1]] };
      t_edge_diff_ksi(i) = t_node_diff_ksi[en[1]](i)-t_node_diff_ksi[en[0]](i);

      for(int ii = 0;ii!=nb_integration_pts;ii++) {

        const int node_shift = ii*4;
        const double n[] = {
          N[node_shift+faces_nodes[3*ff+edges[ee][0]]],
          N[node_shift+faces_nodes[3*ff+edges[ee][1]]]
        };
        const double ksi_0i = n[1]-n[0];
        ierr = base_polynomials(p[ff],ksi_0i,&t_edge_diff_ksi(0),psi_l,diff_psi_l,3); CHKERRQ(ierr);
        FTensor::Tensor1<double*,3> t_diff_psi_l(&diff_psi_l[0],&diff_psi_l[p[ff]+1],&diff_psi_l[2*p[ff]+2],1);

        const double beta_e = n[0]*n[1];
        t_diff_beta_e(j) = t_node_diff_ksi[en[0]](j)*n[1]+n[0]*t_node_diff_ksi[en[1]](j);

        for(int ll = 0;ll!=nb_base_fun_on_face;ll++) {
          // if(ll == nb_base_fun_on_face-1) cerr << psi_l[ll] << endl;

          t_face_edge_base(i) = beta_e*psi_l[ll]*t_opposite_node_diff[ee](i);
          ++t_face_edge_base;

          t_diff_face_edge_base(i,j) =
          (beta_e*t_diff_psi_l(j)+t_diff_beta_e(j)*psi_l[ll])*t_opposite_node_diff[ee](i);

          ++t_diff_face_edge_base;
          ++t_diff_psi_l;
        }

      }
    }
  }

  PetscFunctionReturn(0);
}

Hcurl_EdgeBasedFaceFunctions_MBTET_ON_FACE()

PetscErrorCode MoFEM::Hcurl_EdgeBasedFaceFunctions_MBTET_ON_FACE	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_f_e[3],
		double *	diff_phi_f_e[3],
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face edge base functions of Hcurl space.

On each edge we have (P-1) base functions, and each face has 3 edges and are 4 faces on tetrahedral.

See NBFACETRI_EDGE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	array shape functions evaluated at each integration point
diffN	derivatives of nodal shape functions
phi_f[4]	calculated shape functions for each face
diff_phi_v[4]	derivatives of shape functions for each face
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 411 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  const int nb_base_fun_on_face = NBFACETRI_EDGE_HCURL(p);
  if(nb_base_fun_on_face==0) PetscFunctionReturn(0);

  const int edges[3][2] = { {0,1}, {1,2}, {2,0} };

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',2> j;

  const int o_nodes[3] = { 2,0,1 };
  FTensor::Tensor2<double,3,3> t_opposite_node_diff(
    diffN[2*o_nodes[0]+0],diffN[2*o_nodes[0]+1],0,
    diffN[2*o_nodes[1]+0],diffN[2*o_nodes[1]+1],0,
    diffN[2*o_nodes[2]+0],diffN[2*o_nodes[2]+1],0
  );
  double psi_l[p+1];
  double diff_psi_l[2*p+2];

  FTensor::Tensor1<double*,3> t_face_edge_base[3] = {
      FTensor::Tensor1<double*,3>(&phi_f_e[0][HCURL0],&phi_f_e[0][HCURL1],&phi_f_e[0][HCURL2],3),
      FTensor::Tensor1<double*,3>(&phi_f_e[1][HCURL0],&phi_f_e[1][HCURL1],&phi_f_e[1][HCURL2],3),
      FTensor::Tensor1<double*,3>(&phi_f_e[2][HCURL0],&phi_f_e[2][HCURL1],&phi_f_e[2][HCURL2],3),
  };
  FTensor::Tensor2<double*,3,2> t_diff_face_edge_base[3] = {
    FTensor::Tensor2<double*,3,2>(
      &diff_phi_f_e[0][HCURL0_0],&diff_phi_f_e[0][HCURL0_1],
      &diff_phi_f_e[0][HCURL1_0],&diff_phi_f_e[0][HCURL1_1],
      &diff_phi_f_e[0][HCURL2_0],&diff_phi_f_e[0][HCURL2_1],6
    ),
    FTensor::Tensor2<double*,3,2>(
      &diff_phi_f_e[1][HCURL0_0],&diff_phi_f_e[1][HCURL0_1],
      &diff_phi_f_e[1][HCURL1_0],&diff_phi_f_e[1][HCURL1_1],
      &diff_phi_f_e[1][HCURL2_0],&diff_phi_f_e[1][HCURL2_1],6
    ),
    FTensor::Tensor2<double*,3,2>(
      &diff_phi_f_e[2][HCURL0_0],&diff_phi_f_e[2][HCURL0_1],
      &diff_phi_f_e[2][HCURL1_0],&diff_phi_f_e[2][HCURL1_1],
      &diff_phi_f_e[2][HCURL2_0],&diff_phi_f_e[2][HCURL2_1],6
    )
  };

  for(int ee = 0;ee!=3;ee++) {

    const int node0 = faces_nodes[edges[ee][0]];
    const int node1 = faces_nodes[edges[ee][1]];
    double diff_ksi0i[] = {
      diffN[2*node1+0]-diffN[2*node0+0],
      diffN[2*node1+1]-diffN[2*node0+1]
    };

    for(int ii = 0;ii!=nb_integration_pts;ii++) {

      const int node_shift = ii*3;
      const double n0 = N[node_shift+node0];
      const double n1 = N[node_shift+node1];
      const double ksi_0i = n1-n0;
      ierr = base_polynomials(p,ksi_0i,diff_ksi0i,psi_l,diff_psi_l,2); CHKERRQ(ierr);
      const double beta_e = n0*n1;
      FTensor::Tensor1<double,2> t_diff_beta_e(
        diffN[2*node0+0]*n1+n0*diffN[2*node1+0],
        diffN[2*node0+1]*n1+n0*diffN[2*node1+1]
      );
      FTensor::Tensor1<double*,2> t_diff_psi_l(
        &diff_psi_l[0],&diff_psi_l[p+1],1
      );

      for(int ll = 0;ll!=nb_base_fun_on_face;ll++) {
        t_face_edge_base[ee](i) = beta_e*psi_l[ll]*t_opposite_node_diff(ee,i);
        t_diff_face_edge_base[ee](i,j) =
        beta_e*t_opposite_node_diff(ee,i)*t_diff_psi_l(j)+
        psi_l[ll]*t_opposite_node_diff(ee,i)*t_diff_beta_e(j);
        ++t_face_edge_base[ee];
        ++t_diff_face_edge_base[ee];
        ++t_diff_psi_l;
      }

    }
  }

  PetscFunctionReturn(0);
}

Hcurl_EdgeBaseFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_EdgeBaseFunctions_MBTET	(	int *	sense,
		int *	p,
		double *	N,
		double *	diffN,
		double *	edgeN[],
		double *	diff_edgeN[],
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Edge based H-curl base functions on tetrahedral.

Function generates hierarchical base of h-curl comforting functions on tetrahedral edge. For more details see [2].

On each tetrahedral's edge we have P+1 functions. See NBEDGE_HCURL

Parameters

sense	sense fo edge (i.e. unique orientation)
p	array of oder for each edge
N	array shape functions evaluated at each integration point
diffN	derivatives of shape functions
edgeN	base functions on edges
diff_edgeN	derivatives of edge shape functions
nb_integration_pts	number of integration points
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 21 of file Hcurl.cpp.

  {
  PetscFunctionBegin;
  PetscErrorCode ierr;
  const int edges_nodes[6][2] = {
    {0,1}, {1,2}, {2,0}, {0,3}, {1,3}, {2,3}
  };
  int P[6];
  for(int ee = 0;ee!=6; ee++) P[ee] = NBEDGE_HCURL(p[ee]);

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };
  double edge_diff_ksi[6][3];
  FTensor::Tensor1<double*,3> t_edge_diff_ksi[6] = {
    FTensor::Tensor1<double*,3>(&edge_diff_ksi[0][0],&edge_diff_ksi[0][1],&edge_diff_ksi[0][2]),
    FTensor::Tensor1<double*,3>(&edge_diff_ksi[1][0],&edge_diff_ksi[1][1],&edge_diff_ksi[1][2]),
    FTensor::Tensor1<double*,3>(&edge_diff_ksi[2][0],&edge_diff_ksi[2][1],&edge_diff_ksi[2][2]),
    FTensor::Tensor1<double*,3>(&edge_diff_ksi[3][0],&edge_diff_ksi[3][1],&edge_diff_ksi[3][2]),
    FTensor::Tensor1<double*,3>(&edge_diff_ksi[4][0],&edge_diff_ksi[4][1],&edge_diff_ksi[4][2]),
    FTensor::Tensor1<double*,3>(&edge_diff_ksi[5][0],&edge_diff_ksi[5][1],&edge_diff_ksi[5][2])
  };
  for(int ee = 0;ee!=6;ee++) {
    t_edge_diff_ksi[ee](i) = (
      t_node_diff_ksi[edges_nodes[ee][1]](i)-t_node_diff_ksi[edges_nodes[ee][0]](i)
    )*sense[ee];
  }

  FTensor::Tensor1<double*,3> t_edge_n[6] = {
    FTensor::Tensor1<double*,3>(&edge_n[0][0],&edge_n[0][1],&edge_n[0][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[1][0],&edge_n[1][1],&edge_n[1][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[2][0],&edge_n[2][1],&edge_n[2][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[3][0],&edge_n[3][1],&edge_n[3][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[4][0],&edge_n[4][1],&edge_n[4][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[5][0],&edge_n[5][1],&edge_n[5][2],3)
  };
  FTensor::Tensor2<double*,3,3> t_diff_edge_n[6] = {
    FTensor::Tensor2<double*,3,3>(
      &diff_edge_n[0][0],&diff_edge_n[0][3],&diff_edge_n[0][6],
      &diff_edge_n[0][1],&diff_edge_n[0][4],&diff_edge_n[0][7],
      &diff_edge_n[0][2],&diff_edge_n[0][5],&diff_edge_n[0][8],9
    ),
    FTensor::Tensor2<double*,3,3>(
      &diff_edge_n[1][0],&diff_edge_n[1][3],&diff_edge_n[1][6],
      &diff_edge_n[1][1],&diff_edge_n[1][4],&diff_edge_n[1][7],
      &diff_edge_n[1][2],&diff_edge_n[1][5],&diff_edge_n[1][8],9
    ),
    FTensor::Tensor2<double*,3,3>(
      &diff_edge_n[2][0],&diff_edge_n[2][3],&diff_edge_n[2][6],
      &diff_edge_n[2][1],&diff_edge_n[2][4],&diff_edge_n[2][7],
      &diff_edge_n[2][2],&diff_edge_n[2][5],&diff_edge_n[2][8],9
    ),
    FTensor::Tensor2<double*,3,3>(
      &diff_edge_n[3][0],&diff_edge_n[3][3],&diff_edge_n[3][6],
      &diff_edge_n[3][1],&diff_edge_n[3][4],&diff_edge_n[3][7],
      &diff_edge_n[3][2],&diff_edge_n[3][5],&diff_edge_n[3][8],9
    ),
    FTensor::Tensor2<double*,3,3>(
      &diff_edge_n[4][0],&diff_edge_n[4][3],&diff_edge_n[4][6],
      &diff_edge_n[4][1],&diff_edge_n[4][4],&diff_edge_n[4][7],
      &diff_edge_n[4][2],&diff_edge_n[4][5],&diff_edge_n[4][8],9
    ),
    FTensor::Tensor2<double*,3,3>(
      &diff_edge_n[5][0],&diff_edge_n[5][3],&diff_edge_n[5][6],
      &diff_edge_n[5][1],&diff_edge_n[5][4],&diff_edge_n[5][7],
      &diff_edge_n[5][2],&diff_edge_n[5][5],&diff_edge_n[5][8],9
    )
  };
  FTensor::Tensor1<double,3> t_psi_e_0,t_psi_e_1;
  FTensor::Tensor2<double,3,3> t_diff_psi_e_0,t_diff_psi_e_1;

  for(int ii = 0;ii!=nb_integration_pts;ii++) {

    const int node_shift = ii*4;
    for(int ee = 0;ee!=6;ee++) {

      if(P[ee]==0) continue;

      t_psi_e_0(i) =
      (N[node_shift+edges_nodes[ee][1]]*t_node_diff_ksi[edges_nodes[ee][0]](i)-
      N[node_shift+edges_nodes[ee][0]]*t_node_diff_ksi[edges_nodes[ee][1]](i))*sense[ee];
      t_diff_psi_e_0(i,j) =
      (t_node_diff_ksi[edges_nodes[ee][1]](j)*t_node_diff_ksi[edges_nodes[ee][0]](i)-
      t_node_diff_ksi[edges_nodes[ee][0]](j)*t_node_diff_ksi[edges_nodes[ee][1]](i))*sense[ee];

      t_psi_e_1(i) =
      N[node_shift+edges_nodes[ee][1]]*t_node_diff_ksi[edges_nodes[ee][0]](i)+
      N[node_shift+edges_nodes[ee][0]]*t_node_diff_ksi[edges_nodes[ee][1]](i);
      t_diff_psi_e_1(i,j) =
      t_node_diff_ksi[edges_nodes[ee][1]](j)*t_node_diff_ksi[edges_nodes[ee][0]](i)+
      t_node_diff_ksi[edges_nodes[ee][0]](j)*t_node_diff_ksi[edges_nodes[ee][1]](i);

      (t_edge_n[ee])(i) = t_psi_e_0(i);
      ++(t_edge_n[ee]);
      (t_edge_n[ee])(i) = t_psi_e_1(i);
      ++(t_edge_n[ee]);

      (t_diff_edge_n[ee])(i,j) = t_diff_psi_e_0(i,j);
      ++(t_diff_edge_n[ee]);
      (t_diff_edge_n[ee])(i,j) = t_diff_psi_e_1(i,j);
      ++(t_diff_edge_n[ee]);

      if(p[ee]>1) {

        const double ksi_0i = (N[node_shift+edges_nodes[ee][1]]-N[node_shift+edges_nodes[ee][0]])*sense[ee];
        double psi_l[p[ee]+1],diff_psi_l[3*p[ee]+3];
        ierr = base_polynomials(p[ee],ksi_0i,&edge_diff_ksi[ee][0],psi_l,diff_psi_l,3); CHKERRQ(ierr);
        FTensor::Tensor1<double*,3> t_diff_psi_l(&diff_psi_l[0],&diff_psi_l[p[ee]+1],&diff_psi_l[2*p[ee]+2],1);

        for(int ll = 2;ll!=P[ee];ll++) {

          const double a = (double)(2*ll+1)/(double)(ll+1);
          const double b = (double)(ll)/(double)(ll+1);

          (t_edge_n[ee])(i) = a*psi_l[ll-1]*t_psi_e_1(i)-b*psi_l[ll-2]*t_psi_e_0(i);
          ++(t_edge_n[ee]);

          (t_diff_edge_n[ee])(i,j) = -b*(t_diff_psi_l(j)*t_psi_e_0(i)+psi_l[ll-2]*t_diff_psi_e_0(i,j));
          ++t_diff_psi_l;
          (t_diff_edge_n[ee])(i,j) += a*(t_diff_psi_l(j)*t_psi_e_1(i)+psi_l[ll-1]*t_diff_psi_e_1(i,j));
          ++(t_diff_edge_n[ee]);

        }
      }

    }
  }

  PetscFunctionReturn(0);
}

Hcurl_EdgeBaseFunctions_MBTET_ON_EDGE()

PetscErrorCode MoFEM::Hcurl_EdgeBaseFunctions_MBTET_ON_EDGE	(	int	sense,
		int	p,
		double *	N,
		double *	diffN,
		double *	edgeN,
		double *	diff_edgeN,
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Edge based H-curl base functions on edge.

Function generates hierarchical base of h-curl comforting functions on tetrahedral edge. For more details see [2].

On each edge we have P+1 functions. See NBEDGE_HCURL

Parameters

sense	sense fo edge (i.e. unique orientation)
p	array of oder for each edge
N	array shape functions evaluated at each integration point
diffN	derivatives of shape functions
edgeN	base functions on edges
diff_edgeN	derivatives of edge shape functions
nb_integration_pts	number of integration points
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 160 of file Hcurl.cpp.

  {
  PetscFunctionBegin;
  PetscErrorCode ierr;

  if(NBEDGE_HCURL(p)==0) PetscFunctionReturn(0);
  if(diff_edge_n!=NULL) {
    SETERRQ(PETSC_COMM_SELF,MOFEM_NOT_IMPLEMENTED,"Calculation of derivatives not implemented");
  }

  FTensor::Index<'i',3> i;
  FTensor::Tensor1<double,3> t_node_diff_ksi[2];
  t_node_diff_ksi[0](0) = diffN[0];
  t_node_diff_ksi[0](1) = 0;
  t_node_diff_ksi[0](2) = 0;
  t_node_diff_ksi[1](0) = diffN[1];
  t_node_diff_ksi[1](1) = 0;
  t_node_diff_ksi[1](2) = 0;

  FTensor::Tensor1<double*,3> t_edge_n(&edge_n[0],&edge_n[1],&edge_n[2],3);
  FTensor::Tensor1<double,3> t_psi_e_0,t_psi_e_1;

  for(int ii = 0;ii!=nb_integration_pts;ii++) {

    const int node_shift = ii*2;

    t_psi_e_0(i) = (N[node_shift+1]*t_node_diff_ksi[0](i)-N[node_shift+0]*t_node_diff_ksi[1](i))*sense;
    t_psi_e_1(i) = N[node_shift+1]*t_node_diff_ksi[0](i)+N[node_shift+0]*t_node_diff_ksi[1](i);
    t_edge_n(i) = t_psi_e_0(i);
    ++t_edge_n;
    t_edge_n(i) = t_psi_e_1(i);
    ++t_edge_n;

    if(p>1) {
      const double ksi_0i = (N[node_shift+1]-N[node_shift+0])*sense;
      double psi_l[p+1];
      ierr = base_polynomials(p,ksi_0i,NULL,psi_l,NULL,3); CHKERRQ(ierr);
      for(int ll = 2;ll!=NBEDGE_HCURL(p);ll++) {
        const double a = (double)(2*ll+1)/(double)(ll+1);
        const double b = (double)(ll)/(double)(ll+1);
        t_edge_n(i) = a*psi_l[ll-1]*t_psi_e_1(i)-b*psi_l[ll-2]*t_psi_e_0(i);
        ++t_edge_n;
      }
    }

  }

  PetscFunctionReturn(0);
}

Hcurl_EdgeBaseFunctions_MBTET_ON_FACE()

PetscErrorCode MoFEM::Hcurl_EdgeBaseFunctions_MBTET_ON_FACE	(	int *	sense,
		int *	p,
		double *	N,
		double *	diffN,
		double *	edgeN[],
		double *	diff_edgeN[],
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Edge based H-curl base functions on face.

Function generates hierarchical base of h-curl comforting functions on tetrahedral edge. For more details see [2].

On each face's edge we have P+1 functions. See NBEDGE_HCURL

Parameters

sense	sense fo edge (i.e. unique orientation)
p	array of oder for each edge
N	array shape functions evaluated at each integration point
diffN	derivatives of shape functions
edgeN	base functions on edges
diff_edgeN	derivatives of edge shape functions
nb_integration_pts	number of integration points
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 212 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  // TODO This is not by atom tests properly

  const int edges_nodes[3][2] = { {0,1}, {1,2}, {2,0} };
  int P[3];
  for(int ee = 0;ee<3; ee++) P[ee] = NBEDGE_HCURL(p[ee]);

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',2> j;

  FTensor::Tensor1<double,3> t_node_diff_ksi[3] = {
    FTensor::Tensor1<double,3>(diffN[0],diffN[1],0),
    FTensor::Tensor1<double,3>(diffN[2],diffN[3],0),
    FTensor::Tensor1<double,3>(diffN[4],diffN[5],0),
  };
  FTensor::Tensor1<double,2> t_2d_diff_ksi[3] = {
    FTensor::Tensor1<double,2>(diffN[0],diffN[1]),
    FTensor::Tensor1<double,2>(diffN[2],diffN[3]),
    FTensor::Tensor1<double,2>(diffN[4],diffN[5])
  };

  FTensor::Tensor1<double*,3> t_edge_n[3] = {
    FTensor::Tensor1<double*,3>(&edge_n[0][0],&edge_n[0][1],&edge_n[0][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[1][0],&edge_n[1][1],&edge_n[1][2],3),
    FTensor::Tensor1<double*,3>(&edge_n[2][0],&edge_n[2][1],&edge_n[2][2],3)
  };
  FTensor::Tensor2<double*,3,2> t_diff_edge_n[3] = {
    FTensor::Tensor2<double*,3,2>(
      &diff_edge_n[0][HCURL0_0],&diff_edge_n[0][HCURL0_1],
      &diff_edge_n[0][HCURL1_0],&diff_edge_n[0][HCURL1_1],
      &diff_edge_n[0][HCURL2_0],&diff_edge_n[0][HCURL2_1],6
    ),
    FTensor::Tensor2<double*,3,2>(
      &diff_edge_n[1][HCURL0_0],&diff_edge_n[1][HCURL0_1],
      &diff_edge_n[1][HCURL1_0],&diff_edge_n[1][HCURL1_1],
      &diff_edge_n[1][HCURL2_0],&diff_edge_n[1][HCURL2_1],6
    ),
    FTensor::Tensor2<double*,3,2>(
      &diff_edge_n[2][HCURL0_0],&diff_edge_n[2][HCURL0_1],
      &diff_edge_n[2][HCURL1_0],&diff_edge_n[2][HCURL1_1],
      &diff_edge_n[2][HCURL2_0],&diff_edge_n[2][HCURL2_1],6
    )
  };

  FTensor::Tensor1<double,3> t_psi_e_0,t_psi_e_1;
  FTensor::Tensor2<double,3,2> t_diff_psi_e_0,t_diff_psi_e_1;

  for(int ee = 0;ee!=3;ee++) {

    if(P[ee]==0) continue;
    const int node0 = edges_nodes[ee][0];
    const int node1 = edges_nodes[ee][1];
    const int sense_edge = sense[ee];

    t_diff_psi_e_0(i,j) =
    (t_node_diff_ksi[node0](i)*t_2d_diff_ksi[node1](j)-
    t_node_diff_ksi[node1](i)*t_2d_diff_ksi[node0](j))*sense_edge;
    t_diff_psi_e_1(i,j) =
    t_node_diff_ksi[node0](i)*t_2d_diff_ksi[node1](j)+
    t_node_diff_ksi[node1](i)*t_2d_diff_ksi[node0](j);

    for(int ii = 0;ii!=nb_integration_pts;ii++) {

      const int node_shift = ii*3;
      const double n0 = N[node_shift+node0];
      const double n1 = N[node_shift+node1];

      t_psi_e_0(i) = (n1*t_node_diff_ksi[node0](i)-n0*t_node_diff_ksi[node1](i))*sense_edge;
      t_psi_e_1(i) = n1*t_node_diff_ksi[node0](i)+n0*t_node_diff_ksi[node1](i);

      (t_edge_n[ee])(i) = t_psi_e_0(i);
      (t_diff_edge_n[ee])(i,j) = t_diff_psi_e_0(i,j);
      ++(t_edge_n[ee]);
      ++(t_diff_edge_n[ee]);
      (t_edge_n[ee])(i) = t_psi_e_1(i);
      (t_diff_edge_n[ee])(i,j) = t_diff_psi_e_1(i,j);
      ++(t_edge_n[ee]);
      ++(t_diff_edge_n[ee]);

      if(p[ee]>1) {
        const double ksi_0i = (n1-n0)*sense_edge;
        double diff_ksi_0i[] = {
          ((t_2d_diff_ksi[node1])(0)-(t_2d_diff_ksi[node0])(0))*sense_edge,
          ((t_2d_diff_ksi[node1])(1)-(t_2d_diff_ksi[node0])(1))*sense_edge
        };

        double psi_l[p[ee]+1],diff_psi_l[2*p[ee]+2];
        ierr = base_polynomials(p[ee],ksi_0i,diff_ksi_0i,psi_l,diff_psi_l,2); CHKERRQ(ierr);
        FTensor::Tensor1<double*,2> t_diff_psi_ll_m1(&diff_psi_l[0+2-1],&diff_psi_l[p[ee]+1+2-1],1);
        FTensor::Tensor1<double*,2> t_diff_psi_ll_m2(&diff_psi_l[0+2-2],&diff_psi_l[p[ee]+1+2-2],1);
        for(int ll = 2;ll!=P[ee];ll++) {
          const double a = (double)(2*ll+1)/(double)(ll+1);
          const double b = (double)(ll)/(double)(ll+1);
          (t_edge_n[ee])(i) = a*psi_l[ll-1]*t_psi_e_1(i)-b*psi_l[ll-2]*t_psi_e_0(i);
          (t_diff_edge_n[ee])(i,j) =
          a*t_psi_e_1(i)*t_diff_psi_ll_m1(j)+a*psi_l[ll-1]*t_diff_psi_e_1(i,j)-
          b*t_psi_e_0(i)*t_diff_psi_ll_m2(j)-b*psi_l[ll-2]*t_diff_psi_e_0(i,j);
          ++(t_edge_n[ee]);
          ++(t_diff_edge_n[ee]);
          ++t_diff_psi_ll_m1;
          ++t_diff_psi_ll_m2;
        }
      }

    }
  }

  PetscFunctionReturn(0);
}

Hcurl_FaceFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_FaceFunctions_MBTET	(	int *	face_nodes,
		int *	p,
		double *	N,
		double *	diffN,
		double *	phi_f[4],
		double *	diff_phi_f[4],
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face H-curl functions.

Face H-curl functions are set of Eddge-Based Face functions (Hcurl_EdgeBasedFaceFunctions_MBTET) and Bubble-Face functions (Hcurl_BubbleFaceFunctions_MBTET).

See NBVOLUMETET_FACE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	nodal shape functions
diffN	derivatives of nodal shape functions
phi_f[4]	calculated shape functions for each face
diff_phi_v[4]	derivatives of shape functions for each face
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 1018 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  try {

    MatrixDouble base_face_edge_functions[4];
    MatrixDouble diff_base_face_edge_functions[4];
    double *phi_f_e[4][3];
    double *diff_phi_f_e[4][3];
    for(int ff = 0;ff!=4;ff++) {
      if(NBFACETRI_EDGE_HCURL(p[ff])==0) {
        for(int ee = 0;ee!=3;ee++) {
          phi_f_e[ff][ee] = NULL;
          diff_phi_f_e[ff][ee] = NULL;
        }
      } else {
        base_face_edge_functions[ff].resize(3,3*NBFACETRI_EDGE_HCURL(p[ff])*nb_integration_pts);
        diff_base_face_edge_functions[ff].resize(3,9*NBFACETRI_EDGE_HCURL(p[ff])*nb_integration_pts);
        // base_face_edge_functions[ff].clear();
        // diff_base_face_edge_functions[ff].clear();
        for(int ee = 0;ee!=3;ee++) {
          phi_f_e[ff][ee] = &base_face_edge_functions[ff](ee,0);
          diff_phi_f_e[ff][ee] = &diff_base_face_edge_functions[ff](ee,0);
        }
      }
    }
    ierr = Hcurl_EdgeBasedFaceFunctions_MBTET(
      face_nodes,p,N,diffN,phi_f_e,diff_phi_f_e,nb_integration_pts,base_polynomials
    ); CHKERRQ(ierr);

    VectorDouble base_face_bubble_functions[4];
    VectorDouble diff_base_face_bubble_functions[4];
    double *phi_f_f[4];
    double *diff_phi_f_f[4];
    for(int ff=0;ff!=4;ff++) {
      int nb_dofs = NBFACETRI_FACE_HCURL(p[ff]);
      if(nb_dofs==0) {
        phi_f_f[ff] = NULL;
        diff_phi_f_f[ff] = NULL;
      } else {
        base_face_bubble_functions[ff].resize(3*nb_dofs*nb_integration_pts,false);
        diff_base_face_bubble_functions[ff].resize(9*nb_dofs*nb_integration_pts,false);
        phi_f_f[ff] = &*base_face_bubble_functions[ff].data().begin();
        diff_phi_f_f[ff] = &*diff_base_face_bubble_functions[ff].data().begin();
      }
    }
    ierr = Hcurl_BubbleFaceFunctions_MBTET(
      face_nodes,p,N,diffN,phi_f_f,diff_phi_f_f,nb_integration_pts,base_polynomials
    ); CHKERRQ(ierr);

    FTensor::Index<'i',3> i;
    FTensor::Index<'j',3> j;

    for(int ff = 0;ff!=4;ff++) {

      if(NBFACETRI_EDGE_HCURL(p[ff])==0) continue;

      FTensor::Tensor1<double*,3> t_face_edge_base[] = {
        FTensor::Tensor1<double*,3>(&phi_f_e[ff][0][0],&phi_f_e[ff][0][1],&phi_f_e[ff][0][2],3),
        FTensor::Tensor1<double*,3>(&phi_f_e[ff][1][0],&phi_f_e[ff][1][1],&phi_f_e[ff][1][2],3),
        FTensor::Tensor1<double*,3>(&phi_f_e[ff][2][0],&phi_f_e[ff][2][1],&phi_f_e[ff][2][2],3)
      };
      FTensor::Tensor2<double*,3,3> t_diff_face_edge_base[]= {
        FTensor::Tensor2<double*,3,3>(
          &diff_phi_f_e[ff][0][0],&diff_phi_f_e[ff][0][3],&diff_phi_f_e[ff][0][6],
          &diff_phi_f_e[ff][0][1],&diff_phi_f_e[ff][0][4],&diff_phi_f_e[ff][0][7],
          &diff_phi_f_e[ff][0][2],&diff_phi_f_e[ff][0][5],&diff_phi_f_e[ff][0][8],9
        ),
        FTensor::Tensor2<double*,3,3>(
          &diff_phi_f_e[ff][1][0],&diff_phi_f_e[ff][1][3],&diff_phi_f_e[ff][1][6],
          &diff_phi_f_e[ff][1][1],&diff_phi_f_e[ff][1][4],&diff_phi_f_e[ff][1][7],
          &diff_phi_f_e[ff][1][2],&diff_phi_f_e[ff][1][5],&diff_phi_f_e[ff][1][8],9
        ),
        FTensor::Tensor2<double*,3,3>(
          &diff_phi_f_e[ff][2][0],&diff_phi_f_e[ff][2][3],&diff_phi_f_e[ff][2][6],
          &diff_phi_f_e[ff][2][1],&diff_phi_f_e[ff][2][4],&diff_phi_f_e[ff][2][7],
          &diff_phi_f_e[ff][2][2],&diff_phi_f_e[ff][2][5],&diff_phi_f_e[ff][2][8],9
        )
      };

      FTensor::Tensor1<double*,3> t_face_base(&phi_f[ff][0],&phi_f[ff][1],&phi_f[ff][2],3);
      FTensor::Tensor2<double*,3,3> t_diff_face_base(
        &diff_phi_f[ff][0],&diff_phi_f[ff][3],&diff_phi_f[ff][6],
        &diff_phi_f[ff][1],&diff_phi_f[ff][4],&diff_phi_f[ff][7],
        &diff_phi_f[ff][2],&diff_phi_f[ff][5],&diff_phi_f[ff][8],9
      );

      if(NBFACETRI_FACE_HCURL(p[ff])>0) {
        FTensor::Tensor1<double*,3> t_face_face_base(&phi_f_f[ff][0],&phi_f_f[ff][1],&phi_f_f[ff][2],3);
        FTensor::Tensor2<double*,3,3> t_diff_face_face_base(
          &diff_phi_f_f[ff][0],&diff_phi_f_f[ff][3],&diff_phi_f_f[ff][6],
          &diff_phi_f_f[ff][1],&diff_phi_f_f[ff][4],&diff_phi_f_f[ff][7],
          &diff_phi_f_f[ff][2],&diff_phi_f_f[ff][5],&diff_phi_f_f[ff][8],9
        );
        for(int ii = 0;ii!=nb_integration_pts;ii++) {
          int cc = 0;
          for(int oo = 0;oo<=p[ff];oo++) {
            // Face-edge base
            if(oo>1) {
              for(int ee = 0;ee!=3;ee++) {
                for(int ll = NBFACETRI_EDGE_HCURL(oo-1);ll!=NBFACETRI_EDGE_HCURL(oo);ll++) {
                  t_face_base(i) = t_face_edge_base[ee](i);
                  ++cc;
                  ++t_face_base;
                  ++t_face_edge_base[ee];
                  t_diff_face_base(i,j) = t_diff_face_edge_base[ee](i,j);
                  ++t_diff_face_base;
                  ++t_diff_face_edge_base[ee];
                  // cerr << oo << " " << ll << " " << cc << " " << NBFACETRI_EDGE_HCURL(oo) << endl;
                }
              }
            }
            // Face-face base
            if(oo>2) {
              for(int ll = NBFACETRI_FACE_HCURL(oo-1);ll!=NBFACETRI_FACE_HCURL(oo);ll++) {
                t_face_base(i) = t_face_face_base(i);
                ++cc;
                ++t_face_base;
                ++t_face_face_base;
                t_diff_face_base(i,j) = t_diff_face_face_base(i,j);
                ++t_diff_face_base;
                ++t_diff_face_face_base;
              }
            }
          }
          // check consistency
          const int nb_base_fun_on_face = NBFACETRI_HCURL(p[ff]);
          if(cc!=nb_base_fun_on_face) {
            SETERRQ2(
              PETSC_COMM_SELF,
              MOFEM_DATA_INCONSISTENCY,
              "Wrong number of base functions %d != %d",
              cc,nb_base_fun_on_face
            );
          }
        }
      } else {
        for(int ii = 0;ii!=nb_integration_pts;ii++) {
          int cc = 0;
          for(int oo = 0;oo<=p[ff];oo++) {
            // Face-edge base
            if(oo>1) {
              for(int ee = 0;ee!=3;ee++) {
                for(int ll = NBFACETRI_EDGE_HCURL(oo-1);ll!=NBFACETRI_EDGE_HCURL(oo);ll++) {
                  t_face_base(i) = t_face_edge_base[ee](i);
                  ++cc;
                  ++t_face_base;
                  ++t_face_edge_base[ee];
                  t_diff_face_base(i,j) = t_diff_face_edge_base[ee](i,j);
                  ++t_diff_face_base;
                  ++t_diff_face_edge_base[ee];
                  // cerr << oo << " " << ll << " " << cc << " " << NBFACETRI_EDGE_HCURL(oo) << endl;
                }
              }
            }
          }
          // check consistency
          const int nb_base_fun_on_face = NBFACETRI_HCURL(p[ff]);
          if(cc!=nb_base_fun_on_face) {
            SETERRQ2(
              PETSC_COMM_SELF,
              MOFEM_DATA_INCONSISTENCY,
              "Wrong number of base functions %d != %d",
              cc,nb_base_fun_on_face
            );
          }
        }
      }
    }

  } catch (MoFEMException const &e) {
    SETERRQ(PETSC_COMM_SELF,e.errorCode,e.errorMessage);
  } catch (std::exception& ex) {
    std::ostringstream ss;
    ss << "thorw in method: " << ex.what() << " at line " << __LINE__ << " in file " << __FILE__;
    SETERRQ(PETSC_COMM_SELF,MOFEM_STD_EXCEPTION_THROW,ss.str().c_str());
  }

  PetscFunctionReturn(0);
}

Hcurl_FaceFunctions_MBTET_ON_FACE()

PetscErrorCode MoFEM::Hcurl_FaceFunctions_MBTET_ON_FACE	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_f,
		double *	diff_phi_f,
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face H-curl functions.

Face H-curl functions are set of Eddge-Based Face functions (Hcurl_EdgeBasedFaceFunctions_MBTET) and Bubble-Face functions (Hcurl_BubbleFaceFunctions_MBTET).

See NBVOLUMETET_FACE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	nodal shape functions
diffN	derivatives of nodal shape functions
phi_f[4]	calculated shape functions for each face
diff_phi_v[4]	derivatives of shape functions for each face
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 1203 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  if(NBFACETRI_EDGE_HCURL(p)==0) PetscFunctionReturn(0);

  MatrixDouble base_face_edge_functions,diff_base_face_edge_functions;
  double *phi_f_e[3];
  double *diff_phi_f_e[3];
  base_face_edge_functions.resize(
    3,3*NBFACETRI_EDGE_HCURL(p)*nb_integration_pts
  );
  diff_base_face_edge_functions.resize(
    3,2*3*NBFACETRI_EDGE_HCURL(p)*nb_integration_pts
  );
  // base_face_edge_functions.clear();
  for(int ee = 0;ee!=3;ee++) {
    phi_f_e[ee] = &base_face_edge_functions(ee,0);
    diff_phi_f_e[ee] = &diff_base_face_edge_functions(ee,0);
  }
  ierr = Hcurl_EdgeBasedFaceFunctions_MBTET_ON_FACE(
    faces_nodes,p,N,diffN,phi_f_e,diff_phi_f_e,nb_integration_pts,base_polynomials
  ); CHKERRQ(ierr);

  VectorDouble base_face_bubble_functions;
  VectorDouble diff_base_face_bubble_functions;
  double *phi_f_f,*diff_phi_f_f;
  base_face_bubble_functions.resize(3*NBFACETRI_FACE_HCURL(p)*nb_integration_pts);
  diff_base_face_bubble_functions.resize(2*3*NBFACETRI_FACE_HCURL(p)*nb_integration_pts);
  phi_f_f = &*base_face_bubble_functions.data().begin();
  diff_phi_f_f = &*diff_base_face_bubble_functions.data().begin();
  ierr = Hcurl_BubbleFaceFunctions_MBTET_ON_FACE(
    faces_nodes,p,N,diffN,phi_f_f,diff_phi_f_f,nb_integration_pts,base_polynomials
  ); CHKERRQ(ierr);
  // cerr << diff_base_face_bubble_functions << endl;

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',2> j;

  FTensor::Tensor1<double*,3> t_face_edge_base[]= {
    FTensor::Tensor1<double*,3>(&phi_f_e[0][HCURL0],&phi_f_e[0][HCURL1],&phi_f_e[0][HCURL2],3),
    FTensor::Tensor1<double*,3>(&phi_f_e[1][HCURL0],&phi_f_e[1][HCURL1],&phi_f_e[1][HCURL2],3),
    FTensor::Tensor1<double*,3>(&phi_f_e[2][HCURL0],&phi_f_e[2][HCURL1],&phi_f_e[2][HCURL2],3)
  };
  FTensor::Tensor2<double*,3,2> t_diff_face_edge_base[]= {
    FTensor::Tensor2<double*,3,2>(
      &diff_phi_f_e[0][HCURL0_0],&diff_phi_f_e[0][HCURL0_1],
      &diff_phi_f_e[0][HCURL1_0],&diff_phi_f_e[0][HCURL1_1],
      &diff_phi_f_e[0][HCURL2_0],&diff_phi_f_e[0][HCURL2_1],6
    ),
    FTensor::Tensor2<double*,3,2>(
      &diff_phi_f_e[1][HCURL0_0],&diff_phi_f_e[1][HCURL0_1],
      &diff_phi_f_e[1][HCURL1_0],&diff_phi_f_e[1][HCURL1_1],
      &diff_phi_f_e[1][HCURL2_0],&diff_phi_f_e[1][HCURL2_1],6
    ),
    FTensor::Tensor2<double*,3,2>(
      &diff_phi_f_e[2][HCURL0_0],&diff_phi_f_e[2][HCURL0_1],
      &diff_phi_f_e[2][HCURL1_0],&diff_phi_f_e[2][HCURL1_1],
      &diff_phi_f_e[2][HCURL2_0],&diff_phi_f_e[2][HCURL2_1],6
    )
  };

  FTensor::Tensor1<double*,3> t_face_base(&phi_f[0],&phi_f[1],&phi_f[2],3);
  FTensor::Tensor2<double*,3,2> t_diff_face_base(
    &diff_phi_f[HCURL0_0],&diff_phi_f[HCURL0_1],
    &diff_phi_f[HCURL1_0],&diff_phi_f[HCURL1_1],
    &diff_phi_f[HCURL2_0],&diff_phi_f[HCURL2_1],6
  );

  if(NBFACETRI_FACE_HCURL(p)>0) {
    FTensor::Tensor1<double*,3> t_face_face_base(
      &phi_f_f[HCURL0],&phi_f_f[HCURL1],&phi_f_f[HCURL2],3
    );
    FTensor::Tensor2<double*,3,2> t_diff_face_face_base(
      &diff_phi_f_f[HCURL0_0],&diff_phi_f_f[HCURL0_1],
      &diff_phi_f_f[HCURL1_0],&diff_phi_f_f[HCURL1_1],
      &diff_phi_f_f[HCURL2_0],&diff_phi_f_f[HCURL2_1],6
    );
    for(int ii = 0;ii!=nb_integration_pts;ii++) {
      int cc = 0;
      for(int oo = 0;oo<=p;oo++) {
        // Face-edge base
        if(oo>1) {
          for(int ee = 0;ee!=3;ee++) {
            for(int ll = NBFACETRI_EDGE_HCURL(oo-1);ll!=NBFACETRI_EDGE_HCURL(oo);ll++) {
              t_face_base(i) = t_face_edge_base[ee](i);
              t_diff_face_base(i,j) = t_diff_face_edge_base[ee](i,j);
              ++cc;
              ++t_face_base;
              ++t_face_edge_base[ee];
              ++t_diff_face_base;
              ++t_diff_face_edge_base[ee];
            }
          }
        }
        // Face-face base
        if(oo>2) {
          for(int ll = NBFACETRI_FACE_HCURL(oo-1);ll!=NBFACETRI_FACE_HCURL(oo);ll++) {
            t_face_base(i) = t_face_face_base(i);
            t_diff_face_base(i,j) = t_diff_face_face_base(i,j);
            ++cc;
            ++t_face_base;
            ++t_face_face_base;
            ++t_diff_face_base;
            ++t_diff_face_face_base;
          }
        }
      }
      // check consistency
      const int nb_base_fun_on_face = NBFACETRI_HCURL(p);
      if(cc!=nb_base_fun_on_face) {
        SETERRQ2(
          PETSC_COMM_SELF,
          MOFEM_DATA_INCONSISTENCY,
          "Wrong number of base functions %d != %d",
          cc,nb_base_fun_on_face
        );
      }
    }
  } else {
    for(int ii = 0;ii!=nb_integration_pts;ii++) {
      int cc = 0;
      for(int oo = 0;oo<=p;oo++) {
        // Face-edge base
        if(oo>1) {
          for(int ee = 0;ee!=3;ee++) {
            for(int ll = NBFACETRI_EDGE_HCURL(oo-1);ll!=NBFACETRI_EDGE_HCURL(oo);ll++) {
              t_face_base(i) = t_face_edge_base[ee](i);
              t_diff_face_base(i,j) = t_diff_face_edge_base[ee](i,j);
              ++cc;
              ++t_face_base;
              ++t_face_edge_base[ee];
              ++t_diff_face_base;
              ++t_diff_face_edge_base[ee];
              // cerr << oo << " " << ll << " " << cc << " " << NBFACETRI_EDGE_HCURL(oo) << endl;
            }
          }
        }
      }
      // check consistency
      const int nb_base_fun_on_face = NBFACETRI_HCURL(p);
      if(cc!=nb_base_fun_on_face) {
        SETERRQ2(
          PETSC_COMM_SELF,
          MOFEM_DATA_INCONSISTENCY,
          "Wrong number of base functions %d != %d",
          cc,nb_base_fun_on_face
        );
      }
    }
  }

  PetscFunctionReturn(0);
}

Hcurl_FaceInteriorFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_FaceInteriorFunctions_MBTET	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_v,
		double *	diff_phi_v,
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face base interior function.

On each face we have P*(P-1)/2 and are 4 faces on Tetrahedral.

See NBFACETRI_FACE_HCURL

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
N	nodal shape functions
diffN	derivatives of nodal shape functions
phi_v	calculated shape functions
diff_phi_v	derivatives of shape functions
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 735 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  if(NBVOLUMETET_FACE_HCURL(p)==0) PetscFunctionReturn(0);

  const int face_opposite_nodes[] = { 2,0,1,3 };

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };
  FTensor::Tensor1<double,3> t_diff_ksi0i,t_diff_ksi0j;

  MatrixDouble m_psi_l_0i(4,p+1);
  MatrixDouble m_psi_l_0j(4,p+1);
  MatrixDouble m_diff_psi_l_0i(4,3*p+3);
  MatrixDouble m_diff_psi_l_0j(4,3*p+3);

  double* psi_l_0i[] = {
    &m_psi_l_0i(0,0),&m_psi_l_0i(1,0),&m_psi_l_0i(2,0),&m_psi_l_0i(3,0)
  };
  double* psi_l_0j[] = {
    &m_psi_l_0j(0,0),&m_psi_l_0j(1,0),&m_psi_l_0j(2,0),&m_psi_l_0j(3,0)
  };
  double* diff_psi_l_0i[] = {
    &m_diff_psi_l_0i(0,0),&m_diff_psi_l_0i(1,0),&m_diff_psi_l_0i(2,0),&m_diff_psi_l_0i(3,0)
  };
  double* diff_psi_l_0j[] = {
    &m_diff_psi_l_0j(0,0),&m_diff_psi_l_0j(1,0),&m_diff_psi_l_0j(2,0),&m_diff_psi_l_0j(3,0)
  };
  double beta_f[4];

  FTensor::Tensor1<double,3> t_diff_beta_f[4];

  FTensor::Tensor1<double*,3> t_phi_v(&phi_v[0],&phi_v[1],&phi_v[2],3);
  FTensor::Tensor2<double*,3,3> t_diff_phi_v(
    &diff_phi_v[0],&diff_phi_v[3],&diff_phi_v[6],
    &diff_phi_v[1],&diff_phi_v[4],&diff_phi_v[7],
    &diff_phi_v[2],&diff_phi_v[5],&diff_phi_v[8],9
  );

  for(int ii = 0;ii!=nb_integration_pts;ii++) {

    for(int ff = 0;ff!=4;ff++) {

      t_diff_ksi0i(i) =
      t_node_diff_ksi[faces_nodes[3*ff+1]](i)-t_node_diff_ksi[faces_nodes[3*ff+0]](i);
      t_diff_ksi0j(i) =
      t_node_diff_ksi[faces_nodes[3*ff+2]](i)-t_node_diff_ksi[faces_nodes[3*ff+0]](i);

      const int node_shift = ii*4;

      beta_f[ff] =
      N[node_shift+faces_nodes[3*ff+0]]*N[node_shift+faces_nodes[3*ff+1]]*
      N[node_shift+faces_nodes[3*ff+2]];

      t_diff_beta_f[ff](j) =
      t_node_diff_ksi[faces_nodes[3*ff+0]](j)*N[node_shift+faces_nodes[3*ff+1]]*N[node_shift+faces_nodes[3*ff+2]]+
      N[node_shift+faces_nodes[3*ff+0]]*t_node_diff_ksi[faces_nodes[3*ff+1]](j)*N[node_shift+faces_nodes[3*ff+2]]+
      N[node_shift+faces_nodes[3*ff+0]]*N[node_shift+faces_nodes[3*ff+1]]*t_node_diff_ksi[faces_nodes[3*ff+2]](j);

      const double ksi_0i =
      N[node_shift+faces_nodes[3*ff+1]]-N[node_shift+faces_nodes[3*ff+0]];
      ierr = base_polynomials(
        p,ksi_0i,&t_diff_ksi0i(0),psi_l_0i[ff],diff_psi_l_0i[ff],3
      ); CHKERRQ(ierr);

      const double ksi_0j =
      N[node_shift+faces_nodes[3*ff+2]]-N[node_shift+faces_nodes[3*ff+0]];
      ierr = base_polynomials(
        p,ksi_0j,&t_diff_ksi0j(0),psi_l_0j[ff],diff_psi_l_0j[ff],3
      ); CHKERRQ(ierr);

    }

    int cc = 0;
    for(int oo = 0;oo<=(p-3);oo++) {
      FTensor::Tensor1<double*,3> t_diff_psi_l_0i[] = {
        FTensor::Tensor1<double*,3>(&diff_psi_l_0i[0][0],&diff_psi_l_0i[0][p+1],&diff_psi_l_0i[0][2*p+2],1),
        FTensor::Tensor1<double*,3>(&diff_psi_l_0i[1][0],&diff_psi_l_0i[1][p+1],&diff_psi_l_0i[1][2*p+2],1),
        FTensor::Tensor1<double*,3>(&diff_psi_l_0i[2][0],&diff_psi_l_0i[2][p+1],&diff_psi_l_0i[2][2*p+2],1),
        FTensor::Tensor1<double*,3>(&diff_psi_l_0i[3][0],&diff_psi_l_0i[3][p+1],&diff_psi_l_0i[3][2*p+2],1),
      };
      for(int pp0 = 0;pp0<=oo;pp0++) {
        const int pp1 = oo-pp0;
        if(pp1>=0) {
          for(int ff = 0;ff!=4;ff++) {
            FTensor::Tensor1<double*,3> t_diff_psi_l_0j(
              &m_diff_psi_l_0j(ff,pp1),
              &m_diff_psi_l_0j(ff,p+1+pp1),
              &m_diff_psi_l_0j(ff,2*p+2+pp1),1
            );
            const double t = psi_l_0i[ff][pp0]*psi_l_0j[ff][pp1];
            const double a = beta_f[ff]*t;
            t_phi_v(i) = a*t_node_diff_ksi[face_opposite_nodes[ff]](i);
            ++t_phi_v;
            ++cc;
            t_diff_phi_v(i,j) = (
              t_diff_beta_f[ff](j)*t+
              beta_f[ff]*t_diff_psi_l_0i[ff](j)*psi_l_0j[ff][pp1]+
              beta_f[ff]*psi_l_0i[ff][pp0]*t_diff_psi_l_0j(j)
            )*t_node_diff_ksi[face_opposite_nodes[ff]](i);
            ++t_diff_phi_v;
            ++t_diff_psi_l_0i[ff];
          }
        }
      }
    }

    const int nb_base_fun_on_face = NBVOLUMETET_FACE_HCURL(p);
    if(cc!=nb_base_fun_on_face) {
      SETERRQ2(
        PETSC_COMM_SELF,
        MOFEM_DATA_INCONSISTENCY,
        "Wrong number of base functions %d != %d",
        cc,nb_base_fun_on_face
      );
    }

  }

  PetscFunctionReturn(0);
}

Hcurl_VolumeFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_VolumeFunctions_MBTET	(	int	p,
		double *	N,
		double *	diffN,
		double *	phi_v,
		double *	diff_phi_v,
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

H-curl volume base functions.

Volume base functions are collection of iace interior base functions and volume interior base functions.

Parameters

p	approximation order
N	nodal shape functions
diffN	derivatives of nodal shape functions
phi_v	calculated shape functions
diff_phi_v	derivatives of shape functions
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 1361 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  VectorDouble base_face_inetrior_functions(3*NBVOLUMETET_FACE_HCURL(p)*nb_integration_pts);
  VectorDouble diff_base_face_inetrior_functions(9*NBVOLUMETET_FACE_HCURL(p)*nb_integration_pts);
  // base_face_inetrior_functions.clear();
  // diff_base_face_inetrior_functions.clear();
  double *phi_v_f = &*base_face_inetrior_functions.data().begin();
  double *diff_phi_v_f = &*diff_base_face_inetrior_functions.data().begin();
  int faces_nodes[] = { 0,1,3, 1,2,3, 0,2,3, 0,1,2 };
  ierr = Hcurl_FaceInteriorFunctions_MBTET(
    faces_nodes,p,N,diffN,phi_v_f,diff_phi_v_f,nb_integration_pts,base_polynomials
  ); CHKERRQ(ierr);

  VectorDouble base_interior_functions(3*NBVOLUMETET_TET_HCURL(p)*nb_integration_pts);
  VectorDouble diff_base_interior_functions(9*NBVOLUMETET_TET_HCURL(p)*nb_integration_pts);
  // base_interior_functions.clear();
  // diff_base_interior_functions.clear();
  double *phi_v_v = &*base_interior_functions.data().begin();
  double *diff_phi_v_v = &*diff_base_interior_functions.data().begin();
  ierr = Hcurl_VolumeInteriorFunctions_MBTET(
    p,N,diffN,phi_v_v,diff_phi_v_v,nb_integration_pts,base_polynomials
  ); CHKERRQ(ierr);

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double*,3> t_face_interior(&phi_v_f[0],&phi_v_f[1],&phi_v_f[2],3);
  FTensor::Tensor2<double*,3,3> t_diff_face_interior(
    &diff_phi_v_f[0],&diff_phi_v_f[3],&diff_phi_v_f[6],
    &diff_phi_v_f[1],&diff_phi_v_f[4],&diff_phi_v_f[7],
    &diff_phi_v_f[2],&diff_phi_v_f[5],&diff_phi_v_f[8],9
  );

  FTensor::Tensor1<double*,3> t_phi_v(&phi_v[0],&phi_v[1],&phi_v[2],3);
  FTensor::Tensor2<double*,3,3> t_diff_phi_v(
    &diff_phi_v[0],&diff_phi_v[3],&diff_phi_v[6],
    &diff_phi_v[1],&diff_phi_v[4],&diff_phi_v[7],
    &diff_phi_v[2],&diff_phi_v[5],&diff_phi_v[8],9
  );


  if(NBVOLUMETET_TET_HCURL(p)>0) {
    FTensor::Tensor1<double*,3> t_volume_interior(&phi_v_v[0],&phi_v_v[1],&phi_v_v[2],3);
    FTensor::Tensor2<double*,3,3> t_diff_volume_interior(
      &diff_phi_v_v[0],&diff_phi_v_v[3],&diff_phi_v_v[6],
      &diff_phi_v_v[1],&diff_phi_v_v[4],&diff_phi_v_v[7],
      &diff_phi_v_v[2],&diff_phi_v_v[5],&diff_phi_v_v[8],9
    );
    for(int ii = 0;ii!=nb_integration_pts;ii++) {
      int cc = 0;
      for(int oo = 0;oo<=p;oo++) {
        for(int ll = NBVOLUMETET_FACE_HCURL(oo-1);ll!=NBVOLUMETET_FACE_HCURL(oo);ll++) {
          t_phi_v(i) = t_face_interior(i);
          ++t_phi_v;
          ++t_face_interior;
          ++cc;
          t_diff_phi_v(i,j) = t_diff_face_interior(i,j);
          ++t_diff_phi_v;
          ++t_diff_face_interior;
        }
        for(int ll = NBVOLUMETET_TET_HCURL(oo-1);ll!=NBVOLUMETET_TET_HCURL(oo);ll++) {
          t_phi_v(i) = t_volume_interior(i);
          ++t_phi_v;
          ++t_volume_interior;
          ++cc;
          t_diff_phi_v(i,j) = t_diff_volume_interior(i,j);
          ++t_diff_phi_v;
          ++t_diff_volume_interior;
        }
      }
      // check consistency
      const int nb_base_fun_on_face = NBVOLUMETET_HCURL(p);
      if(cc!=nb_base_fun_on_face) {
        SETERRQ2(
          PETSC_COMM_SELF,
          MOFEM_DATA_INCONSISTENCY,
          "Wrong number of base functions %d != %d",
          cc,nb_base_fun_on_face
        );
      }
    }
  } else {
    for(int ii = 0;ii!=nb_integration_pts;ii++) {
      int cc = 0;
      for(int oo = 0;oo<=p;oo++) {
        for(int ll = NBVOLUMETET_FACE_HCURL(oo-1);ll!=NBVOLUMETET_FACE_HCURL(oo);ll++) {
          t_phi_v(i) = t_face_interior(i);
          ++t_phi_v;
          ++t_face_interior;
          ++cc;
          t_diff_phi_v(i,j) = t_diff_face_interior(i,j);
          ++t_diff_phi_v;
          ++t_diff_face_interior;
        }
      }
      // check consistency
      const int nb_base_fun_on_face = NBVOLUMETET_HCURL(p);
      if(cc!=nb_base_fun_on_face) {
        SETERRQ2(
          PETSC_COMM_SELF,
          MOFEM_DATA_INCONSISTENCY,
          "Wrong number of base functions %d != %d",
          cc,nb_base_fun_on_face
        );
      }
    }
  }

  PetscFunctionReturn(0);
}

Hcurl_VolumeInteriorFunctions_MBTET()

PetscErrorCode MoFEM::Hcurl_VolumeInteriorFunctions_MBTET	(	int	p,
		double *	N,
		double *	diffN,
		double *	phi_v,
		double *	diff_phi_v,
		int	nb_integration_pts,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Volume interior function.

On volume have (P-3)*(P-2)*(P-1)/2.

See NBVOLUMETET_TET_HCURL

Parameters

p	approximation order
N	nodal shape functions
diffN	derivatives of nodal shape functions
phi_v	calculated shape functions
diff_phi_v	derivatives of shape functions
nb_integration_pts	number of shape functions
base_polynomials	polynomial base function (f.e. Legendre of Lobatto)

Returns

error code

Definition at line 868 of file Hcurl.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;

  if(NBVOLUMETET_TET_HCURL(p)==0) PetscFunctionReturn(0);

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;
  FTensor::Number<0> N0;
  FTensor::Number<1> N1;
  FTensor::Number<2> N2;

  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };

  double diff_ksi0i[3],diff_ksi0j[3],diff_ksi0k[3];
  FTensor::Tensor1<double*,3> t_diff_ksi0i(diff_ksi0i,&diff_ksi0i[1],&diff_ksi0i[2]);
  FTensor::Tensor1<double*,3> t_diff_ksi0j(diff_ksi0j,&diff_ksi0j[1],&diff_ksi0j[2]);
  FTensor::Tensor1<double*,3> t_diff_ksi0k(diff_ksi0k,&diff_ksi0k[1],&diff_ksi0k[2]);
  t_diff_ksi0i(i) = t_node_diff_ksi[1](i)-t_node_diff_ksi[0](i);
  t_diff_ksi0j(i) = t_node_diff_ksi[2](i)-t_node_diff_ksi[0](i);
  t_diff_ksi0k(i) = t_node_diff_ksi[3](i)-t_node_diff_ksi[0](i);

  std::vector<double> v_psi_l_0i(p+1),v_diff_psi_l_0i(3*p+3);
  std::vector<double> v_psi_l_0j(p+1),v_diff_psi_l_0j(3*p+3);
  std::vector<double> v_psi_l_0k(p+1),v_diff_psi_l_0k(3*p+3);
  double *psi_l_0i = &*v_psi_l_0i.begin();
  double *diff_psi_l_0i = &*v_diff_psi_l_0i.begin();
  double *psi_l_0j = &*v_psi_l_0j.begin();
  double *diff_psi_l_0j = &*v_diff_psi_l_0j.begin();
  double *psi_l_0k = &*v_psi_l_0k.begin();
  double *diff_psi_l_0k = &*v_diff_psi_l_0k.begin();

  FTensor::Tensor1<double*,3> t_phi_v(&phi_v[0],&phi_v[1],&phi_v[2],3);
  FTensor::Tensor2<double*,3,3> t_diff_phi_v(
    &diff_phi_v[0],&diff_phi_v[3],&diff_phi_v[6],
    &diff_phi_v[1],&diff_phi_v[4],&diff_phi_v[7],
    &diff_phi_v[2],&diff_phi_v[5],&diff_phi_v[8],9
  );
  FTensor::Tensor1<double,3> t_b;

  for(int ii = 0;ii!=nb_integration_pts;ii++) {

    const int node_shift = ii*4;
    const int n0 = node_shift+0;
    const int n1 = node_shift+1;
    const int n2 = node_shift+2;
    const int n3 = node_shift+3;

    const double beta_v = N[n0]*N[n1]*N[n2]*N[n3];

    const double ksi_0i = N[n1]-N[n0];
    ierr = base_polynomials(p,ksi_0i,diff_ksi0i,psi_l_0i,diff_psi_l_0i,3); CHKERRQ(ierr);
    const double ksi_0j = N[n2]-N[n0];
    ierr = base_polynomials(p,ksi_0j,diff_ksi0j,psi_l_0j,diff_psi_l_0j,3); CHKERRQ(ierr);
    const double ksi_0k = N[n3]-N[n0];
    ierr = base_polynomials(p,ksi_0k,diff_ksi0k,psi_l_0k,diff_psi_l_0k,3); CHKERRQ(ierr);

    FTensor::Tensor1<double,3> t_diff_beta_v;
    t_diff_beta_v(j) =
    t_node_diff_ksi[0](j)*N[n1]*N[n2]*N[n3]+
    N[n0]*t_node_diff_ksi[1](j)*N[n2]*N[n3]+
    N[n0]*N[n1]*t_node_diff_ksi[2](j)*N[n3]+
    N[n0]*N[n1]*N[n2]*t_node_diff_ksi[3](j);

    int cc = 0;
    for(int oo = 0;oo<=(p-4);oo++) {
      FTensor::Tensor1<double*,3> t_diff_psi_l_0i(
        &diff_psi_l_0i[0],
        &diff_psi_l_0i[p+1],
        &diff_psi_l_0i[2*p+2],1
      );
      for(int pp0 = 0;pp0<=oo;pp0++) {
        FTensor::Tensor1<double*,3> t_diff_psi_l_0j(
          &diff_psi_l_0j[0],
          &diff_psi_l_0j[p+1],
          &diff_psi_l_0j[2*p+2],1
        );
        for(int pp1 = 0;(pp0+pp1)<=oo;pp1++) {
          const int pp2 = oo-pp0-pp1;
          if(pp2>=0) {
            FTensor::Tensor1<double*,3> t_diff_psi_l_0k(
              &diff_psi_l_0k[0+pp2],
              &diff_psi_l_0k[p+1+pp2],
              &diff_psi_l_0k[2*p+2+pp2],1
            );
            const double t = psi_l_0i[pp0]*psi_l_0j[pp1]*psi_l_0k[pp2];
            const double a = beta_v*t;
            t_phi_v(0) = a;
            t_phi_v(1) = 0;
            t_phi_v(2) = 0;
            ++t_phi_v;
            ++cc;
            t_phi_v(0) = 0;
            t_phi_v(1) = a;
            t_phi_v(2) = 0;
            ++t_phi_v;
            ++cc;
            t_phi_v(0) = 0;
            t_phi_v(1) = 0;
            t_phi_v(2) = a;
            ++t_phi_v;
            ++cc;
            t_b(j) =
            t_diff_beta_v(j)*t+
            beta_v*(
              t_diff_psi_l_0i(j)*psi_l_0j[pp1]*psi_l_0k[pp2]+
              psi_l_0i[pp0]*t_diff_psi_l_0j(j)*psi_l_0k[pp2]+
              psi_l_0i[pp0]*psi_l_0j[pp1]*t_diff_psi_l_0k(j)
            );
            t_diff_phi_v(N0,j) = t_b(j);
            t_diff_phi_v(N1,j) = 0;
            t_diff_phi_v(N2,j) = 0;
            ++t_diff_phi_v;
            t_diff_phi_v(N0,j) = 0;
            t_diff_phi_v(N1,j) = t_b(j);
            t_diff_phi_v(N2,j) = 0;
            ++t_diff_phi_v;
            t_diff_phi_v(N0,j) = 0;
            t_diff_phi_v(N1,j) = 0;
            t_diff_phi_v(N2,j) = t_b(j);
            ++t_diff_phi_v;
          }
          ++t_diff_psi_l_0j;
        }
        ++t_diff_psi_l_0i;
      }
    }

    const int nb_base_fun_on_face = NBVOLUMETET_TET_HCURL(p);
    if(cc!=nb_base_fun_on_face) {
      SETERRQ2(
        PETSC_COMM_SELF,
        MOFEM_DATA_INCONSISTENCY,
        "Wrong number of base functions %d != %d",
        cc,nb_base_fun_on_face
      );
    }

  }
  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_EdgeBasedVolumeShapeFunctions_MBTET()

PetscErrorCode MoFEM::Hdiv_Ainsworth_EdgeBasedVolumeShapeFunctions_MBTET	(	int	p,
		double *	N,
		double *	diffN,
		double *	phi_v_e[6],
		double *	diff_phi_v_e[6],
		int	gdim,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Hdiv base function, Edge-based interior (volume) functions by Ainsworth [1].

Parameters

p	volume approx. order
N	shape functions
diffN	derivatives of shape functions
phi_v_e	base functions (return)
diff_phi_v_e	derivatives of base functions (returned)
gdim	number of integration points
base_polynomials	base function (Legendre/Lobbatto-Gauss)

Returns

error code

Definition at line 273 of file Hdiv.cpp.

  {
  PetscErrorCode ierr;
  const int edges_nodes[6][2] = {
    {0,1}, {1,2}, {2,0}, {0,3}, {1,3}, {2,3}
  };

  PetscFunctionBegin;
  if(p<2) PetscFunctionReturn(0);
  if(diffN == NULL) {
    SETERRQ(PETSC_COMM_SELF,MOFEM_DATA_INCONSISTENCY,"data inconsistency");
  }

  FTensor::Tensor1<double,3> t_coords[4] = {
    FTensor::Tensor1<double,3>(0,0,0),
    FTensor::Tensor1<double,3>(1,0,0),
    FTensor::Tensor1<double,3>(0,1,0),
    FTensor::Tensor1<double,3>(0,0,1)
  };
  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double,3> t_tou_e;
  FTensor::Tensor1<double,3> t_diff_ksi0i;
  FTensor::Tensor1<double,3> t_diff_beta_e;

  double psi_l[p+1];
  double diff_psi_l[3*(p+1)];

  for(int ee = 0;ee!=6;ee++) {
    t_tou_e(i) =
    t_coords[edges_nodes[ee][1]](i)-t_coords[edges_nodes[ee][0]](i);
    t_diff_ksi0i(i) =
    t_node_diff_ksi[edges_nodes[ee][1]](i)-t_node_diff_ksi[edges_nodes[ee][0]](i);
    FTensor::Tensor1<double*,3> t_psi_v_e(
      &phi_v_e[ee][0],&phi_v_e[ee][1],&phi_v_e[ee][2],3
    );
    FTensor::Tensor2<double*,3,3> t_diff_phi_v_e(
      &diff_phi_v_e[ee][HDIV0_0],&diff_phi_v_e[ee][HDIV0_1],&diff_phi_v_e[ee][HDIV0_2],
      &diff_phi_v_e[ee][HDIV1_0],&diff_phi_v_e[ee][HDIV1_1],&diff_phi_v_e[ee][HDIV1_2],
      &diff_phi_v_e[ee][HDIV2_0],&diff_phi_v_e[ee][HDIV2_1],&diff_phi_v_e[ee][HDIV2_2],9
    );
    for(int ii = 0;ii!=gdim;ii++) {
      const int node_shift = ii*4;
      const double ni = N[node_shift+edges_nodes[ee][1]];
      const double n0 = N[node_shift+edges_nodes[ee][0]];
      const double beta_e = ni*n0;
      const double ksi0i = ni-n0;
      if(diff_phi_v_e) {
        t_diff_beta_e(i) =
        ni*t_node_diff_ksi[edges_nodes[ee][0]](i)+
        t_node_diff_ksi[edges_nodes[ee][1]](i)*n0;
        ierr = base_polynomials(p,ksi0i,&t_diff_ksi0i(0),psi_l,diff_psi_l,3); CHKERRQ(ierr);
      } else {
        ierr = base_polynomials(p,ksi0i,NULL,psi_l,NULL,3); CHKERRQ(ierr);
      }
      FTensor::Tensor0<double*> t_psi_l(&psi_l[0]);
      FTensor::Tensor1<double*,3> t_diff_psi_l(
        &diff_psi_l[0],&diff_psi_l[p+1],&diff_psi_l[2*p+2],1
      );
      for(int l = 0;l<=p-2;l++) {
        t_psi_v_e(i) = (beta_e*t_psi_l)*t_tou_e(i);
        ++t_psi_v_e;
        if(diff_phi_v_e) {
          t_diff_phi_v_e(i,j) =
          (t_diff_beta_e(j)*t_psi_l+beta_e*t_diff_psi_l(j))*
          t_tou_e(i);
          ++t_diff_phi_v_e;
          ++t_diff_psi_l;
        }
        ++t_psi_l;
      }
    }
  }

  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET()

PetscErrorCode MoFEM::Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET	(	int *	faces_nodes,
		int *	p,
		double *	N,
		double *	diffN,
		double *	phi_f_e[4][3],
		double *	diff_phi_f_e[4][3],
		int	gdim,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Hdiv base functions, Edge-based face functions by Ainsworth [1].

Parameters

faces_nodes	Face nodes on tetrahedral
p	Approximation order on faces
N	Shape functions
diffN	Derivatives of shape functions
phi_f_e	Base functions (returned)
diff_phi_f_e	Derivatives of base functions (returned)
gdim	Number of integration pts
base_polynomials	base function (Legendre/Lobbatto-Gauss)

Returns

error code

Definition at line 19 of file Hdiv.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;
  for(int ff = 0;ff<4;ff++) {
    if(diff_phi_f_e!=NULL) {
      ierr = Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET_ON_FACE(
        &faces_nodes[3*ff],p[ff],N,diffN,phi_f_e[ff],diff_phi_f_e[ff],gdim,4,base_polynomials
      ); CHKERRQ(ierr);
    } else {
      ierr = Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET_ON_FACE(
        &faces_nodes[3*ff],p[ff],N,diffN,phi_f_e[ff],NULL,gdim,4,base_polynomials
      ); CHKERRQ(ierr);
    }
  }
  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET_ON_FACE()

PetscErrorCode MoFEM::Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET_ON_FACE	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_f_e[3],
		double *	diff_phi_f_e[3],
		int	gdim,
		int	nb,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Hdiv base functions, Edge-based face functions by Ainsworth [1].

Parameters

faces_nodes	Face nodes on face
p	Approximation order on faces
N	Shape functions
diffN	Derivatives of shape functions
phi_f_e	Base functions (returned)
diff_phi_f_e	Derivatives of base functions (returned)
gdim	Number of integration pts
base_polynomials	base function (Legendre/Lobbatto-Gauss)
nb	Number of nodes on entity (4 if tet, 3 if triangle)

Returns

error code

Definition at line 39 of file Hdiv.cpp.

  {

  const int face_edges_nodes[3][2] = { {0,1}, {1,2}, {2,0} };
  const int face_oposite_edges_node[] = { 2, 0, 1 };
  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;
  PetscErrorCode ierr;
  PetscFunctionBegin;
  if(p<1) PetscFunctionReturn(0);

  FTensor::Tensor1<double,3> t_edge_cross[3];
  FTensor::Tensor1<double,3> t_node_diff_ksi[4];
  FTensor::Tensor1<double,3> t_diff_ksi0i[3];
  if(diffN!=NULL) {
    t_node_diff_ksi[0] = FTensor::Tensor1<double,3>(diffN[0],diffN[ 1],diffN[ 2]);
    t_node_diff_ksi[1] = FTensor::Tensor1<double,3>(diffN[3],diffN[ 4],diffN[ 5]);
    t_node_diff_ksi[2] = FTensor::Tensor1<double,3>(diffN[6],diffN[ 7],diffN[ 8]);
    t_node_diff_ksi[3] = FTensor::Tensor1<double,3>(diffN[9],diffN[10],diffN[11]);
    for(int ee = 0;ee<3;ee++) {
      const int n0 = faces_nodes[face_edges_nodes[ee][0]];
      const int n1 = faces_nodes[face_edges_nodes[ee][1]];
      t_diff_ksi0i[ee](i) =
      t_node_diff_ksi[n1](i)-t_node_diff_ksi[n0](i);
      t_edge_cross[ee](0) =
      t_node_diff_ksi[n0](1)*t_node_diff_ksi[n1](2)-
      t_node_diff_ksi[n0](2)*t_node_diff_ksi[n1](1);
      t_edge_cross[ee](1) =
      t_node_diff_ksi[n0](2)*t_node_diff_ksi[n1](0)-
      t_node_diff_ksi[n0](0)*t_node_diff_ksi[n1](2);
      t_edge_cross[ee](2) =
      t_node_diff_ksi[n0](0)*t_node_diff_ksi[n1](1)-
      t_node_diff_ksi[n0](1)*t_node_diff_ksi[n1](0);
    }
  } else {
    for(int ee = 0;ee<3;ee++) {
      t_edge_cross[ee](0) = 1;
      t_edge_cross[ee](1) = 0;
      t_edge_cross[ee](2) = 0;
    }
  }
  double psi_l[p+1],diff_psi_l[3*(p+1)];
  boost::shared_ptr<FTensor::Tensor2<double*,3,3> > t_diff_phi_f_e_ptr;

  for(int ee = 0;ee!=3;ee++) {
    const int i0 = faces_nodes[face_edges_nodes[ee][0]];
    const int i1 = faces_nodes[face_edges_nodes[ee][1]];
    const int iO = faces_nodes[face_oposite_edges_node[ee]];
    FTensor::Tensor1<double*,3> t_psi_f_e(
      &phi_f_e[ee][0],&phi_f_e[ee][1],&phi_f_e[ee][2],3
    );
    if(diff_phi_f_e) {
      t_diff_phi_f_e_ptr = boost::shared_ptr<FTensor::Tensor2<double*,3,3> >(
        new FTensor::Tensor2<double*,3,3>(
          &diff_phi_f_e[ee][HDIV0_0],&diff_phi_f_e[ee][HDIV0_1],&diff_phi_f_e[ee][HDIV0_2],
          &diff_phi_f_e[ee][HDIV1_0],&diff_phi_f_e[ee][HDIV1_1],&diff_phi_f_e[ee][HDIV1_2],
          &diff_phi_f_e[ee][HDIV2_0],&diff_phi_f_e[ee][HDIV2_1],&diff_phi_f_e[ee][HDIV2_2],9
        )
      );
    }
    for(int ii = 0;ii!=gdim;ii++) {
      const int node_shift = ii*nb;
      const double n0 = N[node_shift+i0];
      const double n1 = N[node_shift+i1];
      const double lambda = N[node_shift+iO];
      const double ksi0i = n1 - n0;
      if(diff_phi_f_e) {
        ierr = base_polynomials(p,ksi0i,&t_diff_ksi0i[ee](0),psi_l,diff_psi_l,3); CHKERRQ(ierr);
      } else {
        ierr = base_polynomials(p,ksi0i,NULL,psi_l,NULL,3); CHKERRQ(ierr);
      }
      FTensor::Tensor0<double*> t_psi_l(&psi_l[0]);
      FTensor::Tensor1<double*,3> t_diff_psi_l(
        &diff_psi_l[0],&diff_psi_l[p+1],&diff_psi_l[2*p+2],1
      );
      for(int l = 0;l<=p-1;l++) {
        t_psi_f_e(i) = lambda*t_psi_l*t_edge_cross[ee](i);
        if(t_diff_phi_f_e_ptr) {
          (*t_diff_phi_f_e_ptr)(i,j) =
          (t_node_diff_ksi[iO](j)*t_psi_l+lambda*t_diff_psi_l(j))*t_edge_cross[ee](i);
          ++t_diff_psi_l;
          ++(*t_diff_phi_f_e_ptr);
        }
        ++t_psi_f_e;
        ++t_psi_l;
      }
    }
  }
  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_FaceBasedVolumeShapeFunctions_MBTET()

PetscErrorCode MoFEM::Hdiv_Ainsworth_FaceBasedVolumeShapeFunctions_MBTET	(	int	p,
		double *	N,
		double *	diffN,
		double *	phi_v_f[],
		double *	diff_phi_v_f[],
		int	gdim,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Hdiv Face-based interior functions by Ainsworth [1]

Parameters

p	Approximation order on face
N	Shape functions on face
diffN	Derivatives of shape functions of face
phi_v_f	Base functions (returned)
diff_phi_v_f	Derivatives of base functions (returned)
gdim	Number of integration points
base_polynomials	Base function (Legendre/Lobbatto-Gauss)

Returns

Error code

Definition at line 367 of file Hdiv.cpp.

  {
  PetscErrorCode ierr;
  const int faces_nodes[4][3] = { {0,1,3}, {1,2,3}, {0,2,3}, {0,1,2} };

  PetscFunctionBegin;
  if(p<3) PetscFunctionReturn(0);

  FTensor::Tensor1<double,3> t_coords[4] = {
    FTensor::Tensor1<double,3>(0,0,0),
    FTensor::Tensor1<double,3>(1,0,0),
    FTensor::Tensor1<double,3>(0,1,0),
    FTensor::Tensor1<double,3>(0,0,1)
  };

  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double,3> t_tau0i[4],t_tau0j[4];
  FTensor::Tensor1<double,3> t_diff_ksi0i[4],t_diff_ksi0j[4];
  for(int ff = 0;ff!=4;ff++) {
    const int v0 = faces_nodes[ff][0];
    const int vi = faces_nodes[ff][1];
    const int vj = faces_nodes[ff][2];
    t_tau0i[ff](i) = t_coords[vi](i)-t_coords[v0](i);
    t_tau0j[ff](i) = t_coords[vj](i)-t_coords[v0](i);
    t_diff_ksi0i[ff](i) = t_node_diff_ksi[vi](i)-t_node_diff_ksi[v0](i);
    t_diff_ksi0j[ff](i) = t_node_diff_ksi[vj](i)-t_node_diff_ksi[v0](i);
  }

  double psi_l[p+1],psi_m[p+1];
  double diff_psi_l[3*(p+1)],diff_psi_m[3*(p+1)];
  for(int ff = 0;ff!=4;ff++) {
    const int v0 = faces_nodes[ff][0];
    const int vi = faces_nodes[ff][1];
    const int vj = faces_nodes[ff][2];
    FTensor::Tensor1<double*,3> t_phi_v_f(
      &phi_v_f[ff][HDIV0],&phi_v_f[ff][HDIV1],&phi_v_f[ff][HDIV2],3
    );
    FTensor::Tensor2<double*,3,3> t_diff_phi_v_f(
      &diff_phi_v_f[ff][HDIV0_0],&diff_phi_v_f[ff][HDIV0_1],&diff_phi_v_f[ff][HDIV0_2],
      &diff_phi_v_f[ff][HDIV1_0],&diff_phi_v_f[ff][HDIV1_1],&diff_phi_v_f[ff][HDIV1_2],
      &diff_phi_v_f[ff][HDIV2_0],&diff_phi_v_f[ff][HDIV2_1],&diff_phi_v_f[ff][HDIV2_2],9
    );
    for(int ii = 0;ii<gdim;ii++) {
      const int node_shift = 4*ii;
      const double n0 = N[node_shift+v0];
      const double ni = N[node_shift+vi];
      const double nj = N[node_shift+vj];
      const double beta_f = n0*ni*nj;
      FTensor::Tensor1<double,3> t_diff_beta_f;
      t_diff_beta_f(i) =
      (ni*nj)*t_node_diff_ksi[v0](i)+
      (n0*nj)*t_node_diff_ksi[vi](i)+
      (n0*ni)*t_node_diff_ksi[vj](i);
      const double ksi0i = ni-n0;
      const double ksi0j = nj-n0;
      ierr = base_polynomials(p,ksi0i,&t_diff_ksi0i[ff](0),psi_l,diff_psi_l,3); CHKERRQ(ierr);
      ierr = base_polynomials(p,ksi0j,&t_diff_ksi0j[ff](0),psi_m,diff_psi_m,3); CHKERRQ(ierr);
      FTensor::Tensor1<double,3> t_diff_a;
      int jj = 0;
      for(int oo = 0;oo<=p-3;oo++) {
        FTensor::Tensor0<double*> t_psi_l(&psi_l[0],1);
        FTensor::Tensor1<double*,3> t_diff_psi_l(
          diff_psi_l,&diff_psi_l[p+1],&diff_psi_l[2*p+2],1
        );
        for(int l = 0;l<=oo;l++) {
          int m = oo - l;
          if(m>=0) {

            FTensor::Tensor1<double*,3> t_diff_psi_m(
              &diff_psi_m[m],&diff_psi_m[p+1+m],&diff_psi_m[2*p+2+m],1
            );
            const double a = beta_f*t_psi_l*psi_m[m];
            t_phi_v_f(i) = a*t_tau0i[ff](i);
            ++t_phi_v_f;
            ++jj;
            t_phi_v_f(i) = a*t_tau0j[ff](i);
            ++t_phi_v_f;
            ++jj;

            t_diff_a(j) =
            (t_psi_l*psi_m[m])*t_diff_beta_f(j)+
            (beta_f*psi_m[m])*t_diff_psi_l(j)+
            (beta_f*t_psi_l)*t_diff_psi_m(j);
            t_diff_phi_v_f(i,j) = t_diff_a(j)*t_tau0i[ff](i);
            ++t_diff_phi_v_f;
            t_diff_phi_v_f(i,j) = t_diff_a(j)*t_tau0j[ff](i);
            ++t_diff_phi_v_f;

            ++t_psi_l;
            ++t_diff_psi_l;

          }
        }
      }
      if(jj!=NBVOLUMETET_AINSOWRTH_FACE_HDIV(p)) {
        SETERRQ2(
          PETSC_COMM_SELF,
          MOFEM_DATA_INCONSISTENCY,
          "wrong order %d != %d",
          jj,NBVOLUMETET_AINSOWRTH_FACE_HDIV(p));
      }
    }
  }
  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_FaceBubbleShapeFunctions()

PetscErrorCode MoFEM::Hdiv_Ainsworth_FaceBubbleShapeFunctions	(	int *	faces_nodes,
		int *	p,
		double *	N,
		double *	diffN,
		double *	phi_f[],
		double *	diff_phi_f[],
		int	gdim,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face bubble functions by Ainsworth [1].

Parameters

faces_nodes	Face nodes on tetrahedral
p	Approx. order on faces
N	Shape function
diffN	Derivatives of shape functions
phi_f	Base functions
diff_phi_f	Derivatives of base functions
gdim	Number of integration pts
base_polynomials	Base function (Legendre/Lobbatto-Gauss)

Returns

error code

Definition at line 132 of file Hdiv.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;
  for(int ff = 0;ff<4;ff++) {
    double *diff;
    if(diff_phi_f!=NULL) {
      diff = diff_phi_f[ff];
    } else {
      diff = NULL;
    }
    ierr = Hdiv_Ainsworth_FaceBubbleShapeFunctions_ON_FACE(
      &faces_nodes[3*ff],p[ff],N,diffN,phi_f[ff],diff,gdim,4,base_polynomials
    ); CHKERRQ(ierr);
  }
  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_FaceBubbleShapeFunctions_ON_FACE()

PetscErrorCode MoFEM::Hdiv_Ainsworth_FaceBubbleShapeFunctions_ON_FACE	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_f,
		double *	diff_phi_f,
		int	gdim,
		int	nb,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Face bubble functions by Ainsworth [1].

Parameters

faces_nodes	Face nodes on face
p	Approx. order on face
N	Shape function
diffN	Derivatives of shape functions
phi_f	Base functions
diff_phi_f	Derivatives of base functions
gdim	Number of integration pts
nb	Number of nodes on entity (4 if tet, 3 if triangle)
base_polynomials	Base function (Legendre/Lobbatto-Gauss)

Returns

error code

Definition at line 152 of file Hdiv.cpp.

  {
  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;
  PetscErrorCode ierr;
  PetscFunctionBegin;
  if(p<3) PetscFunctionReturn(0);

  const int vert_i = face_nodes[1];
  const int vert_j = face_nodes[2];
  const int i0 = face_nodes[0];
  FTensor::Tensor1<double,3> t_cross;
  FTensor::Tensor1<double,3> t_node_diff_ksi[4];
  FTensor::Tensor1<double,3> t_diff_ksi0i;
  FTensor::Tensor1<double,3> t_diff_ksi0j;

  if(diffN) {
    t_node_diff_ksi[0] = FTensor::Tensor1<double,3>(diffN[0],diffN[ 1],diffN[ 2]);
    t_node_diff_ksi[1] = FTensor::Tensor1<double,3>(diffN[3],diffN[ 4],diffN[ 5]);
    t_node_diff_ksi[2] = FTensor::Tensor1<double,3>(diffN[6],diffN[ 7],diffN[ 8]);
    t_node_diff_ksi[3] = FTensor::Tensor1<double,3>(diffN[9],diffN[10],diffN[11]);
    t_diff_ksi0i(i) =
    t_node_diff_ksi[vert_i](i)-t_node_diff_ksi[i0](i);
    t_diff_ksi0j(i) =
    t_node_diff_ksi[vert_j](i)-t_node_diff_ksi[i0](i);
    t_cross(0) =
    t_node_diff_ksi[vert_i](1)*t_node_diff_ksi[vert_j](2)-
    t_node_diff_ksi[vert_i](2)*t_node_diff_ksi[vert_j](1);
    t_cross(1) =
    t_node_diff_ksi[vert_i](2)*t_node_diff_ksi[vert_j](0)-
    t_node_diff_ksi[vert_i](0)*t_node_diff_ksi[vert_j](2);
    t_cross(2) =
    t_node_diff_ksi[vert_i](0)*t_node_diff_ksi[vert_j](1)-
    t_node_diff_ksi[vert_i](1)*t_node_diff_ksi[vert_j](0);
  } else {
    t_cross(0) = 1;
    t_cross(1) = 0;
    t_cross(2) = 0;
  }

  double psi_l[p+1],diff_psi_l[3*(p+1)];
  double psi_m[p+1],diff_psi_m[3*(p+1)];
  FTensor::Tensor1<double,3> t_diff_beta_0ij;

  FTensor::Tensor1<double*,3> t_psi_f(
    &phi_f[HDIV0],&phi_f[HDIV1],&phi_f[HDIV2],3
  );

  boost::shared_ptr<FTensor::Tensor2<double*,3,3> > t_diff_phi_f_ptr;
  if(diff_phi_f) {
    t_diff_phi_f_ptr = boost::shared_ptr<FTensor::Tensor2<double*,3,3> >(
      new FTensor::Tensor2<double*,3,3>(
        &diff_phi_f[HDIV0_0],&diff_phi_f[HDIV0_1],&diff_phi_f[HDIV0_2],
        &diff_phi_f[HDIV1_0],&diff_phi_f[HDIV1_1],&diff_phi_f[HDIV1_2],
        &diff_phi_f[HDIV2_0],&diff_phi_f[HDIV2_1],&diff_phi_f[HDIV2_2],9
      )
    );
  }

  for(int ii = 0;ii<gdim;ii++) {

    int node_shift = ii*nb;
    const double ni = N[ node_shift+vert_i ];
    const double nj = N[ node_shift+vert_j ];
    const double n0 = N[ node_shift+i0 ];
    const double ksi0i = ni - n0;
    const double ksi0j = nj - n0;
    double beta_0ij =  n0*ni*nj;
    if(diff_phi_f) {
      t_diff_beta_0ij(i) =
      (ni*nj)*t_node_diff_ksi[i0](i)+
      (n0*nj)*t_node_diff_ksi[vert_i](i)+
      (n0*ni)*t_node_diff_ksi[vert_j](i);
      ierr = base_polynomials(p,ksi0i,&t_diff_ksi0i(0),psi_l,diff_psi_l,3); CHKERRQ(ierr);
      ierr = base_polynomials(p,ksi0j,&t_diff_ksi0j(0),psi_m,diff_psi_m,3); CHKERRQ(ierr);
    } else {
      ierr = base_polynomials(p,ksi0i,NULL,psi_l,NULL,3); CHKERRQ(ierr);
      ierr = base_polynomials(p,ksi0j,NULL,psi_m,NULL,3); CHKERRQ(ierr);
    }

    int jj = 0;
    int oo = 0;
    for(;oo<=p-3;oo++) {
      FTensor::Tensor0<double*> t_psi_l(&psi_l[0]);
      FTensor::Tensor1<double*,3> t_diff_psi_l(
        diff_psi_l,&diff_psi_l[p+1],&diff_psi_l[2*p+2],1
      );
      for(int l = 0;l<=oo;l++) {
        int m = oo - l;
        if(m>=0) {
          FTensor::Tensor1<double,3> t_diff_psi_m(
            diff_psi_m[m],diff_psi_m[p+1+m],diff_psi_m[2*p+2+m]
          );
          t_psi_f(i) = (beta_0ij*t_psi_l*psi_m[m])*t_cross(i);
          ++t_psi_f;
          if(diff_phi_f) {
            (*t_diff_phi_f_ptr)(i,j) = (
              (t_psi_l*psi_m[m])*t_diff_beta_0ij(j)+
              (beta_0ij*psi_m[m])*t_diff_psi_l(j)+
              (beta_0ij*t_psi_l)*t_diff_psi_m(j)
            )*t_cross(i);
            ++(*t_diff_phi_f_ptr);
          }
        }
        ++t_psi_l;
        ++t_diff_psi_l;
        ++jj;
      }
    }
    if(jj!=NBFACETRI_AINSWORTH_FACE_HDIV(p)) {
      SETERRQ2(
        PETSC_COMM_SELF,MOFEM_DATA_INCONSISTENCY,"wrong order %d != %d",
        jj,NBFACETRI_AINSWORTH_FACE_HDIV(p)
      );
    }
  }
  PetscFunctionReturn(0);
}

Hdiv_Ainsworth_VolumeBubbleShapeFunctions_MBTET()

PetscErrorCode MoFEM::Hdiv_Ainsworth_VolumeBubbleShapeFunctions_MBTET	(	int	p,
		double *	N,
		double *	diffN,
		double *	phi_v,
		double *	diff_phi_v,
		int	gdim,
		PetscErrorCode(*)(int p, double s, double *diff_s, double *L, double *diffL, const int dim)	base_polynomials
	)

Interior bubble functions by Ainsworth [1].

Parameters

p	Volume order
N	Shape functions
diffN	Derivatives of shape functions
phi_v	Base functions
diff_phi_v	Derivatives of shape functions
gdim	Number of integration points
base_polynomials	Base function (Legendre/Lobbatto-Gauss)

Returns

Error code

Definition at line 484 of file Hdiv.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;
  if(p<4) PetscFunctionReturn(0);

  FTensor::Tensor1<double*,3> t_node_diff_ksi[4] = {
    FTensor::Tensor1<double*,3>(&diffN[0],&diffN[ 1],&diffN[ 2]),
    FTensor::Tensor1<double*,3>(&diffN[3],&diffN[ 4],&diffN[ 5]),
    FTensor::Tensor1<double*,3>(&diffN[6],&diffN[ 7],&diffN[ 8]),
    FTensor::Tensor1<double*,3>(&diffN[9],&diffN[10],&diffN[11])
  };

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;
  FTensor::Number<0> N0;
  FTensor::Number<1> N1;
  FTensor::Number<2> N2;

  FTensor::Tensor1<double,3> t_diff_ksi0i;
  FTensor::Tensor1<double,3> t_diff_ksi0j;
  FTensor::Tensor1<double,3> t_diff_ksi0k;

  t_diff_ksi0i(i) = t_node_diff_ksi[1](i)-t_node_diff_ksi[0](i);
  t_diff_ksi0j(i) = t_node_diff_ksi[2](i)-t_node_diff_ksi[0](i);
  t_diff_ksi0k(i) = t_node_diff_ksi[3](i)-t_node_diff_ksi[0](i);

  double psi_l[p+1];
  double diff_psi_l[3*(p+1)];
  double psi_m[p+1];
  double diff_psi_m[3*(p+1)];
  double psi_n[p+1];
  double diff_psi_n[3*(p+1)];

  FTensor::Tensor1<double*,3> t_phi_v(phi_v,&phi_v[HDIV1],&phi_v[HDIV2],3);
  FTensor::Tensor2<double*,3,3> t_diff_phi_v(
    diff_phi_v,&diff_phi_v[HDIV0_1],&diff_phi_v[HDIV0_2],
    &diff_phi_v[HDIV1_0],&diff_phi_v[HDIV1_1],&diff_phi_v[HDIV1_2],
    &diff_phi_v[HDIV2_0],&diff_phi_v[HDIV2_1],&diff_phi_v[HDIV2_2],9
  );

  FTensor::Tensor1<double,3> t_diff_beta_v;
  for(int ii = 0;ii<gdim;ii++) {
    const int node_shift = ii*4;
    const double n0 = N[node_shift+0];
    const double ni = N[node_shift+1];
    const double nj = N[node_shift+2];
    const double nk = N[node_shift+3];
    const double ksi0i = ni-n0;
    const double ksi0j = nj-n0;
    const double ksi0k = nk-n0;
    const double beta_v = n0*ni*nj*nk;
    t_diff_beta_v(i) =
    (ni*nj*nk)*t_node_diff_ksi[0](i)+
    (n0*nj*nk)*t_node_diff_ksi[1](i)+
    (n0*ni*nk)*t_node_diff_ksi[2](i)+
    (n0*ni*nj)*t_node_diff_ksi[3](i);
    ierr = base_polynomials(p,ksi0i,&t_diff_ksi0i(0),psi_l,diff_psi_l,3); CHKERRQ(ierr);
    ierr = base_polynomials(p,ksi0j,&t_diff_ksi0j(0),psi_m,diff_psi_m,3); CHKERRQ(ierr);
    ierr = base_polynomials(p,ksi0k,&t_diff_ksi0k(0),psi_n,diff_psi_n,3); CHKERRQ(ierr);

    FTensor::Tensor1<double,3> t_diff_a;

    int jj = 0;
    for(int oo = 0;oo<=p-4;oo++) {
      FTensor::Tensor0<double*> t_psi_l(&psi_l[0]);
      FTensor::Tensor1<double*,3> t_diff_psi_l(
        diff_psi_l,&diff_psi_l[p+1],&diff_psi_l[2*p+2],1
      );
      for(int l = 0;l<=oo;l++) {
        FTensor::Tensor0<double*> t_psi_m(&psi_m[0]);
        FTensor::Tensor1<double*,3> t_diff_psi_m(
          diff_psi_m,&diff_psi_m[p+1],&diff_psi_m[2*p+2],1
        );
        for(int m = 0;(l+m)<=oo;m++) {
          int n = oo - l - m;
          if(n>=0) {
            FTensor::Tensor1<double,3> t_diff_psi_n(
              diff_psi_n[n],diff_psi_n[p+1+n],diff_psi_n[2*p+2+n]
            );
            const double a = beta_v*t_psi_l*t_psi_m*psi_n[n];
            t_phi_v(0) = a;
            t_phi_v(1) = 0;
            t_phi_v(2) = 0;
            ++t_phi_v;
            t_phi_v(0) = 0;
            t_phi_v(1) = a;
            t_phi_v(2) = 0;
            ++t_phi_v;
            t_phi_v(0) = 0;
            t_phi_v(1) = 0;
            t_phi_v(2) = a;
            ++t_phi_v;
            t_diff_a(j) =
            (t_psi_l*t_psi_m*psi_n[n])*t_diff_beta_v(j)+
            (beta_v*t_psi_m*psi_n[n])*t_diff_psi_l(j)+
            (beta_v*t_psi_l*psi_n[n])*t_diff_psi_m(j)+
            (beta_v*t_psi_l*t_psi_m)*t_diff_psi_n(j);
            t_diff_phi_v(N0,j) = t_diff_a(j);
            t_diff_phi_v(N1,j) = 0;
            t_diff_phi_v(N2,j) = 0;
            ++t_diff_phi_v;
            t_diff_phi_v(N0,j) = 0;
            t_diff_phi_v(N1,j) = t_diff_a(j);
            t_diff_phi_v(N2,j) = 0;
            ++t_diff_phi_v;
            t_diff_phi_v(N0,j) = 0;
            t_diff_phi_v(N1,j) = 0;
            t_diff_phi_v(N2,j) = t_diff_a(j);
            ++t_diff_phi_v;
            ++jj;
          }
          ++t_psi_m;
          ++t_diff_psi_m;
        }
        ++t_psi_l;
        ++t_diff_psi_l;
      }
    }

    if(3*jj!=NBVOLUMETET_AINSWORTH_VOLUME_HDIV(p)) {
      SETERRQ2(
        PETSC_COMM_SELF,
        MOFEM_DATA_INCONSISTENCY,
        "wrong order %d != %d",jj,
        NBVOLUMETET_AINSWORTH_VOLUME_HDIV(p)
      );
    }
  }

  PetscFunctionReturn(0);
}

Hdiv_Demkowicz_Face_MBTET_ON_FACE()

PetscErrorCode MoFEM::Hdiv_Demkowicz_Face_MBTET_ON_FACE	(	int *	faces_nodes,
		int	p,
		double *	N,
		double *	diffN,
		double *	phi_f,
		double *	diff_phi_f,
		int	gdim,
		int	nb
	)

HDiv base finuctions on triangle by Demkowicz [20]

Parameters

faces_nodes	Nodes on face
p	Approx. order
N	Shape functions
diffN	Derivatives of shape functions
phi_f	Returned base functions on face
diff_phi_f	Returned derivatives of base functions on face
gdim	Number of integration points
nb	nb is 4 for face on tetrahedral and 3 for face

Returns

error code

Definition at line 619 of file Hdiv.cpp.

  {
  const int face_edges_nodes[3][2] = { {0,1}, {1,2}, {2,0} };
  const int face_oposite_edges_node[] = { 2, 0, 1 };
  PetscErrorCode ierr;
  PetscFunctionBegin;

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double,3> t_cross[3];
  FTensor::Tensor2<double,3,3> t_diff_cross;
  FTensor::Tensor1<double,3> t_node_diff_ksi[4];
  FTensor::Tensor1<double,3> t_node_diff_sum_n0_n1;

  const int i0 = faces_nodes[0];
  const int i1 = faces_nodes[1];
  const int i2 = faces_nodes[2];
  const int o[] = {
    faces_nodes[face_oposite_edges_node[0]],
    faces_nodes[face_oposite_edges_node[1]],
    faces_nodes[face_oposite_edges_node[2]]
  };

  FTensor::Tensor1<double,3> t_diff_n0_p_n1;
  FTensor::Tensor1<double,3> t_diff_n0_p_n1_p_n2;

  if(diff_phi_f) {
    t_node_diff_ksi[0] = FTensor::Tensor1<double,3>(diffN[0],diffN[ 1],diffN[ 2]);
    t_node_diff_ksi[1] = FTensor::Tensor1<double,3>(diffN[3],diffN[ 4],diffN[ 5]);
    t_node_diff_ksi[2] = FTensor::Tensor1<double,3>(diffN[6],diffN[ 7],diffN[ 8]);
    t_node_diff_ksi[3] = FTensor::Tensor1<double,3>(diffN[9],diffN[10],diffN[11]);
    t_diff_cross(i,j) = 0;
    for(int ee = 0;ee!=3;ee++) {
      int ei0 = faces_nodes[face_edges_nodes[ee][0]];
      int ei1 = faces_nodes[face_edges_nodes[ee][1]];
      t_cross[ee](0) =
      t_node_diff_ksi[ei0](1)*t_node_diff_ksi[ei1](2)-
      t_node_diff_ksi[ei0](2)*t_node_diff_ksi[ei1](1);
      t_cross[ee](1) =
      t_node_diff_ksi[ei0](2)*t_node_diff_ksi[ei1](0)-
      t_node_diff_ksi[ei0](0)*t_node_diff_ksi[ei1](2);
      t_cross[ee](2) =
      t_node_diff_ksi[ei0](0)*t_node_diff_ksi[ei1](1)-
      t_node_diff_ksi[ei0](1)*t_node_diff_ksi[ei1](0);
      FTensor::Tensor1<double,3> t_diff_o(
        diffN[3*o[ee]+0],diffN[3*o[ee]+1],diffN[3*o[ee]+2]
      );
      t_diff_cross(i,j) += t_cross[ee](i)*t_diff_o(j);
      // cerr << t_cross[ee](0) << " " << t_cross[ee](1) << " " << t_cross[ee](2) << endl;
    }
    // cerr << endl << endl;
    t_diff_n0_p_n1(i) = t_node_diff_ksi[i0](i)+t_node_diff_ksi[i1](i);
    t_diff_n0_p_n1_p_n2(i) = t_diff_n0_p_n1(i)+t_node_diff_ksi[i2](i);
  } else {
    for(int ee = 0;ee!=3;ee++) {
      t_cross[ee](0) = 1;
      t_cross[ee](1) = 0;
      t_cross[ee](2) = 0;
    }
  }

  FTensor::Tensor1<double*,3> t_phi(&phi_f[HDIV0],&phi_f[HDIV1],&phi_f[HDIV2],3);
  boost::shared_ptr<FTensor::Tensor2<double*,3,3> > t_diff_phi_ptr;
  if(diff_phi_f) {
    t_diff_phi_ptr = boost::shared_ptr<FTensor::Tensor2<double*,3,3> >(
      new FTensor::Tensor2<double*,3,3>(
        &diff_phi_f[HDIV0_0],&diff_phi_f[HDIV0_1],&diff_phi_f[HDIV0_2],
        &diff_phi_f[HDIV1_0],&diff_phi_f[HDIV1_1],&diff_phi_f[HDIV1_2],
        &diff_phi_f[HDIV2_0],&diff_phi_f[HDIV2_1],&diff_phi_f[HDIV2_2],9
      )
    );
  }

  double fi[p+1],diff_fi[3*p+3];
  double fj[p+1],diff_fj[3*p+3];
  double tmp_fj[p+1],tmp_diff_fj[3*p+3];
  for(int ii = 0;ii!=gdim;ii++) {
    const int shift = ii*nb;
    double n0 = N[shift+i0];
    double n1 = N[shift+i1];
    double n2 = N[shift+i2];
    double *diff_n1 = (diff_phi_f) ? &t_node_diff_ksi[i1](0) : NULL;
    double *diff_n0_p_n1 = (diff_phi_f) ? &t_diff_n0_p_n1(0) : NULL;
    ierr = Jacobi_polynomials(
      p,0,n1,n0+n1,diff_n1,diff_n0_p_n1,fi,diff_phi_f?diff_fi:NULL,3
    ); CHKERRQ(ierr);
    for(int pp = 0;pp<=p;pp++) {
      double *diff_n2 = (diff_phi_f) ? &t_node_diff_ksi[i2](0) : NULL;
      double *diff_n0_p_n1_p_n2 = (diff_phi_f) ? &t_diff_n0_p_n1_p_n2(0) : NULL;
      ierr = Jacobi_polynomials(
        pp,2*pp+1,n2,n0+n1+n2,diff_n2,diff_n0_p_n1_p_n2,tmp_fj,diff_phi_f?tmp_diff_fj:NULL,3
      ); CHKERRQ(ierr);
      fj[pp] = tmp_fj[pp];
      if(diff_phi_f) {
        diff_fj[0*(p+1)+pp] = tmp_diff_fj[0*(pp+1)+pp];
        diff_fj[1*(p+1)+pp] = tmp_diff_fj[1*(pp+1)+pp];
        diff_fj[2*(p+1)+pp] = tmp_diff_fj[2*(pp+1)+pp];
      }
    }
    double no0 = N[shift+o[0]];
    double no1 = N[shift+o[1]];
    double no2 = N[shift+o[2]];
    FTensor::Tensor1<double,3> base0;
    base0(i) = no0*t_cross[0](i)+no1*t_cross[1](i)+no2*t_cross[2](i);
    int jj = 0;
    for(int oo = 0;oo<p;oo++) {
      FTensor::Tensor0<double*> t_fi(fi);
      FTensor::Tensor1<double*,3> t_diff_fi(
        &diff_fi[0],&diff_fi[p+1],&diff_fi[2*p+2],1
      );
      for(int ll = 0;ll<=oo;ll++) {
        const int mm = oo-ll;
        if(mm>=0) {
          const double a = t_fi*fj[mm];
          // cerr << ll << " " << mm << " " << a << endl;
          t_phi(i) = a*base0(i);
          if(diff_phi_f) {
            FTensor::Tensor1<double*,3> t_diff_fj(
              &diff_fj[0+mm],&diff_fj[p+1+mm],&diff_fj[2*p+2+mm],1
            );
            (*t_diff_phi_ptr)(i,j) =
            a*t_diff_cross(i,j)+
            (
              t_diff_fi(j)*fj[mm]+t_fi*t_diff_fj(j)
            )*base0(i);
            ++(*t_diff_phi_ptr);
            ++t_diff_fi;
          }
          ++t_fi;
          ++t_phi;
          ++jj;
        }
      }
    }
    if(jj!=NBFACETRI_DEMKOWICZ_HDIV(p)) {
      SETERRQ2(
        PETSC_COMM_SELF,
        MOFEM_DATA_INCONSISTENCY,
        "wrong number of base functions "
        "jj!=NBFACETRI_DEMKOWICZ_HDIV(p) "
        "%d!=%d",jj,NBFACETRI_DEMKOWICZ_HDIV(p)
      );
    }
  }

  PetscFunctionReturn(0);
}

Hdiv_Demkowicz_Interior_MBTET()

PetscErrorCode MoFEM::Hdiv_Demkowicz_Interior_MBTET	(	int	p,
		double *	N,
		double *	diffN,
		int	p_face[],
		double *	phi_f[4],
		double *	diff_phi_f[4],
		double *	phi_v,
		double *	diff_phi_v,
		int	gdim
	)

HDiv base finuctions in tetrahedral interior by Demkowicz [20]

Parameters

p	Approximation order
N	Shape functions
diffN	Derivatives of base functions
p_face	Max order on faces
phi_f	Precalculated face base functions
diff_phi_f	Precalculated derivatives of face base functions
phi_v	Returned base functions in volume
diff_phi_v	Returned derivatives of base functions in volume
gdim	Number of integration points

Returns

error code

Definition at line 774 of file Hdiv.cpp.

  {
  PetscErrorCode ierr;
  const int oppisite_face_node[4] = { 2,0,1,3 };
  // list of zero node faces
  const int znf[] = { 0,2,3 };
  PetscFunctionBegin;

  FTensor::Index<'i',3> i;
  FTensor::Index<'j',3> j;

  FTensor::Tensor1<double,3> t_node_diff_ksi[4];
  t_node_diff_ksi[0] = FTensor::Tensor1<double,3>(diffN[0],diffN[ 1],diffN[ 2]);
  t_node_diff_ksi[1] = FTensor::Tensor1<double,3>(diffN[3],diffN[ 4],diffN[ 5]);
  t_node_diff_ksi[2] = FTensor::Tensor1<double,3>(diffN[6],diffN[ 7],diffN[ 8]);
  t_node_diff_ksi[3] = FTensor::Tensor1<double,3>(diffN[9],diffN[10],diffN[11]);

  FTensor::Tensor1<double*,3> t_phi_v(&phi_v[HDIV0],&phi_v[HDIV1],&phi_v[HDIV2],3);
  FTensor::Tensor2<double*,3,3>t_diff_phi_v(
    &diff_phi_v[HDIV0_0],&diff_phi_v[HDIV0_1],&diff_phi_v[HDIV0_2],
    &diff_phi_v[HDIV1_0],&diff_phi_v[HDIV1_1],&diff_phi_v[HDIV1_2],
    &diff_phi_v[HDIV2_0],&diff_phi_v[HDIV2_1],&diff_phi_v[HDIV2_2],9
  );

  ublas::matrix<double> fk(3,p+1),diff_fk(3,3*p+3);
  double tmp_fk[p+1],tmp_diff_fk[3*p+3];

  for(int ii = 0;ii!=gdim;ii++) {
    const int shift = 4*ii;

    for(int ff = 0;ff!=3;ff++) {
      const int fff = znf[ff];
      const int iO = oppisite_face_node[fff];
      const double nO = N[shift+iO];
      for(int pp = 0;pp<=p;pp++) {
        ierr = Jacobi_polynomials(
          pp,2*pp+2,nO,nO,&t_node_diff_ksi[iO](0),&t_node_diff_ksi[iO](0),tmp_fk,tmp_diff_fk,3
        ); CHKERRQ(ierr);
        fk(ff,pp) = tmp_fk[pp];
        diff_fk(ff,0*(p+1)+pp) = tmp_diff_fk[0*(pp+1)+pp];
        diff_fk(ff,1*(p+1)+pp) = tmp_diff_fk[1*(pp+1)+pp];
        diff_fk(ff,2*(p+1)+pp) = tmp_diff_fk[2*(pp+1)+pp];
      }
    }

    int jj = 0;
    for(int oo = 2;oo<=p;oo++) {
      for(int k = 1;k!=oo;k++) {
        int OO = oo-k;
        if(OO>=0) {
          int s = NBFACETRI_DEMKOWICZ_HDIV(OO-1);
          // Note taht we do faces 0,2,3, skipping 1. All the faces which have zero node in it.
          int nb_dofs = NBFACETRI_DEMKOWICZ_HDIV(p_f[znf[0]]);
          int sp[] = { ii*3*nb_dofs+3*s, ii*3*nb_dofs+3*s, ii*3*nb_dofs+3*s };
          FTensor::Tensor1<double*,3> t_phi_f[] = {
            FTensor::Tensor1<double*,3>(
              &phi_f[znf[0]][sp[0]+HDIV0],&phi_f[znf[0]][sp[0]+HDIV1],&phi_f[znf[0]][sp[0]+HDIV2],3
            ),
            FTensor::Tensor1<double*,3>(
              &phi_f[znf[1]][sp[1]+HDIV0],&phi_f[znf[1]][sp[1]+HDIV1],&phi_f[znf[1]][sp[1]+HDIV2],3
            ),
            FTensor::Tensor1<double*,3>(
              &phi_f[znf[2]][sp[2]+HDIV0],&phi_f[znf[2]][sp[2]+HDIV1],&phi_f[znf[2]][sp[2]+HDIV2],3
            )
          };
          int sdp[] = { ii*9*nb_dofs+9*s, ii*9*nb_dofs+9*s, ii*9*nb_dofs+9*s };
          FTensor::Tensor2<double*,3,3> t_diff_phi_f[] = {
            FTensor::Tensor2<double*,3,3>(
              &diff_phi_f[znf[0]][sdp[0]+HDIV0_0],&diff_phi_f[znf[0]][sdp[0]+HDIV0_1],&diff_phi_f[znf[0]][sdp[0]+HDIV0_2],
              &diff_phi_f[znf[0]][sdp[0]+HDIV1_0],&diff_phi_f[znf[0]][sdp[0]+HDIV1_1],&diff_phi_f[znf[0]][sdp[0]+HDIV1_2],
              &diff_phi_f[znf[0]][sdp[0]+HDIV2_0],&diff_phi_f[znf[0]][sdp[0]+HDIV2_1],&diff_phi_f[znf[0]][sdp[0]+HDIV2_2],9
            ),
            FTensor::Tensor2<double*,3,3>(
              &diff_phi_f[znf[1]][sdp[1]+HDIV0_0],&diff_phi_f[znf[1]][sdp[1]+HDIV0_1],&diff_phi_f[znf[1]][sdp[1]+HDIV0_2],
              &diff_phi_f[znf[1]][sdp[1]+HDIV1_0],&diff_phi_f[znf[1]][sdp[1]+HDIV1_1],&diff_phi_f[znf[1]][sdp[1]+HDIV1_2],
              &diff_phi_f[znf[1]][sdp[1]+HDIV2_0],&diff_phi_f[znf[1]][sdp[1]+HDIV2_1],&diff_phi_f[znf[1]][sdp[1]+HDIV2_2],9
            ),
            FTensor::Tensor2<double*,3,3>(
              &diff_phi_f[znf[2]][sdp[2]+HDIV0_0],&diff_phi_f[znf[2]][sdp[2]+HDIV0_1],&diff_phi_f[znf[2]][sdp[2]+HDIV0_2],
              &diff_phi_f[znf[2]][sdp[2]+HDIV1_0],&diff_phi_f[znf[2]][sdp[2]+HDIV1_1],&diff_phi_f[znf[2]][sdp[2]+HDIV1_2],
              &diff_phi_f[znf[2]][sdp[2]+HDIV2_0],&diff_phi_f[znf[2]][sdp[2]+HDIV2_1],&diff_phi_f[znf[2]][sdp[2]+HDIV2_2],9
            )
          };
          for(int ij = s;ij!=NBFACETRI_DEMKOWICZ_HDIV(OO);ij++) {
            for(int ff = 0;ff!=3;ff++) {
              FTensor::Tensor1<double,3> t_diff_fk(
                diff_fk(ff,0*(p+1)+k),diff_fk(ff,1*(p+1)+k),diff_fk(ff,2*(p+1)+k)
              );
              t_phi_v(i) = fk(ff,k)*t_phi_f[ff](i);
              t_diff_phi_v(i,j) = t_diff_fk(j)*t_phi_f[ff](i)+fk(ff,k)*t_diff_phi_f[ff](i,j);
              ++t_phi_v;
              ++t_diff_phi_v;
              ++t_phi_f[ff];
              ++t_diff_phi_f[ff];
              ++jj;
            }
          }
        }
      }
    }
    if(jj!=NBVOLUMETET_DEMKOWICZ_HDIV(p)) {
      SETERRQ2(PETSC_COMM_SELF,
        MOFEM_DATA_INCONSISTENCY,
        "wrong number of base functions "
        "jj!=NBVOLUMETET_DEMKOWICZ_HDIV(p) "
        "%d!=%d",jj,NBVOLUMETET_DEMKOWICZ_HDIV(p)
      );
    }

  }

  PetscFunctionReturn(0);
}

invertTensor3by3< 3, double, ublas::row_major, ublas::unbounded_array< double > >()

template<>

PetscErrorCode MoFEM::invertTensor3by3< 3, double, ublas::row_major, ublas::unbounded_array< double > >	(	MatrixDouble &	jac_data,
		VectorDouble &	det_data,
		MatrixDouble &	inv_jac_data
	)

Definition at line 485 of file DataOperators.cpp.

  {
  PetscErrorCode ierr;
  PetscFunctionBegin;
  FTensor::Tensor2<double*,3,3> A = getTensor2FormData<3,3>(jac_data);
  int nb_gauss_pts = jac_data.size2();
  det_data.resize(nb_gauss_pts,false);
  inv_jac_data.resize(3,nb_gauss_pts,false);
  FTensor::Tensor0<double*> det = getTensor0FormData(det_data);
  FTensor::Tensor2<double*,3,3> I = getTensor2FormData<3,3>(inv_jac_data);
  for(int gg = 0;gg!=nb_gauss_pts;gg++) {
    ierr = determinantTensor3by3(A,det); CHKERRQ(ierr);
    ierr = invertTensor3by3(A,det,I); CHKERRQ(ierr);
    ++A;
    ++det;
    ++I;
  }
  PetscFunctionReturn(0);
}

KspMat()

PetscErrorCode MoFEM::KspMat	(	KSP	ksp,
		Mat	A,
		Mat	B,
		void *	ctx
	)

Run over elenents in the list.

Parameters

ksp	KSP solver
A	matrix
B	Preconditioner matrix
ctx	data context, i.e. KspCtx

Returns

error code

Definition at line 83 of file KspCtx.cpp.

                                                     {
  PetscFunctionBegin;
  PetscErrorCode ierr;
  KspCtx* ksp_ctx = (KspCtx*)ctx;
  PetscLogEventBegin(ksp_ctx->USER_EVENT_KspMat,0,0,0,0);
  KspCtx::basic_method_to_do::iterator bit = ksp_ctx->preProcess_Mat.begin();
  for(;bit!=ksp_ctx->preProcess_Mat.end();bit++) {
    ierr = (*bit)->setKsp(ksp); CHKERRQ(ierr);
    (*bit)->ksp_A = A;
    (*bit)->ksp_B = B;
    ierr = (*bit)->setKspCtx(KspMethod::CTX_OPERATORS); CHKERRQ(ierr);
    ierr = ksp_ctx->mField.problem_basic_method_preProcess(ksp_ctx->problemName,*(*(bit)));  CHKERRQ(ierr);
    ierr = (*bit)->setKspCtx(KspMethod::CTX_KSPNONE);  CHKERRQ(ierr);
  }
  KspCtx::loops_to_do_type::iterator lit = ksp_ctx->loops_to_do_Mat.begin();
  for(;lit!=ksp_ctx->loops_to_do_Mat.end();lit++) {
    lit->second->ksp_A = A;
    lit->second->ksp_B = B;
    ierr = lit->second->setKsp(ksp); CHKERRQ(ierr);
    ierr = lit->second->setKspCtx(KspMethod::CTX_OPERATORS); CHKERRQ(ierr);
    ierr = ksp_ctx->mField.loop_finite_elements(ksp_ctx->problemName,lit->first,*(lit->second),ksp_ctx->bH);  CHKERRQ(ierr);
    ierr = lit->second->setKspCtx(KspMethod::CTX_KSPNONE);
  }
  bit = ksp_ctx->postProcess_Mat.begin();
  for(;bit!=ksp_ctx->postProcess_Mat.end();bit++) {
    ierr = (*bit)->setKsp(ksp); CHKERRQ(ierr);
    (*bit)->ksp_A = A;
    (*bit)->ksp_B = B;
    ierr = (*bit)->setKspCtx(KspMethod::CTX_OPERATORS); CHKERRQ(ierr);
    ierr = ksp_ctx->mField.problem_basic_method_postProcess(ksp_ctx->problemName,*(*(bit)));  CHKERRQ(ierr);
    ierr = (*bit)->setKspCtx(KspMethod::CTX_KSPNONE);  CHKERRQ(ierr);
  }
  ierr = MatAssemblyBegin(B,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);
  ierr = MatAssemblyEnd(B,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);
  // MatView(A,PETSC_VIEWER_DRAW_WORLD);
  // std::string wait;
  // std::cin >> wait;
  PetscLogEventEnd(ksp_ctx->USER_EVENT_KspMat,0,0,0,0);
  PetscFunctionReturn(0);
}

KspRhs()

PetscErrorCode MoFEM::KspRhs	(	KSP	ksp,
		Vec	f,
		void *	ctx
	)

Run over elements in the lists.

Parameters

ksp	KSP solver
f	the right hand side vector
ctx	data context, i.e. KspCtx

Returns

error code

Definition at line 47 of file KspCtx.cpp.

                                               {
  PetscFunctionBegin;
  PetscErrorCode ierr;
  KspCtx* ksp_ctx = (KspCtx*)ctx;
  PetscLogEventBegin(ksp_ctx->USER_EVENT_KspRhs,0,0,0,0);
  KspCtx::basic_method_to_do::iterator bit = ksp_ctx->preProcess_Rhs.begin();
  for(;bit!=ksp_ctx->preProcess_Rhs.end();bit++) {
    ierr = (*bit)->setKsp(ksp); CHKERRQ(ierr);
    (*bit)->ksp_f = f;
    ierr = (*bit)->setKspCtx(KspMethod::CTX_SETFUNCTION);  CHKERRQ(ierr);
    ierr = ksp_ctx->mField.problem_basic_method_preProcess(ksp_ctx->problemName,*(*(bit)));  CHKERRQ(ierr);
    ierr = (*bit)->setKspCtx(KspMethod::CTX_KSPNONE);  CHKERRQ(ierr);
  }
  KspCtx::loops_to_do_type::iterator lit = ksp_ctx->loops_to_do_Rhs.begin();
  for(;lit!=ksp_ctx->loops_to_do_Rhs.end();lit++) {
    ierr = lit->second->setKspCtx(KspMethod::CTX_SETFUNCTION);  CHKERRQ(ierr);
    ierr = lit->second->setKsp(ksp); CHKERRQ(ierr);
    lit->second->ksp_f = f;
    ierr = ksp_ctx->mField.loop_finite_elements(ksp_ctx->problemName,lit->first,*(lit->second),ksp_ctx->bH);  CHKERRQ(ierr);
    ierr = lit->second->setKspCtx(KspMethod::CTX_KSPNONE);  CHKERRQ(ierr);
  }
  bit = ksp_ctx->postProcess_Rhs.begin();
  for(;bit!=ksp_ctx->postProcess_Rhs.end();bit++) {
    ierr = (*bit)->setKsp(ksp); CHKERRQ(ierr);
    (*bit)->ksp_f = f;
    ierr = (*bit)->setKspCtx(KspMethod::CTX_SETFUNCTION);  CHKERRQ(ierr);
    ierr = ksp_ctx->mField.problem_basic_method_postProcess(ksp_ctx->problemName,*(*(bit)));  CHKERRQ(ierr);
    ierr = (*bit)->setKspCtx(KspMethod::CTX_KSPNONE);  CHKERRQ(ierr);
  }
  ierr = VecGhostUpdateBegin(f,ADD_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  ierr = VecGhostUpdateEnd(f,ADD_VALUES,SCATTER_REVERSE); CHKERRQ(ierr);
  ierr = VecAssemblyBegin(f); CHKERRQ(ierr);
  ierr = VecAssemblyEnd(f); CHKERRQ(ierr);
  PetscLogEventEnd(ksp_ctx->USER_EVENT_KspRhs,0,0,0,0);
  PetscFunctionReturn(0);
}

operator<<() [1/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const RefElement &	e
	)

Definition at line 42 of file FEMultiIndices.cpp.

                                                           {
  os << " ref egdes " << e.getBitRefEdges();
  os << " " << *(e.sPtr);
  return os;
}

operator<<() [2/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const DofEntity &	e
	)

Definition at line 84 of file DofsMultiIndices.cpp.

                                                          {
  os << "dof_uid " << e.getGlobalUniqueId()
  << " dof_order " << e.getDofOrder()
  << " dof_rank " << e.getDofCoeffIdx()
  << " dof " << e.getEntDofIdx()
  << " active " << e.active
  << " " << *(e.sFieldPtr);
  return os;
}

operator<<() [3/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const Problem &	e
	)

Definition at line 86 of file ProblemsMultiIndices.cpp.

                                                        {
  os << "problem id " << e.getId()
    << " FiniteElement id " << e.getBitFEId()
    << " name "<<e.getName();
  return os;
}

operator<<() [4/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const NumeredDofEntity &	e
	)

Definition at line 119 of file DofsMultiIndices.cpp.

                                                                 {
  os << "idx " << e.dofIdx << " part " << e.pArt
  << " petsc idx " << e.petscGloablDofIdx
  << " ( " << e.petscLocalDofIdx <<  " ) "
  << *e.sFieldPtr;
  return os;
}

operator<<() [5/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const RefEntity &	e
	)

Definition at line 144 of file EntsMultiIndices.cpp.

                                                          {
  os << "ent " << e.ent;
  os << " pstatus "<< std::bitset<8>(e.getPStatus());
  os << " owner ent " << e.getOwnerEnt();
  os << " owner proc " << e.getOwnerProc();
  os << " parent ent " << e.getParentEnt();
  //os << " BitRefLevel " << e.getBitRefLevel();
  os << " ent type " << e.getEntType();
  os << " ent parent type " << e.getParentEntType();
  return os;
}

operator<<() [6/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const FEDofEntity &	e
	)

Definition at line 146 of file DofsMultiIndices.cpp.

                                                            {
  os << "local dof FiniteElement idx "
    << "side_number " << (int)e.sideNumberPtr->side_number << " "
    << "sense " << (int)e.sideNumberPtr->sense << " "
    << *e.sFieldPtr;
  return os;
}

operator<<() [7/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const FENumeredDofEntity &	e
	)

Definition at line 172 of file DofsMultiIndices.cpp.

                                                                   {
  os << "local dof FiniteElement idx "
    << "side_number " << (int)e.sideNumberPtr->side_number << " "
    << "sense " << (int)e.sideNumberPtr->sense << " "
    << *e.sFieldPtr;
  return os;
}

operator<<() [8/38]

std::ostream& MoFEM::operator<<	(	std::ostream &	os,
		const Field &	e
	)

Definition at line 180 of file CoreDataStructures.cpp.

                                                      {
  os
  << "name " <<e.getNameRef()
  << " BitFieldId "<< e.getId().to_ulong()
  << " bit number " << e.getBitNumber()
  << " space " << FieldSpaceNames[e.getSpace()]
  << " approximation base " << ApproximationBaseNames[e.getApproxBase()]
  << " rank " << e.getNbOfCoeffs()
  << " meshset " << e.meshSet;
  return os;
}