MoFEM Namespace Reference

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

Namespaces
	BcManagerImplTools
	DemkowiczHexAndQuad
	Exceptions
	Exceptions and handling errors data structures.
	IntRules
	LogKeywords
	Types
	Types.

Classes
struct	AccelerationCubitBcData
	Definition of the acceleration bc data structure. More...
struct	AddEssentialToLhsPipelineImpl
	Function (factory) for setting operators for lhs pipeline. More...
struct	AddEssentialToLhsPipelineImpl< OpEssentialLhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddEssentialToLhsPipelineImpl< OpEssentialLhsImpl< HeatFluxCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddEssentialToLhsPipelineImpl< OpEssentialLhsImpl< MPCsType, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddEssentialToRhsPipelineImpl
	Function (factory) for setting operators for rhs pipeline. More...
struct	AddEssentialToRhsPipelineImpl< OpEssentialRhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddEssentialToRhsPipelineImpl< OpEssentialRhsImpl< HeatFluxCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddEssentialToRhsPipelineImpl< OpEssentialRhsImpl< MPCsType, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddFluxToLhsPipelineImpl
struct	AddFluxToRhsPipelineImpl
struct	AddFluxToRhsPipelineImpl< MoFEM::OpFluxRhsImpl< ThermoElasticOps::SetTargetTemperature, 1, 1, A, I, OpBase >, A, I, OpBase >
struct	AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalForceMeshsets, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalForceMeshsetsScalarAndVectorScaling, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalMeshsetType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalMeshsetTypeVectorScaling< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalTemperatureMeshsets, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase >
struct	AddHOOps
	Add operators pushing bases from local to physical configuration. More...
struct	AddHOOps< 1, 2, 2 >
struct	AddHOOps< 1, 3, 3 >
struct	AddHOOps< 2, 2, 2 >
struct	AddHOOps< 2, 2, 3 >
struct	AddHOOps< 2, 3, 3 >
struct	AddHOOps< 3, 3, 3 >
struct	AinsworthOrderHooks
	Broken base Ainsworth subentries order change hooks. More...
struct	AssemblyTypeSelector
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	BaseFunctionUnknownInterface
struct	BasicEntityData
	PipelineManager data. like access to moab interface and basic tag handlers. More...
struct	BasicMethod
	Data structure to exchange data between mofem and User Loop Methods. More...
struct	BasicMethodPtr
struct	BcDisplacementMeshsetType
struct	BcFluxMeshsetType
struct	BcForceMeshsetType
struct	BcManager
	Simple interface for fast problem set-up. More...
struct	BcMeshsetType
struct	BcScalarMeshsetType
struct	BernsteinBezier
	Evaluating BB polynomial. More...
struct	BitFEId_mi_tag
struct	BitFieldId_mi_tag
struct	BitFieldId_space_mi_tag
struct	BitProblemId_mi_tag
struct	BitRefManager
	Managing BitRefLevels. More...
struct	Block_BodyForces
	Body force data structure. More...
struct	BlockData
struct	BlockSetAttributes
	Arbitrary block attributes data structure. More...
struct	BlockStructure
struct	BrokenBaseSideData
struct	CfgCubitBcData
	Definition of the cfd_bc data structure. More...
struct	CommInterface
	Managing BitRefLevels. More...
struct	ComposedProblemsData
struct	Composite_Cubit_msId_And_MeshsetType_mi_tag
struct	Composite_Ent_And_EntDofIdx_mi_tag
struct	Composite_Ent_and_ShortId_mi_tag
struct	Composite_Ent_Order_And_CoeffIdx_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_Part_mi_tag
struct	Composite_Name_Ent_And_Part_mi_tag
struct	Composite_Name_Ent_Order_And_CoeffIdx_mi_tag
struct	Composite_ParentEnt_And_BitsOfRefinedEdges_mi_tag
struct	Composite_ParentEnt_And_EntType_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	ConstrainMatrixCtx
	structure for projection matrices More...
struct	ContactPrismElementForcesAndSourcesCore
	ContactPrism finite element. More...
struct	CoreInterface
	Interface. More...
struct	CoreTmp
struct	CoreTmp< 0 >
	Core (interface) class. More...
struct	CoreTmp<-1 >
struct	CoreValue
struct	CreateRowCompressedADJMatrix
	Create compressed matrix. More...
struct	CubitMeshsetMaskedType_mi_tag
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_name
struct	CubitMeshsetType_mi_tag
	MultiIndex Tag for field id. More...
struct	CutMeshInterface
	Interface to cut meshes. More...
struct	DataOperator
	base operator to do operations at Gauss Pt. level More...
struct	DefaultElementAdjacency
	default adjacency map More...
struct	DeprecatedCoreInterface
	Deprecated interface functions. More...
struct	DerivedEntitiesFieldData
	this class derive data form other data structure More...
struct	DeterminantTensorImpl
struct	DeterminantTensorImpl< T, 2 >
struct	DeterminantTensorImpl< T, 3 >
struct	DiagBlockIndex
struct	DisplacementCubitBcData
	Definition of the displacement bc data structure. More...
struct	DisplacementCubitBcDataWithRotation
	A specialized version of DisplacementCubitBcData that includes an additional rotation offset. More...
struct	DMCtx
	PETSc Discrete Manager data structure. More...
struct	DMCtxImpl
struct	DMMGViaApproxOrdersCtx
	Structure for DM for multi-grid via approximation orders. More...
struct	DOF_Unique_mi_tag
struct	DofEntity
	keeps information about DOF on the entity More...
struct	DofEntity_active_change
struct	DofMethod
	Data structure to exchange data between mofem and User Loop Methods on entities. More...
struct	EdgeElementForcesAndSourcesCore
	Edge finite element. More...
struct	EdgeElementForcesAndSourcesCoreOnChildParent
	Base face element used to integrate on skeleton. 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	EntDofIdx_mi_tag
struct	EntFiniteElement
	Finite element data for entity. More...
struct	EntitiesFieldData
	data structure for finite element entity More...
struct	EntityCacheDofs
struct	EntityCacheNumeredDofs
struct	EntityMethod
	Data structure to exchange data between mofem and User Loop Methods on entities. More...
struct	EntityStorage
struct	EntPolynomialBaseCtx
	Class used to pass element data to calculate base functions on tet,triangle,edge. More...
struct	EntType_mi_tag
struct	EqBit
struct	EssentialBC
	Essential boundary conditions. More...
struct	EssentialBcStorage
	[Storage and set boundary conditions] More...
struct	EssentialPostProcLhs
	Class (Function) to enforce essential constrains on the left hand side diagonal. More...
struct	EssentialPostProcLhs< DisplacementCubitBcData >
	Specialization for DisplacementCubitBcData. More...
struct	EssentialPostProcLhs< MPCsType >
	Specialization for MPCsType. More...
struct	EssentialPostProcRhs
	Class (Function) to enforce essential constrains on the right hand side diagonal. More...
struct	EssentialPostProcRhs< DisplacementCubitBcData >
	Specialization for DisplacementCubitBcData. More...
struct	EssentialPostProcRhs< MPCsType >
	Specialization for DisplacementCubitBcData. More...
struct	EssentialPreProc
	Class (Function) to enforce essential constrains. More...
struct	EssentialPreProc< DisplacementCubitBcData >
	Specialization for DisplacementCubitBcData. More...
struct	EssentialPreProc< MPCsType >
	Type generating multipoint constraints. More...
struct	EssentialPreProc< TemperatureCubitBcData >
	Specialization for TemperatureCubitBcData. More...
struct	EssentialPreProcReaction
	Class (Function) to calculate residual side diagonal. More...
struct	EssentialPreProcReaction< DisplacementCubitBcData >
	Specialization for DisplacementCubitBcData. More...
struct	FaceElementForcesAndSourcesCore
	Face finite element. More...
struct	FaceElementForcesAndSourcesCoreOnChildParent
	Base face element used to integrate on skeleton. More...
struct	FaceElementForcesAndSourcesCoreOnChildParentSwitch
struct	FaceElementForcesAndSourcesCoreOnSide
	Base face element used to integrate on skeleton. More...
struct	FaceElementForcesAndSourcesCoreOnSideSwitch
struct	FatPrismElementForcesAndSourcesCore
	FatPrism finite element. More...
struct	FatPrismPolynomialBase
	Calculate base functions on tetrahedral. More...
struct	FatPrismPolynomialBaseCtx
	Class used to pass element data to calculate base functions on fat prism. More...
struct	FE_Unique_mi_tag
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 elements More...
struct	FENumeredDofEntity
	keeps information about indexed dofs for the finite element More...
struct	Field
	Provide data structure for (tensor) field approximation. More...
struct	FieldBlas
	Basic algebra on fields. More...
struct	FieldEntity
	Struct keeps handle to entity in the field. More...
struct	FieldEntity_change_order
	structure to change FieldEntity order More...
struct	FieldEntityEntFiniteElementAdjacencyMap
	FieldEntityEntFiniteElementAdjacencyMap of mofem finite element and entities. More...
struct	FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat
struct	FieldEvaluatorInterface
	Field evaluator interface. More...
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
	Finite element definition. More...
struct	FiniteElement_change_bit_add
	Add field to data. More...
struct	FiniteElement_change_bit_off
	Unset field from data. More...
struct	FiniteElement_change_bit_reset
	Reset 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_col_change_bit_reset
	Reset 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	FiniteElement_row_change_bit_reset
	Reset field from row. More...
struct	FlatPrismElementForcesAndSourcesCore
	FlatPrism finite element. More...
struct	FlatPrismPolynomialBase
	Calculate base functions on tetrahedral. More...
struct	FlatPrismPolynomialBaseCtx
	Class used to pass element data to calculate base functions on flat prism. More...
struct	FluxOpType
	Wrapper to generate natural b.c. specialisation based on operator type. More...
struct	ForceCubitBcData
	Definition of the force bc data structure. More...
struct	ForcesAndSourcesCore
	structure to get information form mofem into EntitiesFieldData More...
struct	FormsIntegrators
	Integrator forms. More...
struct	GenericAttributeData
	Generic attribute data structure. More...
struct	GenericCubitBcData
	Generic bc data structure. More...
struct	GetFTensor0FromVecImpl
struct	GetFTensor1FromArray
struct	GetFTensor1FromArray< 1, S >
struct	GetFTensor1FromArray< 2, S >
struct	GetFTensor1FromArray< 3, S >
struct	GetFTensor1FromArray< 4, S >
struct	GetFTensor1FromArray< 6, S >
struct	GetFTensor1FromArray< 9, S >
struct	GetFTensor1FromMatImpl
struct	GetFTensor1FromMatImpl< 1, S, T, ublas::row_major, A >
struct	GetFTensor1FromMatImpl< 2, S, T, ublas::row_major, A >
struct	GetFTensor1FromMatImpl< 3, S, T, ublas::row_major, A >
struct	GetFTensor1FromMatImpl< 4, S, T, ublas::row_major, A >
struct	GetFTensor1FromMatImpl< 6, S, T, ublas::row_major, A >
struct	GetFTensor1FromMatImpl< 9, S, T, ublas::row_major, A >
struct	GetFTensor1FromPtrImpl
struct	GetFTensor1FromPtrImpl< 1, S, T >
struct	GetFTensor1FromPtrImpl< 2, S, T >
struct	GetFTensor1FromPtrImpl< 3, S, T >
struct	GetFTensor1FromPtrImpl< 4, S, T >
struct	GetFTensor1FromPtrImpl< 6, S, T >
struct	GetFTensor2FromArrayImpl
	Get FTensor2 from array. More...
struct	GetFTensor2FromArrayImpl< 2, 2, S, T, L, A >
struct	GetFTensor2FromArrayImpl< 3, 3, S, T, L, A >
struct	GetFTensor2FromArrayRawPtrImpl
struct	GetFTensor2FromArrayRawPtrImpl< 2, 2, T, L, A >
struct	GetFTensor2FromArrayRawPtrImpl< 3, 3, T, L, A >
struct	GetFTensor2FromMatImpl
struct	GetFTensor2FromPtr
struct	GetFTensor2FromPtr< 1, 1, S, T >
struct	GetFTensor2FromPtr< 1, 2, S, T >
struct	GetFTensor2FromPtr< 1, 3, S, T >
struct	GetFTensor2FromPtr< 2, 2, S, T >
struct	GetFTensor2FromPtr< 3, 2, S, T >
struct	GetFTensor2FromPtr< 3, 3, S, T >
struct	GetFTensor2FromPtr< 6, 6, S, T >
struct	GetFTensor2SymmetricFromMatImpl
struct	GetFTensor2SymmetricFromMatImpl< 2, S, T, L, A >
struct	GetFTensor2SymmetricFromMatImpl< 3, S, T, L, A >
struct	GetFTensor3DgFromMatImpl
struct	GetFTensor3DgFromMatImpl< 1, 1, S, T, ublas::row_major, A >
struct	GetFTensor3DgFromMatImpl< 2, 2, S, T, ublas::row_major, A >
struct	GetFTensor3DgFromMatImpl< 3, 3, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl
struct	GetFTensor3FromMatImpl< 1, 1, 1, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl< 2, 2, 2, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl< 2, 2, 3, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl< 3, 2, 2, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl< 3, 3, 3, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl< 3, 3, 6, S, T, ublas::row_major, A >
struct	GetFTensor3FromMatImpl< 6, 3, 3, S, T, ublas::row_major, A >
struct	GetFTensor4DdgFromMatImpl
struct	GetFTensor4DdgFromMatImpl< 1, 1, S, T, ublas::row_major, A >
struct	GetFTensor4DdgFromMatImpl< 2, 2, S, T, ublas::row_major, A >
struct	GetFTensor4DdgFromMatImpl< 3, 3, S, T, ublas::row_major, A >
struct	GetFTensor4DdgFromPtrImpl
struct	GetFTensor4DdgFromPtrImpl< 3, 3, S, T >
struct	GetFTensor4FromMatImpl
struct	GetFTensor4FromMatImpl< 1, 1, 1, 1, S, T, ublas::row_major, A >
struct	GetFTensor4FromMatImpl< 2, 2, 2, 2, S, T, ublas::row_major, A >
struct	GetFTensor4FromMatImpl< 3, 3, 3, 3, S, T, ublas::row_major, A >
struct	HashBit
struct	HeatFluxCubitBcData
	Definition of the heat flux bc data structure. More...
struct	HexPolynomialBase
	Calculate base functions on tetrahedral. More...
struct	Idx_mi_tag
struct	IdxDataType
struct	IdxDataTypePtr
struct	IntegratedJacobiPolynomial
struct	IntegratedJacobiPolynomialCtx
struct	interface_DofEntity
	Interface to DofEntity. More...
struct	interface_EntFiniteElement
	interface to EntFiniteElement More...
struct	interface_Field
struct	interface_Field< T, T >
struct	interface_FieldEntity
	Interface to FieldEntity. More...
struct	interface_FieldImpl
	Pointer interface for MoFEM::Field. More...
struct	interface_FieldSeries
struct	interface_FiniteElement
struct	interface_FiniteElement< T, T >
struct	interface_FiniteElementImpl
	Inetface for FE. More...
struct	interface_RefElement
	intrface to RefElement More...
struct	interface_RefEntity
	interface to RefEntity More...
struct	InvertTensorImpl
struct	InvertTensorImpl< T1, T2, T3, 2 >
struct	InvertTensorImpl< T1, T2, T3, 3 >
struct	ISManager
	Section manager is used to create indexes and sections. 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) context 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	LogManager
	Log manager is used to build and partition problems. 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	MatrixManager
	Matrix manager is used to build and partition problems. 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	Modify_change_nothing
	Do nothing, used to rebuild database. More...
struct	MPCsType
struct	NaturalBC
	Natural boundary conditions. More...
struct	NaturalForceMeshsets
	Type generating specialisation for force meshsets. More...
struct	NaturalForceMeshsetsScalarAndVectorScaling
	Type generating specialisation for force meshsets. More...
struct	NaturalMeshsetType
	Type generating natural b.c. specialisations for meshsets. More...
struct	NaturalMeshsetTypeVectorScaling
struct	NaturalTemperatureMeshsets
	Type generating specialisation for temperature meshsets. More...
struct	NodeMergerInterface
	Merge node by collapsing edge between them. More...
struct	NumeredDofEntity
	keeps information about indexed dofs for the problem More...
struct	NumeredDofEntity_local_idx_change
struct	NumeredDofEntity_mofem_index_change
struct	NumeredDofEntity_part_and_all_indices_change
struct	NumeredDofEntity_part_and_glob_idx_change
struct	NumeredDofEntity_part_and_indices_change
struct	NumeredDofEntity_part_and_mofem_glob_idx_change
struct	NumeredEntFiniteElement
	Partitioned (Indexed) Finite Element in Problem. More...
struct	NumeredEntFiniteElement_change_part
	Change finite element part. More...
struct	OpAddParentEntData
	Operator to project base functions from parent entity to child. More...
struct	OpBaseDerivativesBase
struct	OpBaseDerivativesMass
struct	OpBaseDerivativesMass< 1 >
struct	OpBaseDerivativesMass< 3 >
struct	OpBaseDerivativesNext
struct	OpBaseDerivativesNext< 1 >
	Specialisation for calculate derivatives for scalar base functions. More...
struct	OpBaseDerivativesNext< 3 >
	Specialisation for calculate derivatives for scalar base functions. More...
struct	OpBaseDerivativesSetHOInvJacobian
struct	OpBaseDerivativesSetHOInvJacobian< 2 >
struct	OpBaseImpl
struct	OpBaseTimesScalarImpl
struct	OpBaseTimesScalarImpl< 1, S, GAUSS, OpBase >
struct	OpBaseTimesVectorImpl
struct	OpBaseTimesVectorImpl< 1, FIELD_DIM, S, GAUSS, OpBase >
struct	OpBaseTimesVectorImpl< 3, FIELD_DIM, S, GAUSS, OpBase >
struct	OpBrokenBaseImpl
struct	OpBrokenLoopSide
struct	OpBrokenSpaceConstrainDFluxImpl
struct	OpBrokenSpaceConstrainDFluxImpl< FIELD_DIM, GAUSS, OpBrokenBase >
struct	OpBrokenSpaceConstrainDHybridImpl
struct	OpBrokenSpaceConstrainDHybridImpl< FIELD_DIM, GAUSS, OpBase >
struct	OpBrokenSpaceConstrainImpl
struct	OpBrokenSpaceConstrainImpl< FIELD_DIM, GAUSS, OpBrokenBase >
struct	OpCalcNormL2Tensor0
	Get norm of input VectorDouble for Tensor0. More...
struct	OpCalcNormL2Tensor1
	Get norm of input MatrixDouble for Tensor1. More...
struct	OpCalcNormL2Tensor2
	Get norm of input MatrixDouble for Tensor2. More...
struct	OpCalculateDivergenceVectorFieldValues
	Calculate field values (template specialization) for tensor field rank 1, i.e. vector field. More...
struct	OpCalculateHcurlVectorCurl
	Calculate curl of vector field. More...
struct	OpCalculateHcurlVectorCurl< 1, 2 >
	Calculate curl of vector field. More...
struct	OpCalculateHcurlVectorCurl< 1, 3 >
	Calculate curl of vector field. More...
struct	OpCalculateHcurlVectorCurl< 3, 3 >
	Calculate curl of vector field. More...
struct	OpCalculateHdivVectorDivergence
	Calculate divergence of vector field. More...
struct	OpCalculateHdivVectorDivergenceDot
	Calculate divergence of vector field dot. More...
struct	OpCalculateHOCoords
	Calculate HO coordinates at gauss points. More...
struct	OpCalculateHOJac
struct	OpCalculateHOJac< 2 >
struct	OpCalculateHOJac< 3 >
struct	OpCalculateHOJacForFaceImpl
	Calculate jacobian for face element. More...
struct	OpCalculateHOJacForFaceImpl< 2 >
struct	OpCalculateHOJacForFaceImpl< 3 >
struct	OpCalculateHOJacForVolume
	Calculate jacobian on Hex or other volume which is not simplex. More...
struct	OpCalculateHTensorTensorField
	Calculate tenor field using tensor base, i.e. Hdiv/Hcurl. More...
struct	OpCalculateHVecTensorDivergence
	Calculate divergence of tonsorial field using vectorial base. More...
struct	OpCalculateHVecTensorField
	Calculate tenor field using vectorial base, i.e. Hdiv/Hcurl. More...
struct	OpCalculateHVecTensorTrace
	Calculate trace of vector (Hdiv/Hcurl) space. More...
struct	OpCalculateHVecVectorField
	Get vector field for H-div approximation. More...
struct	OpCalculateHVecVectorField_General
	Get vector field for H-div approximation. More...
struct	OpCalculateHVecVectorField_General< 3, Field_Dim, double, ublas::row_major, DoubleAllocator >
	Get vector field for H-div approximation. More...
struct	OpCalculateHVecVectorFieldDot
	Get vector field for H-div approximation. More...
struct	OpCalculateHVecVectorFieldDot< 3, Field_Dim >
struct	OpCalculateHVecVectorGradient
	Calculate gradient of vector field. More...
struct	OpCalculateHVecVectorHessian
	Calculate gradient of vector field. 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, DoubleAllocator >
	Evaluate field gradient values for scalar field, i.e. gradient is tensor rank 1 (vector), specialization. More...
struct	OpCalculateScalarFieldHessian
	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
	Scalar field values at integration points. More...
struct	OpCalculateScalarFieldValuesFromPetscVecImpl
	Get rate of scalar field at integration points. More...
struct	OpCalculateTensor2FieldValues
	Get values at integration pts for tensor filed rank 2, i.e. matrix field. More...
struct	OpCalculateTensor2FieldValues_General
	Calculate field values for tenor field rank 2. More...
struct	OpCalculateTensor2FieldValues_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, DoubleAllocator >
struct	OpCalculateTensor2FieldValuesDot
	Get time direvarive values at integration pts for tensor filed rank 2, i.e. matrix field. More...
struct	OpCalculateTensor2SymmetricFieldGradient
	Get field gradients at integration pts for symmetric tensorial field rank 2. More...
struct	OpCalculateTensor2SymmetricFieldGradient_General
	Evaluate field gradient values for symmetric 2nd order tensor field, i.e. gradient is tensor rank 3. More...
struct	OpCalculateTensor2SymmetricFieldGradient_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, DoubleAllocator >
struct	OpCalculateTensor2SymmetricFieldValues
	Calculate symmetric tensor field values at integration pts. More...
struct	OpCalculateTensor2SymmetricFieldValuesDot
	Calculate symmetric tensor field rates ant integratio pts. More...
struct	OpCalculateTraceFromMat
	Calculates the trace of an input matrix. More...
struct	OpCalculateTraceFromSymmMat
	Calculates the trace of an input matrix. 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, DoubleAllocator >
struct	OpCalculateVectorFieldGradientDot
	Get field gradients time derivative at integration pts for scalar filed rank 0, i.e. vector field. More...
struct	OpCalculateVectorFieldHessian
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, DoubleAllocator >
	Calculate field values (template specialization) for tensor field rank 1, i.e. vector field. More...
struct	OpCalculateVectorFieldValuesFromPetscVecImpl
	Approximate field values for given petsc vector. More...
struct	OpConvectiveTermLhsDuImpl
struct	OpConvectiveTermLhsDuImpl< 1, 1, SPACE_DIM, GAUSS, OpBase >
struct	OpConvectiveTermLhsDuImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase >
struct	OpConvectiveTermLhsDyImpl
struct	OpConvectiveTermLhsDyImpl< 1, 1, SPACE_DIM, GAUSS, OpBase >
struct	OpConvectiveTermLhsDyImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase >
struct	OpConvectiveTermRhsImpl
struct	OpConvectiveTermRhsImpl< 1, 1, SPACE_DIM, GAUSS, OpBase >
struct	OpConvectiveTermRhsImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase >
struct	OpCopyGeomDataToE
	Copy geometry-related data from one element to other. More...
struct	OpCopyGeomDataToE< 2 >
	Copy geometry-related data from one element to other. More...
struct	OpDGProjectionCoefficients
struct	OpDGProjectionEvaluation
struct	OpDGProjectionMassMatrix
struct	OperatorsTester
	Calculate directional derivative of the right hand side and compare it with tangent matrix derivative. More...
struct	OpEssentialLhsImpl
	Enforce essential constrains on lhs. More...
struct	OpEssentialLhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >
struct	OpEssentialLhsImpl< HeatFluxCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >
struct	OpEssentialLhsImpl< MPCsType, BASE_DIM, FIELD_DIM, A, I, OpBase >
struct	OpEssentialLhsImpl< TemperatureCubitBcData, 1, 1, A, I, OpBase >
struct	OpEssentialRhsImpl
	Enforce essential constrains on rhs. More...
struct	OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase >
struct	OpEssentialRhsImpl< HeatFluxCubitBcData, 3, 2, A, GAUSS, OpBase >
struct	OpEssentialRhsImpl< HeatFluxCubitBcData, 3, 3, A, GAUSS, OpBase >
struct	OpEssentialRhsImpl< MPCsType, 1, FIELD_DIM, A, I, OpBase >
struct	OpEssentialRhsImpl< TemperatureCubitBcData, 1, 1, A, I, OpBase >
struct	OpFluxLhsImpl
struct	OpFluxRhsImpl
struct	OpFluxRhsImpl< NaturalMeshsetType< BLOCKSET >, 1, 1, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< BLOCKSET >, 1, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< BLOCKSET >, 3, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< FORCESET >, 1, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< HEATFLUXSET >, 1, 1, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< PRESSURESET >, 1, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< TEMPERATURESET >, 3, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< UNKNOWNSET >, 1, 1, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetType< UNKNOWNSET >, 1, FIELD_DIM, A, I, OpBase >
	Base class for OpFluxRhsImpl<NaturalMeshsetType<T>, 1, FIELD_DIM, A, I, OpBase> More...
struct	OpFluxRhsImpl< NaturalMeshsetType< UNKNOWNSET >, 3, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetTypeVectorScaling< BLOCKSET >, 1, FIELD_DIM, A, I, OpBase >
struct	OpFluxRhsImpl< NaturalMeshsetTypeVectorScaling< UNKNOWNSET >, 1, FIELD_DIM, A, I, OpBase >
struct	OpGetBrokenBaseSideData
struct	OpGetCoordsAndNormalsOnPrism
	calculate normals at Gauss points of triangle element More...
struct	OpGetDataAndGradient
	Get field values and gradients at Gauss points. More...
struct	OpGetHONormalsOnFace
	Calculate normals at Gauss points of triangle element. More...
struct	OpGetHOTangentOnEdge
	Calculate tangent vector on edge form HO geometry approximation. More...
struct	OpGetHOTangentsOnEdge
	Calculate tangent vector on edge form HO geometry approximation. More...
struct	OpGetTensor0fromFunc
	Get values from scalar function at integration points and save them to VectorDouble for Tensor0. More...
struct	OpGetTensor1fromFunc
struct	OpGradGradImpl
struct	OpGradGradImpl< 1, 1, SPACE_DIM, GAUSS, OpBase >
struct	OpGradGradImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase >
struct	OpGradGradSymTensorGradGradImpl
struct	OpGradGradSymTensorGradGradImpl< 1, 1, SPACE_DIM, S, GAUSS, OpBase >
struct	OpGradSymTensorGradImpl
struct	OpGradSymTensorGradImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase >
struct	OpGradTensorGradImpl
struct	OpGradTensorGradImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase >
struct	OpGradTimesSymTensorImpl
struct	OpGradTimesSymTensorImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase >
struct	OpGradTimesTensorImpl
struct	OpGradTimesTensorImpl< 1, 1, SPACE_DIM, S, GAUSS, OpBase >
struct	OpGradTimesTensorImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase >
struct	OpHOSetContravariantPiolaTransformOnEdge3D
	transform Hcurl base fluxes from reference element to physical edge More...
struct	OpHOSetContravariantPiolaTransformOnFace3D
	transform Hdiv base fluxes from reference element to physical triangle More...
struct	OpHOSetCovariantPiolaTransformOnFace3D
	transform Hcurl base fluxes from reference element to physical triangle More...
struct	OpInvertMatrix
struct	OpLoopSide
	Element used to execute operators on side of the element. More...
struct	OpLoopThis
	Execute "this" element in the operator. More...
struct	OpMakeHdivFromHcurl
	Make Hdiv space from Hcurl space in 2d. More...
struct	OpMassCacheImpl
struct	OpMassCacheImpl< 1, FIELD_DIM, I, OpBase >
struct	OpMassImpl
struct	OpMassImpl< 1, 1, GAUSS, OpBase >
struct	OpMassImpl< 1, FIELD_DIM, GAUSS, OpBase >
struct	OpMassImpl< 3, 4, GAUSS, OpBase >
struct	OpMassImpl< 3, 9, GAUSS, OpBase >
struct	OpMassImpl< 3, FIELD_DIM, GAUSS, OpBase >
struct	OpMixDivTimesScalarImpl
struct	OpMixDivTimesScalarImpl< SPACE_DIM, GAUSS, OpBase >
struct	OpMixDivTimesUImpl
struct	OpMixDivTimesUImpl< 1, FIELD_DIM, FIELD_DIM, GAUSS, OpBase, CoordSys >
struct	OpMixDivTimesUImpl< 3, 1, SPACE_DIM, GAUSS, OpBase, CoordSys >
struct	OpMixDivTimesUImpl< 3, FIELD_DIM, SPACE_DIM, GAUSS, OpBase, CoordSys >
struct	OpMixDivTimesVecImpl
struct	OpMixDivTimesVecImpl< SPACE_DIM, GAUSS, OpBase, CoordSys >
struct	OpMixScalarTimesDivImpl
struct	OpMixScalarTimesDivImpl< SPACE_DIM, GAUSS, OpBase, COORDINATE_SYSTEM >
struct	OpMixTensorTimesGradImpl
struct	OpMixTensorTimesGradImpl< SPACE_DIM, GAUSS, OpBase >
struct	OpMixTensorTimesGradUImpl
	Tensor field time gradient of vector field. More...
struct	OpMixTensorTimesGradUImpl< SPACE_DIM, GAUSS, OpBase >
struct	OpMixVecTimesDivLambdaImpl
	Vector filed time divergence of tensor. More...
struct	OpMixVecTimesDivLambdaImpl< SPACE_DIM, GAUSS, OpBase >
struct	OpMixVectorTimesGradImpl
struct	OpMixVectorTimesGradImpl< 1, SPACE_DIM, SPACE_DIM, GAUSS, OpBase >
struct	OpMixVectorTimesGradImpl< 3, SPACE_DIM, SPACE_DIM, GAUSS, OpBase >
struct	OpMultiplyDeterminantOfJacobianAndWeightsForFatPrisms
	Operator for fat prism element updating integration weights in the volume. More...
struct	OpNormalMixVecTimesScalarImpl
	Multiply vector times normal on the face times scalar function. More...
struct	OpNormalMixVecTimesScalarImpl< 2, GAUSS, OpBase >
struct	OpNormalMixVecTimesScalarImpl< 3, GAUSS, OpBase >
struct	OpNormalMixVecTimesVectorFieldImpl
	Multiply vector times normal on the face times vector field. More...
struct	OpNormalMixVecTimesVectorFieldImpl< SPACE_DIM, GAUSS, OpBase >
struct	OpPostProcMapInMoab
	Post post-proc data at points from hash maps. More...
struct	OpRunParent
	Operator to execute finite element instance on parent element. This operator is typically used to project field from parent to child, or vice versa. It enables to evaluate filed data of parent entity on chile entity integration points. More...
struct	OpScaleBaseBySpaceInverseOfMeasure
	Scale base functions by inverses of measure of element. More...
struct	OpScaleMatrix
struct	OpSchurAssembleBase
struct	OpSchurAssembleBaseImpl
struct	OpSchurAssembleBegin
	Clear Schur complement internal data. More...
struct	OpSchurAssembleEnd
	Assemble Schur complement. More...
struct	OpSchurAssembleEnd< SchurDGESV >
struct	OpSchurAssembleEnd< SchurDSYSV >
struct	OpSchurAssembleEndImpl
	Assemble Schur complement (Implementation) More...
struct	OpSetBc
	Set indices on entities on finite element. More...
struct	OpSetContravariantPiolaTransform
	apply contravariant (Piola) transfer to Hdiv space More...
struct	OpSetContravariantPiolaTransformOnEdge2D
struct	OpSetContravariantPiolaTransformOnFace
	transform Hdiv base fluxes from reference element to physical triangle More...
struct	OpSetContravariantPiolaTransformOnFace2DImpl
	Apply contravariant (Piola) transfer to Hdiv space on face. More...
struct	OpSetContravariantPiolaTransformOnFace2DImpl< 2 >
struct	OpSetContravariantPiolaTransformOnFace2DImpl< 3 >
struct	OpSetCovariantPiolaTransform
	apply covariant transfer to Hcurl space More...
struct	OpSetCovariantPiolaTransformOnEdge
	transform Hcurl base fluxes from reference element to physical edge More...
struct	OpSetCovariantPiolaTransformOnFace
	transform Hcurl base fluxes from reference element to physical triangle More...
struct	OpSetCovariantPiolaTransformOnFace2DImpl
	Transform Hcurl base fluxes from reference element to physical triangle. More...
struct	OpSetCovariantPiolaTransformOnFace2DImpl< 2 >
	Apply contravariant (Piola) transfer to Hdiv space on face. More...
struct	OpSetFlux
struct	OpSetHOContravariantPiolaTransform
	Apply contravariant (Piola) transfer to Hdiv space for HO geometry. More...
struct	OpSetHOCovariantPiolaTransform
	Apply covariant (Piola) transfer to Hcurl space for HO geometry. More...
struct	OpSetHOInvJacToScalarBases
	Set inverse jacobian to base functions. More...
struct	OpSetHOInvJacToScalarBases< 2 >
struct	OpSetHOInvJacToScalarBasesImpl
struct	OpSetHOInvJacVectorBase
	transform local reference derivatives of shape function to global derivatives if higher order geometry is given More...
struct	OpSetHOWeights
	Set inverse jacobian to base functions. More...
struct	OpSetHOWeightsOnEdge
	Modify integration weights on face to take in account higher-order geometry. More...
struct	OpSetHOWeightsOnFace
	Modify integration weights on face to take in account higher-order geometry. More...
struct	OpSetHOWeightsOnSubDim
struct	OpSetHOWeightsOnSubDim< 2 >
struct	OpSetHOWeightsOnSubDim< 3 >
struct	OpSetInvJacH1
	Transform local reference derivatives of shape function to global derivatives. More...
struct	OpSetInvJacH1ForFace
struct	OpSetInvJacH1ForFaceEmbeddedIn3DSpace
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	OpSetInvJacHcurlFaceImpl
	Transform local reference derivatives of shape function to global derivatives for face. More...
struct	OpSetInvJacHcurlFaceImpl< 2 >
struct	OpSetInvJacHcurlFaceImpl< 3 >
struct	OpSetInvJacHdivAndHcurl
	brief Transform local reference derivatives of shape function to global derivatives More...
struct	OpSetInvJacL2ForFace
struct	OpSetInvJacL2ForFaceEmbeddedIn3DSpace
struct	OpSetInvJacSpaceForFaceImpl
	Transform local reference derivatives of shape functions to global derivatives. More...
struct	OpSetInvJacSpaceForFaceImpl< 2, 1 >
struct	OpSetInvJacSpaceForFaceImpl< 2, 2 >
struct	OpSetInvJacSpaceForFaceImpl< 3, 1 >
struct	OpSetInvJacToScalarBasesBasic
struct	OpSourceImpl
struct	OpSourceImpl< 1, 1, GAUSS, SourceFunctionSpecialization::S< OpBase > >
	Integrate source. More...
struct	OpSourceImpl< 1, FIELD_DIM, GAUSS, SourceFunctionSpecialization::S< OpBase > >
struct	OpSourceImpl< 3, FIELD_DIM, GAUSS, SourceFunctionSpecialization::S< OpBase > >
struct	OpSourceImpl< 3, FIELD_DIM, I, SourceBoundaryNormalSpecialization::S< OpBase > >
	This is specialisation for sources on boundary which depends on normal. More...
struct	OpSymmetrizeTensor
struct	OpTensorTimesSymmetricTensor
	Calculate \( \pmb\sigma_{ij} = \mathbf{D}_{ijkl} \pmb\varepsilon_{kl} \). More...
struct	OpUnSetBc
struct	Order_mi_tag
	MultiIndex Tag for field order. More...
struct	PairNameFEMethodPtr
struct	ParentFiniteElementAdjacencyFunction
	Create adjacency to parent elements. More...
struct	ParentFiniteElementAdjacencyFunctionSkeleton
	Create adjacency to parent skeleton elements. More...
struct	Part_mi_tag
struct	PCMGSetUpViaApproxOrdersCtx
struct	PCMGSubMatrixCtx
struct	PetscData
struct	PetscGlobalIdx_mi_tag
struct	PetscLocalIdx_mi_tag
struct	PipelineManager
	PipelineManager interface. More...
struct	PostProcBrokenMeshInMoab
struct	PostProcBrokenMeshInMoab< EdgeElementForcesAndSourcesCore >
struct	PostProcBrokenMeshInMoab< FaceElementForcesAndSourcesCore >
struct	PostProcBrokenMeshInMoab< VolumeElementForcesAndSourcesCore >
struct	PostProcBrokenMeshInMoabBase
struct	PostProcBrokenMeshInMoabBaseBeginImpl
struct	PostProcBrokenMeshInMoabBaseContImpl
struct	PostProcBrokenMeshInMoabBaseEndImpl
struct	PostProcGenerateRefMesh
	Element for postprocessing. Uses MoAB to generate post-processing mesh. More...
struct	PostProcGenerateRefMesh< MBEDGE >
struct	PostProcGenerateRefMesh< MBHEX >
struct	PostProcGenerateRefMesh< MBQUAD >
struct	PostProcGenerateRefMesh< MBTET >
struct	PostProcGenerateRefMesh< MBTRI >
struct	PostProcGenerateRefMeshBase
struct	PressureCubitBcData
	Definition of the pressure bc data structure. More...
struct	PrismInterface
	Create interface from given surface and insert flat prisms in-between. More...
struct	PrismsFromSurfaceInterface
	merge node from two bit levels More...
struct	Problem
	keeps basic data about problem More...
struct	Problem_mi_tag
struct	ProblemChangeRefLevelBitAdd
	add ref level to problem More...
struct	ProblemChangeRefLevelBitDofMaskAdd
	set prof dof bit ref mask More...
struct	ProblemChangeRefLevelBitDofMaskSet
	set prof dof bit ref mask More...
struct	ProblemChangeRefLevelBitSet
	set ref level to problem More...
struct	ProblemClearComposedProblemData
	Clear composed problem data structure. More...
struct	ProblemClearNumeredFiniteElementsChange
	clear problem finite elements More...
struct	ProblemClearSubProblemData
	Clear sub-problem data structure. 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	QuadPolynomialBase
	Calculate base functions on triangle. More...
struct	RefElement
	keeps data about abstract refined finite element 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_VERTEX
	keeps data about abstract VERTEX finite element More...
struct	RefElementFace
	keeps data about abstract TRI finite element More...
struct	RefElementVolume
	keeps data about abstract TET finite element More...
struct	RefEntExtractor
	Extract entity handle form multi-index container. More...
struct	RefEntity_change_left_shift
	ref mofem entity, left shift More...
struct	RefEntity_change_parent
	change parent More...
struct	RefEntity_change_right_shift
	ref mofem entity, right shift More...
struct	RefEntityTmp
struct	RefEntityTmp< 0 >
	Struct keeps handle to refined handle. More...
struct	RefEntityTmp<-1 >
struct	ScalingMethod
struct	SchurBackendMatSetValuesPtr
struct	SchurDGESV
struct	SchurDSYSV
struct	SchurElemMats
	Schur complement data storage. More...
struct	SchurElemMatsBlock
struct	SchurElemMatsPreconditionedBlock
struct	SchurEvents
	Structure to register events for Schur block assembly and solver. More...
struct	SeriesID_mi_tag
struct	SeriesName_mi_tag
struct	SeriesRecorder
struct	SetBitRefLevelTool
	tool class with methods used more than twp times More...
struct	SetOtherGlobalGhostVector
struct	SetOtherLocalGhostVector
struct	SideNumber
	keeps information about side number for the finite element More...
struct	SideNumber_mi_tag
struct	Simple
	Simple interface for fast problem set-up. More...
struct	SmartPetscObj
	intrusive_ptr for managing petsc objects More...
struct	SnesCtx
	Interface for nonlinear (SNES) solver. More...
struct	SnesMethod
	data structure for snes (nonlinear solver) context More...
struct	SourceBoundaryNormalSpecialization
struct	SourceFunctionSpecialization
struct	Space_mi_tag
struct	TemperatureCubitBcData
	Definition of the temperature bc data structure. More...
struct	TempMeshset
struct	TetGenInterface
	TetGen interface. More...
struct	TetPolynomialBase
	Calculate base functions on tetrahedral. More...
struct	TimeScale
	Force scale operator for reading two columns. More...
struct	TimeScaleVector
	Force scale operator for reading four columns (time and vector) More...
struct	Tools
	Auxiliary tools. More...
struct	TriPolynomialBase
	Calculate base functions on triangle. More...
struct	TSAdaptMoFEM
	Custom TSAdaptivity in MoFEM. More...
struct	TsCtx
	Interface for Time Stepping (TS) solver. More...
struct	TSMethod
	data structure for TS (time stepping) context More...
struct	TypeSide_mi_tag
struct	Unique_Ent_mi_tag
struct	Unique_FiniteElement_mi_tag
struct	Unique_mi_tag
struct	UnknownInterface
	base class for all interface classes More...
struct	VecManager
	Vector manager is used to create vectors \mofem_vectors. More...
struct	VelocityCubitBcData
	Definition of the velocity bc data structure. More...
struct	Version
struct	VertexElementForcesAndSourcesCore
	Vertex finite element. More...
struct	VolumeElementForcesAndSourcesCore
	Volume finite element base. More...
struct	VolumeElementForcesAndSourcesCoreOnContactPrismSide
	Base volume element used to integrate on contact surface (could be extended to other volume elements) More...
struct	VolumeElementForcesAndSourcesCoreOnContactPrismSideSwitch
struct	VolumeElementForcesAndSourcesCoreOnSide
	Base volume element used to integrate on skeleton. More...
struct	VolumeElementForcesAndSourcesCoreOnSideSwitch
struct	VolumeElementForcesAndSourcesCoreSwitch
struct	WrapMPIComm
	Wrap MPI communicator such that is destroyed when is out of scope. More...

Typedefs
template<typename T >
using	ShardVec = boost::shared_ptr< std::vector< T > >
template<int DIM>
using	i_FTIndex = FTensor::Index< 'i', DIM >
template<int DIM>
using	j_FTIndex = FTensor::Index< 'j', DIM >
template<int DIM>
using	k_FTIndex = FTensor::Index< 'k', DIM >
template<int DIM>
using	l_FTIndex = FTensor::Index< 'l', DIM >
template<int DIM>
using	m_FTIndex = FTensor::Index< 'm', DIM >
template<int DIM>
using	n_FTIndex = FTensor::Index< 'n', DIM >
template<int DIM>
using	I_FTIndex = FTensor::Index< 'I', DIM >
template<int DIM>
using	J_FTIndex = FTensor::Index< 'J', DIM >
template<int DIM>
using	K_FTIndex = FTensor::Index< 'K', DIM >
template<int DIM>
using	L_FTIndex = FTensor::Index< 'L', DIM >
template<int DIM>
using	M_FTIndex = FTensor::Index< 'M', DIM >
template<int DIM>
using	N_FTIndex = FTensor::Index< 'N', DIM >
using	VecOfTimeScalingMethods = std::vector< boost::shared_ptr< ScalingMethod > >
	Vector of time scaling methods. More...
template<int FIELD_DIM>
using	VecOfTimeVectorScalingMethods = std::vector< boost::shared_ptr< TimeScaleVector< FIELD_DIM > >>
	Vector of time vector scaling methods. More...
using	TimeScaleVector3 = TimeScaleVector< 3 >
using	TimeScaleVector2 = TimeScaleVector< 3 >
using	CacheMatsTypeType = std::map< std::pair< int, int >, boost::shared_ptr< MatrixDouble > >
using	DofsAllocator = ublas::unbounded_array< FEDofEntity *, std::allocator< FEDofEntity * > >
using	VectorDofs = ublas::vector< FEDofEntity *, DofsAllocator >
using	FieldEntAllocator = ublas::unbounded_array< FieldEntity *, std::allocator< FieldEntity * > >
using	VectorFieldEntities = ublas::vector< FieldEntity *, FieldEntAllocator >
using	BaseDerivatives = EntitiesFieldData::EntData::BaseDerivatives
using	ScalarFun = boost::function< double(const double, const double, const double)>
	Scalar function type. More...
using	TimeFun = boost::function< double(double)>
	Lambda function used to scale with time. More...
using	FEFun = boost::function< double(const FEMethod *fe_ptr)>
	Lambda function used to scale with time. More...
using	ConstantFun = boost::function< double()>
	Constant function type. More...
template<int DIM>
using	VectorFun = boost::function< FTensor::Tensor1< double, DIM >(const double, const double, const double)>
	Vector function type. More...
using	OpCalculateHOJacVolume = OpCalculateHOJacForVolume
using	OpCalculateHOJacForFace = OpCalculateHOJacForFaceImpl< 2 >
using	OpCalculateHOJacForFaceEmbeddedIn3DSpace = OpCalculateHOJacForFaceImpl< 3 >
typedef boost::function< VectorDouble(const double, const double, const double)>	VectorFunc
using	SchurFieldPair = std::pair< std::string, std::string >
using	SchurFEOpsFEandFields = std::vector< std::pair< std::string, std::vector< SchurFieldPair > > >
using	SchurShellMatData = std::pair< SmartPetscObj< Mat >, boost::shared_ptr< BlockStructure > >
using	NestSchurData = std::tuple< std::array< SmartPetscObj< Mat >, 4 >, std::array< boost::shared_ptr< BlockStructure >, 4 >, boost::shared_ptr< BlockStructure >, std::pair< SmartPetscObj< IS >, SmartPetscObj< IS > > >
template<CubitBC BC>
using	BcTemperature = BcScalarMeshsetType< BC >
using	Core = CoreTmp< 0 >
using	Sev = MoFEM::LogManager::SeverityLevel
using	CreateRowComressedADJMatrix = CreateRowCompressedADJMatrix
typedef multi_index_container< boost::shared_ptr< RefElement >, indexed_by< ordered_unique< tag< Ent_mi_tag >, const_mem_fun< RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getEnt > >, ordered_non_unique< tag< Ent_Ent_mi_tag >, const_mem_fun< RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getParentEnt > >, ordered_non_unique< tag< Composite_ParentEnt_And_BitsOfRefinedEdges_mi_tag >, composite_key< RefElement, const_mem_fun< RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getParentEnt >, const_mem_fun< RefElement, int, &RefElement::getBitRefEdgesUlong > > > > >	RefElement_multiIndex_parents_view
using	Interface = DeprecatedCoreInterface
typedef CubitMeshSet_multiIndex::index< CubitMeshsetType_mi_tag >::type	CubitMeshsetByType
typedef CubitMeshSet_multiIndex::index< CubitMeshsetMaskedType_mi_tag >::type	CubitMeshsetByMask
typedef CubitMeshSet_multiIndex::index< CubitMeshsets_name >::type	CubitMeshsetByName
typedef CubitMeshSet_multiIndex::index< CubitMeshsetType_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< CubitMeshsetType_mi_tag >, const_mem_fun< CubitMeshSets, unsigned long int, &CubitMeshSets::getBcTypeULong > >, ordered_non_unique< tag< CubitMeshsetMaskedType_mi_tag >, const_mem_fun< CubitMeshSets, unsigned long int, &CubitMeshSets::getMaskedBcTypeULong > >, 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::getMaskedBcTypeULong > > > > >	CubitMeshSet_multiIndex
	Stores data about meshsets (see CubitMeshSets) storing data about boundary conditions, interfaces, sidesets, nodests, blocksets. More...
using	DofEntityByUId = DofEntity_multiIndex::index< Unique_mi_tag >::type
using	DofEntityByEnt = DofEntity_multiIndex::index< Ent_mi_tag >::type
	Dof multi-index by entity. More...
using	DofEntity_multiIndex_uid_view = multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< const_mem_fun< DofEntity, UId, &DofEntity::getLocalUniqueId > > > >
	multi-index view on DofEntity by uid More...
using	DofEntity_multiIndex_global_uid_view = multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< const_mem_fun< DofEntity, UId, &DofEntity::getGlobalUniqueId > > > >
	multi-index view on DofEntity by uid More...
typedef std::vector< boost::weak_ptr< DofEntity > >	DofEntity_vector_view
	vector view on DofEntity by uid More...
typedef multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< const_mem_fun< DofEntity, UId, &DofEntity::getLocalUniqueId > >, ordered_non_unique< const_mem_fun< DofEntity, char, &DofEntity::getActive > > > >	DofEntity_multiIndex_active_view
	multi-index view on DofEntity activity More...
using	FEDofEntityByUId = FEDofEntity_multiIndex::index< Unique_mi_tag >::type
	Dof entity multi-index by UId and entity. More...
using	FENumeredDofEntityByUId = FENumeredDofEntity_multiIndex::index< Unique_mi_tag >::type
	Dof entity multi-index by UId. More...
using	FENumeredDofEntityByEnt = FENumeredDofEntity_multiIndex::index< Ent_mi_tag >::type
	Numbered DoF multi-index by entity. More...
using	NumeredDofEntityByUId = NumeredDofEntity_multiIndex::index< Unique_mi_tag >::type
	Numbered DoF multi-index by UId. More...
using	NumeredDofEntityByLocalIdx = NumeredDofEntity_multiIndex::index< PetscLocalIdx_mi_tag >::type
	Numbered DoF multi-index by local index. More...
using	NumeredDofEntityByEnt = NumeredDofEntity_multiIndex::index< Ent_mi_tag >::type
	Numbered DoF multi-index by entity. More...
using	NumeredDofEntity_multiIndex_uid_view_ordered = multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_unique< const_mem_fun< NumeredDofEntity::interface_type_DofEntity, UId, &NumeredDofEntity::getLocalUniqueId > > > >
using	NumeredDofEntity_multiIndex_idx_view_hashed = multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< hashed_unique< const_mem_fun< NumeredDofEntity, DofIdx, &NumeredDofEntity::getDofIdx > >> >
using	NumeredDofEntity_multiIndex_petsc_local_dof_view_ordered_non_unique = multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_non_unique< const_mem_fun< NumeredDofEntity, DofIdx, &NumeredDofEntity::getPetscLocalDofIdx > >> >
using	NumeredDofEntity_multiIndex_coeff_idx_ordered_non_unique = multi_index_container< boost::shared_ptr< NumeredDofEntity >, indexed_by< ordered_non_unique< const_mem_fun< NumeredDofEntity::interface_type_DofEntity, FieldCoefficientsNumber, &NumeredDofEntity::getDofCoeffIdx > >> >
using	ElementAdjacencyFunct = boost::function< MoFEMErrorCode(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)>
	user adjacency function More...
using	CacheTuple = std::tuple< std::vector< EntityCacheDofs >, std::vector< EntityCacheNumeredDofs >, std::vector< EntityCacheNumeredDofs > >
using	CacheTupleWeakPtr = boost::weak_ptr< CacheTuple >
using	CacheTupleSharedPtr = boost::shared_ptr< CacheTuple >
using	FieldEntityByUId = FieldEntity_multiIndex::index< Unique_mi_tag >::type
	Entity index by field name. More...
using	FieldEntity_multiIndex_global_uid_view = multi_index_container< boost::shared_ptr< FieldEntity >, indexed_by< ordered_unique< tag< Unique_mi_tag >, const_mem_fun< FieldEntity, UId, &FieldEntity::getGlobalUniqueId > > > >
	multi-index view on DofEntity by uid More...
using	FieldEntity_multiIndex_ent_view = multi_index_container< boost::shared_ptr< FieldEntity >, indexed_by< sequenced<>, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< FieldEntity::interface_type_RefEntity, EntityHandle, &FieldEntity::getEnt > > > >
using	FieldEntity_multiIndex_spaceType_view = multi_index_container< boost::shared_ptr< FieldEntity >, indexed_by< sequenced<>, ordered_non_unique< tag< Composite_EntType_and_Space_mi_tag >, composite_key< FieldEntity, const_mem_fun< FieldEntity::interface_type_RefEntity, EntityType, &FieldEntity::getEntType >, const_mem_fun< FieldEntity::interface_type_Field, FieldSpace, &FieldEntity::getSpace > > > > >
typedef std::vector< boost::weak_ptr< FieldEntity > >	FieldEntity_vector_view
using	FieldEntity_multiIndex = multi_index_container< boost::shared_ptr< FieldEntity >, indexed_by< ordered_unique< tag< Unique_mi_tag >, member< FieldEntity, UId, &FieldEntity::localUId > >, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< FieldEntity::interface_type_RefEntity, EntityHandle, &FieldEntity::getEnt > > > >
typedef boost::function< int(const int order)>	FieldOrderFunct
	user adjacency function More...
typedef FieldOrderFunct	FieldOrderTable[MBMAXTYPE]
	user adjacency function table 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
using	BlockFieldPair = Problem::BlockFieldPair
using	EmptyFieldBlocks = Problem::EmptyFieldBlocks
typedef multi_index_container< boost::shared_ptr< RefElement >, indexed_by< ordered_unique< tag< Ent_mi_tag >, const_mem_fun< RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getEnt > > > >	RefElement_multiIndex
using	RefEntity = RefEntityTmp< 0 >
using	RefEntity_multiIndex = multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< ordered_unique< tag< Ent_mi_tag >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getEnt > >, ordered_non_unique< tag< Ent_Ent_mi_tag >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getParentEnt > >, ordered_non_unique< tag< Composite_EntType_and_ParentEntType_mi_tag >, composite_key< RefEntity, const_mem_fun< RefEntity, 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, EntityType, &RefEntity::getEntType >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getParentEnt > > > > >
using	RefEntity_multiIndex_view_by_hashed_parent_entity = multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< hashed_non_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::getEnt >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getParentEnt > >> > >
	multi-index view of RefEntity by parent entity More...
using	RefEntity_multiIndex_view_by_ordered_parent_entity = multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< ordered_non_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::getEnt >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getParentEnt > >> > >
using	RefEntity_multiIndex_view_sequence_ordered_view = multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< sequenced<>, ordered_unique< tag< Ent_mi_tag >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getEnt > >> >
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...
typedef std::deque< PairNameFEMethodPtr >	FEMethodsSequence
typedef std::deque< BasicMethodPtr >	BasicMethodsSequence
using	PostProcGenerateRefMeshPtr = boost::shared_ptr< PostProcGenerateRefMeshBase >
using	PostProcBrokenMeshInMoabBaseBegin = PostProcBrokenMeshInMoabBaseBeginImpl< PostProcBrokenMeshInMoabBase< ForcesAndSourcesCore > >
	Enable to run stack of post-processing elements. Use this to begin stack. More...
template<typename E >
using	PostProcBrokenMeshInMoabBaseCont = PostProcBrokenMeshInMoabBaseContImpl< PostProcBrokenMeshInMoabBase< E > >
	Enable to run stack of post-processing elements. More...
using	PostProcBrokenMeshInMoabBaseEnd = PostProcBrokenMeshInMoabBaseEndImpl< PostProcBrokenMeshInMoabBase< ForcesAndSourcesCore > >
	Enable to run stack of post-processing elements. Use this to end stack. More...

Enumerations
enum	MPC {   MPC::TIE, MPC::RIGID_BODY, MPC::COUPLING, MPC::EMBEDDED_REGION,   MPC::EQUATION, MPC::LAST }
enum	AssemblyType {   PETSC, SCHUR, BLOCK_MAT, BLOCK_SCHUR,   BLOCK_PRECONDITIONER_SCHUR, USER_ASSEMBLE, LAST_ASSEMBLE }
	[Storage and set boundary conditions] More...
enum	IntegrationType { GAUSS, USER_INTEGRATION, LAST_INTEGRATION }
	Form integrator integration types. More...

Functions
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)
template<typename T >
PetscObject	getPetscObject (T obj)
auto	createDM (MPI_Comm comm, const std::string dm_type_name)
	Creates smart DM object. More...
DEPRECATED auto	createSmartDM (MPI_Comm comm, const std::string dm_type_name)
MPI_Comm	getCommFromPetscObject (PetscObject obj)
	Get the Comm From Petsc Object object. More...
auto	createGhostVector (MPI_Comm comm, PetscInt n, PetscInt N, PetscInt nghost, const PetscInt ghosts[])
	Create smart ghost vector. More...
DEPRECATED auto	createSmartGhostVector (MPI_Comm comm, PetscInt n, PetscInt N, PetscInt nghost, const PetscInt ghosts[])
auto	createVectorMPI (MPI_Comm comm, PetscInt n, PetscInt N)
	Create MPI Vector. More...
DEPRECATED auto	createSmartVectorMPI (MPI_Comm comm, PetscInt n, PetscInt N)
SmartPetscObj< Vec >	vectorDuplicate (Vec vec)
	Create duplicate vector of smart vector. More...
DEPRECATED SmartPetscObj< Vec >	smartVectorDuplicate (Vec vec)
SmartPetscObj< Mat >	matDuplicate (Mat mat, MatDuplicateOption op)
DEPRECATED SmartPetscObj< Mat >	smartMatDuplicate (Mat mat, MatDuplicateOption op)
auto	createTS (MPI_Comm comm)
auto	createSNES (MPI_Comm comm)
auto	createKSP (MPI_Comm comm)
auto	createPC (MPI_Comm comm)
auto	createISGeneral (MPI_Comm comm, PetscInt n, const PetscInt idx[], PetscCopyMode mode)
	Creates a data structure for an index set containing a list of integers. More...
auto	isAllGather (IS is)
	IS All gather. More...
auto	createAOMappingIS (IS isapp, IS ispetsc)
	Creates an application mapping using two index sets. More...
auto	createAOMapping (MPI_Comm comm, PetscInt napp, const PetscInt myapp[], const PetscInt mypetsc[])
	Creates an application mapping using two integer arrays. More...
auto	createVecScatter (Vec x, IS ix, Vec y, IS iy)
	Create a Vec Scatter object. More...
auto	isDifference (IS is1, IS is2)
	Get ISDifference. More...
auto	createISLocalToGlobalMapping (IS is)
auto	matCreateVecs (Mat mat)
auto	isDuplicate (IS is)
template<typename T1 >
auto	getVectorAdaptor (T1 ptr, const size_t n)
	Get Vector adaptor. More...
template<typename T1 >
auto	getMatrixAdaptor (T1 ptr, const size_t n, const size_t m)
	Get Matrix adaptor. More...
template<class X >
std::string	toString (X x)
template<int S = 1, class T , class A >
static auto	getFTensor0FromVec (ublas::vector< T, A > &data)
	Get tensor rank 0 (scalar) form data vector. More...
template<int Tensor_Dim, int S = 1, class T , class L , class A >
FTensor::Tensor1< FTensor::PackPtr< T *, S >, Tensor_Dim >	getFTensor1FromMat (ublas::matrix< T, L, A > &data)
	Get tensor rank 1 (vector) form data matrix. More...
template<int Tensor_Dim, int S = 1>
auto	getFTensor1FromMat (MatrixDouble &data)
	Get tensor rank 1 (vector) form data matrix (specialization) More...
template<int Tensor_Dim1, int Tensor_Dim2>
FTensor::Tensor2< FTensor::PackPtr< double *, 1 >, Tensor_Dim1, Tensor_Dim2 >	getFTensor2FromMat (MatrixDouble &data)
	Get tensor rank 2 (matrix) form data matrix. More...
template<int Tensor_Dim1, int Tensor_Dim2>
FTensor::Tensor2< FTensor::PackPtr< double *, 1 >, Tensor_Dim1, Tensor_Dim2 >	getFTensor2FromVec (VectorDouble &data)
template<>
FTensor::Tensor2< FTensor::PackPtr< double *, 1 >, 1, 1 >	getFTensor2FromVec (VectorDouble &data)
template<int Tensor_Dim, int S, class T , class L , class A >
static auto	getFTensor2SymmetricFromMat (ublas::matrix< T, L, A > &data)
	Get symmetric tensor rank 2 (matrix) form data matrix. More...
template<int Tensor_Dim, int S = 1>
static auto	getFTensor2SymmetricFromMat (MatrixDouble &data)
template<int Tensor_Dim01, int Tensor_Dim23, int S = 1, class T , class L , class A >
static FTensor::Ddg< FTensor::PackPtr< T *, 1 >, Tensor_Dim01, Tensor_Dim23 >	getFTensor4DdgFromMat (ublas::matrix< T, L, A > &data)
	Get symmetric tensor rank 4 on first two and last indices from form data matrix. More...
template<int Tensor_Dim01, int Tensor_Dim23, int S = 1>
static auto	getFTensor4DdgFromMat (MatrixDouble &data)
template<int Tensor_Dim01, int Tensor_Dim23, int S = 1, class T = double>
static auto	getFTensor4DdgFromPtr (T *ptr)
template<int Tensor_Dim01, int Tensor_Dim2, int S = 1, class T , class L , class A >
static FTensor::Dg< FTensor::PackPtr< T *, 1 >, Tensor_Dim01, Tensor_Dim2 >	getFTensor3DgFromMat (ublas::matrix< T, L, A > &data)
	Get symmetric tensor rank 3 on the first two indices from form data matrix. More...
template<int Tensor_Dim01, int Tensor_Dim2, int S = 1>
static auto	getFTensor3DgFromMat (MatrixDouble &data)
template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3, int S = 1, class T , class L , class A >
static FTensor::Tensor4< FTensor::PackPtr< T *, 1 >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 >	getFTensor4FromMat (ublas::matrix< T, L, A > &data)
	Get tensor rank 4 (non symmetric) form data matrix. More...
template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3, int S = 1>
static auto	getFTensor4FromMat (MatrixDouble &data)
template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int S = 1, class T , class L , class A >
static FTensor::Tensor3< FTensor::PackPtr< T *, 1 >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >	getFTensor3FromMat (ublas::matrix< T, L, A > &data)
	Get tensor rank 3 (non symmetries) form data matrix. More...
template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int S = 1>
static auto	getFTensor3FromMat (MatrixDouble &data)
template<int DIM, int S = DIM>
FTensor::Tensor1< FTensor::PackPtr< double *, S >, DIM >	getFTensor1FromPtr (double *ptr)
	Make Tensor1 from pointer. More...
template<int DIM, int S = DIM>
FTensor::Tensor1< FTensor::PackPtr< adouble *, S >, DIM >	getFTensor1FromPtr (adouble *ptr)
template<int DIM, int S = DIM>
FTensor::Tensor1< FTensor::PackPtr< std::complex< double > *, S >, DIM >	getFTensor1FromPtr (std::complex< double > *ptr)
template<int DIM1, int DIM2, int S = DIM1 * DIM2>
auto	getFTensor2FromPtr (double *ptr)
	Make Tensor2 from pointer. More...
template<int DIM1, int DIM2, int S = DIM1 * DIM2>
auto	getFTensor2FromPtr (std::complex< double > *ptr)
	Make Tensor2 from pointer. More...
template<int DIM1, int DIM2>
FTensor::Tensor2< FTensor::PackPtr< double *, DIM1 *DIM2 >, DIM1, DIM2 >	getFTensor2HVecFromPtr (double *ptr)
	Make Tensor2 for HVec base from pointer. More...
template<>
FTensor::Tensor2< FTensor::PackPtr< double *, 6 >, 3, 2 >	getFTensor2HVecFromPtr< 3, 2 > (double *ptr)
template<>
FTensor::Tensor2< FTensor::PackPtr< double *, 9 >, 3, 3 >	getFTensor2HVecFromPtr< 3, 3 > (double *ptr)
template<int DIM1, int DIM2, int DIM3>
FTensor::Tensor3< FTensor::PackPtr< double *, DIM1 *DIM2 *DIM3 >, DIM1, DIM2, DIM3 >	getFTensor3FromPtr (double *ptr)
template<>
FTensor::Tensor3< FTensor::PackPtr< double *, 12 >, 3, 2, 2 >	getFTensor3FromPtr< 3, 2, 2 > (double *ptr)
template<>
FTensor::Tensor3< FTensor::PackPtr< double *, 27 >, 3, 3, 3 >	getFTensor3FromPtr< 3, 3, 3 > (double *ptr)
template<int DIM>
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *,(DIM *(DIM+1))/2 >, DIM >	getFTensor2SymmetricFromPtr (double *ptr)
	Make symmetric Tensor2 from pointer. More...
template<>
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *, 6 >, 3 >	getFTensor2SymmetricFromPtr< 3 > (double *ptr)
template<>
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *, 3 >, 2 >	getFTensor2SymmetricFromPtr< 2 > (double *ptr)
template<int DIM>
FTensor::Tensor2_symmetric< FTensor::PackPtr< adouble *,(DIM *(DIM+1))/2 >, DIM >	getFTensor2SymmetricFromPtr (adouble *ptr)
	Make symmetric Tensor2 from pointer. More...
template<>
FTensor::Tensor2_symmetric< FTensor::PackPtr< adouble *, 6 >, 3 >	getFTensor2SymmetricFromPtr< 3 > (adouble *ptr)
template<>
FTensor::Tensor2_symmetric< FTensor::PackPtr< adouble *, 3 >, 2 >	getFTensor2SymmetricFromPtr< 2 > (adouble *ptr)
template<int DIM>
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *, DIM *DIM >, DIM >	getFTensor2SymmetricLowerFromPtr (double *ptr)
	Make symmetric Tensor2 from pointer, taking lower triangle of matrix. More...
template<>
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *, 9 >, 3 >	getFTensor2SymmetricLowerFromPtr< 3 > (double *ptr)
template<>
FTensor::Tensor2_symmetric< FTensor::PackPtr< double *, 4 >, 2 >	getFTensor2SymmetricLowerFromPtr< 2 > (double *ptr)
template<int DIM, int S>
auto	getFTensor1FromArray (VectorDouble &data)
	Get FTensor1 from array. More...
template<int DIM, int S = 0>
auto	getFTensor1FromArray (VectorDouble3 &data)
	Get FTensor1 from array. More...
template<>
auto	getFTensor1FromArray< 3, 0 > (VectorDouble3 &data)
template<int DIM, int S>
FTensor::Tensor1< FTensor::PackPtr< double *, S >, DIM >	getFTensor1FromMat (MatrixDouble &data, const size_t rr)
template<>
FTensor::Tensor1< FTensor::PackPtr< double *, 1 >, 2 >	getFTensor1FromMat (MatrixDouble &data, const size_t rr)
template<int DIM, int S>
FTensor::Tensor1< FTensor::PackPtr< double *, S >, DIM >	getFTensor1FromArrayDiag (MatrixDouble &data, const size_t rr)
	Get FTensor1 from array. More...
template<>
FTensor::Tensor1< FTensor::PackPtr< double *, 2 >, 2 >	getFTensor1FromArrayDiag (MatrixDouble &data, const size_t rr)
template<int DIM1, int DIM2, int S>
FTensor::Tensor2< FTensor::PackPtr< double *, S >, DIM1, DIM2 >	getFTensor2FromArray (MatrixDouble &data, const size_t rr, const size_t cc=0)
template<int DIM1, int DIM2>
FTensor::Tensor2< double *, DIM1, DIM2 >	getFTensor2FromArray (MatrixDouble &data, const size_t rr, const size_t cc, const int ss)
template<int S, typename T , typename L , typename A >
auto	getFTensor2FromArray2by2 (ublas::matrix< T, L, A > &data, const FTensor::Number< S > &, const size_t rr, const size_t cc=0)
template<int S, typename T , typename L , typename A >
auto	getFTensor2FromArray3by3 (ublas::matrix< T, L, A > &data, const FTensor::Number< S > &, const size_t rr, const size_t cc=0)
template<int DIM1, int DIM2, int S>
auto	getFTensor2FromArray (MatrixADouble &data, const size_t rr)
MoFEMErrorCode	computeMatrixInverse (MatrixDouble &mat)
	compute matrix inverse with lapack dgetri More...
MoFEMErrorCode	solveLinearSystem (MatrixDouble &mat, VectorDouble &f)
	solve linear system with lapack dgesv More...
MoFEMErrorCode	solveLinearSystem (const MatrixDouble &mat, VectorDouble &f)
	Solve linear system of equations using Lapack. More...
MoFEMErrorCode	computeEigenValuesSymmetric (const MatrixDouble &mat, VectorDouble &eig, MatrixDouble &eigen_vec)
	compute eigenvalues of a symmetric matrix using lapack dsyev More...
template<int DIM, typename T1 , typename T2 >
MoFEMErrorCode	computeEigenValuesSymmetric (FTensor::Tensor2< T1, DIM, DIM > &eigen_vec, FTensor::Tensor1< T2, DIM > &eig)
	compute eigenvalues of a symmetric matrix using lapack dsyev More...
template<int DIM, typename T1 , typename T2 , typename T3 >
MoFEMErrorCode	computeEigenValuesSymmetric (const FTensor::Tensor2_symmetric< T1, DIM > &mat, FTensor::Tensor1< T2, DIM > &eig, FTensor::Tensor2< T3, DIM, DIM > &eigen_vec)
	compute eigenvalues of a symmetric tensor using lapack dsyev More...
template<typename T >
static auto	determinantTensor3by3 (T &t)
	Calculate the determinant of a 3x3 matrix or a tensor of rank 2. More...
template<typename T >
static auto	determinantTensor2by2 (T &t)
	Calculate the determinant of a 2x2 matrix or a tensor of rank 2. More...
template<typename T , int DIM>
static auto	determinantTensor (FTensor::Tensor2< T, DIM, DIM > &t)
	Calculate the determinant of a tensor of rank DIM. More...
template<typename T , int DIM>
static auto	determinantTensor (FTensor::Tensor2_symmetric< T, DIM > &t)
	Calculate the determinant of a tensor of rank DIM. More...
template<int Tensor_Dim, class T , class L , class A >
MoFEMErrorCode	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<>
MoFEMErrorCode	invertTensor3by3< 3, double, ublas::row_major, DoubleAllocator > (MatrixDouble &jac_data, VectorDouble &det_data, MatrixDouble &inv_jac_data)
template<class T1 , class T2 >
MoFEMErrorCode	determinantTensor3by3 (T1 &t, T2 &det)
	Calculate determinant 3 by 3. More...
template<class T1 , class T2 >
MoFEMErrorCode	determinantTensor2by2 (T1 &t, T2 &det)
	Calculate determinant 2 by 2. More...
template<class T1 , class T2 , class T3 >
MoFEMErrorCode	invertTensor3by3 (T1 &t, T2 &det, T3 &inv_t)
	Calculate matrix inverse 3 by 3. More...
template<class T1 , class T2 , class T3 >
MoFEMErrorCode	invertTensor2by2 (T1 &t, T2 &det, T3 &inv_t)
	Calculate matrix inverse 2 by 2. More...
template<typename T1 , typename T2 , typename T3 , int DIM>
static MoFEMErrorCode	invertTensor (FTensor::Tensor2< T1, DIM, DIM > &t, T2 &det, FTensor::Tensor2< T3, DIM, DIM > &inv_t)
template<typename T1 , typename T2 , typename T3 , int DIM>
static MoFEMErrorCode	invertTensor (FTensor::Tensor2_symmetric< T1, DIM > &t, T2 &det, FTensor::Tensor2_symmetric< T3, DIM > &inv_t)
template<typename Extractor , typename Iterator >
moab::Range::iterator	insertOrdered (Range &r, Extractor, Iterator begin_iter, Iterator end_iter)
	Insert ordered mofem multi-index into range. More...
template<typename MI , typename MO = Modify_change_nothing>
MoFEMErrorCode	reconstructMultiIndex (const MI &mi, MO &&mo=Modify_change_nothing())
	Template used to reconstruct multi-index. More...
auto	get_temp_meshset_ptr (moab::Interface &moab)
	Create smart pointer to temporary meshset. More...
auto	id_from_handle (const EntityHandle h)
auto	type_from_handle (const EntityHandle h)
	get type from entity handle More...
auto	ent_form_type_and_id (const EntityType type, const EntityID id)
	get entity handle from type and id More...
auto	dimension_from_handle (const EntityHandle h)
	get entity dimension form handle More...
auto	type_name_from_handle (const EntityHandle h)
	get entity type name from handle More...
auto	field_bit_from_bit_number (const int bit_number)
	get field bit id from bit number More...
template<typename I >
auto	rangeInserter (const I f, const I s, boost::function< bool(I it)> tester, boost::function< MoFEMErrorCode(I f, I s)> inserter)
	Insert ranges. More...
template<typename Dest = void, typename... Arg>
constexpr auto	make_array (Arg &&...arg)
	Create Array. More...
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)
MoFEMErrorCode	tri_type_1 (const EntityHandle *conn, const int split_edge, const EntityHandle edge_new_node, EntityHandle *new_tris_conn)
MoFEMErrorCode	tri_type_2 (const EntityHandle *conn, const int *split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_tris_conn)
MoFEMErrorCode	tri_type_3 (const EntityHandle *conn, const EntityHandle *edge_new_nodes, EntityHandle *new_tris_conn)
MoFEMErrorCode	prism_type_1 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_prism_conn)
MoFEMErrorCode	prism_type_2 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_prism_conn)
MoFEMErrorCode	prism_type_3 (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_prism_conn)
MoFEMErrorCode	quad_split_all_edges (const EntityHandle *conn, const EntityHandle *edge_new_nodes, EntityHandle *new_quad_conn)
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Ainsworth_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...
MoFEMErrorCode	Hcurl_Demkowicz_EdgeBaseFunctions_MBTET (int *sense, int *p, double *n, double *diff_n, double *phi[], double *diff_phi[], int nb_integration_pts)
	Edge based H-curl base functions on tetrahedral. More...
MoFEMErrorCode	Hcurl_Demkowicz_EdgeBaseFunctions_MBTRI (int *sense, int *p, double *n, double *diff_n, double *phi[], double *diff_phi[], int nb_integration_pts)
	Edge based H-curl base functions on teriangle. More...
MoFEMErrorCode	Hcurl_Demkowicz_EdgeBaseFunctions_MBEDGE (int sense, int p, double *n, double *diff_n, double *phi, double *diff_phi, int nb_integration_pts)
	Edge based H-curl base functions on edge. More...
MoFEMErrorCode	Hcurl_Demkowicz_FaceBaseFunctions_MBTET (int *faces_nodes, int *p, double *n, double *diff_n, double *phi[], double *diff_phi[], int nb_integration_pts)
	Face base interior function. More...
MoFEMErrorCode	Hcurl_Demkowicz_FaceBaseFunctions_MBTRI (int *faces_nodes, int p, double *n, double *diff_n, double *phi, double *diff_phi, int nb_integration_pts)
	Face base interior function. More...
MoFEMErrorCode	Hcurl_Demkowicz_VolumeBaseFunctions_MBTET (int p, double *n, double *diff_n, double *phi, double *diff_phi, int nb_integration_pts)
	Volume base interior function. More...
MoFEMErrorCode	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...
MoFEMErrorCode	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...
MoFEMErrorCode	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...
MoFEMErrorCode	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...
MoFEMErrorCode	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...
MoFEMErrorCode	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))
MoFEMErrorCode	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...
MoFEMErrorCode	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)
MoFEMErrorCode	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)
MoFEMErrorCode	quad_split_all_edges (const EntityHandle *conn, const BitRefEdges split_edges, const EntityHandle *edge_new_nodes, EntityHandle *new_quad_conn)
template<class TYPE >
static MoFEMErrorCode	get_value (MatrixDouble &pts_x, MatrixDouble &pts_t, TYPE *ctx)
MoFEMErrorCode	setMPCParentAdjacency ()
MoFEMErrorCode	ProjectionMatrixMultOpQ (Mat Q, Vec x, Vec f)
	Multiplication operator for Q = I-CTC(CCT)^-1C. More...
MoFEMErrorCode	ConstrainMatrixMultOpP (Mat P, Vec x, Vec f)
	Multiplication operator for P = CT(CCT)^-1C. More...
MoFEMErrorCode	ConstrainMatrixMultOpR (Mat R, Vec x, Vec f)
	Multiplication operator for R = CT(CCT)^-1. More...
MoFEMErrorCode	ConstrainMatrixMultOpRT (Mat RT, Vec x, Vec f)
	Multiplication operator for RT = (CCT)^-TC. More...
MoFEMErrorCode	ConstrainMatrixMultOpCTC_QTKQ (Mat CTC_QTKQ, Vec x, Vec f)
	Multiplication operator for RT = (CCT)^-TC. More...
MoFEMErrorCode	ConstrainMatrixDestroyOpPorQ (Mat Q)
	Destroy shell matrix Q. More...
MoFEMErrorCode	ConstrainMatrixDestroyOpQTKQ (Mat QTKQ)
	Destroy shell matrix. More...
template<typename T = EntityStorage>
MoFEMErrorCode	VecSetValues (Vec V, const EntitiesFieldData::EntData &data, const double *ptr, InsertMode iora)
	Assemble PETSc vector. More...
template<>
MoFEMErrorCode	VecSetValues< EntityStorage > (Vec V, const EntitiesFieldData::EntData &data, const double *ptr, InsertMode iora)
template<typename T = EntityStorage>
MoFEMErrorCode	VecSetValues (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &vec, InsertMode iora)
	Assemble PETSc vector. More...
template<typename T = EntityStorage>
MoFEMErrorCode	MatSetValues (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
	Assemble PETSc matrix. More...
template<typename T = EntityStorage>
MoFEMErrorCode	MatSetValues (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
	Assemble PETSc matrix. More...
template<>
MoFEMErrorCode	MatSetValues< EntityStorage > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< EssentialBcStorage > (Vec V, const EntitiesFieldData::EntData &data, const double *ptr, InsertMode iora)
	Set values to vector in operator. More...
template<>
MoFEMErrorCode	MatSetValues< EssentialBcStorage > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
	Set values to matrix in operator. More...
template<>
MoFEMErrorCode	MatSetValues< AssemblyTypeSelector< PETSC > > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< AssemblyTypeSelector< PETSC > > (Vec V, const EntitiesFieldData::EntData &data, const double *ptr, InsertMode iora)
double	scalar_fun_one (const double, const double, const double)
template<typename E >
MoFEMErrorCode	addHOOpsVol (const std::string field, E &e, bool h1, bool hcurl, bool hdiv, bool l2)
template<typename E >
MoFEMErrorCode	addHOOpsFace3D (const std::string field, E &e, bool hcurl, bool hdiv)
static void	constructor_data (EntitiesFieldData *data, const EntityType type)
static void	constructor_derived_data (DerivedEntitiesFieldData *derived_data, const boost::shared_ptr< EntitiesFieldData > &data_ptr)
std::ostream &	operator<< (std::ostream &os, const EntitiesFieldData::EntData &e)
std::ostream &	operator<< (std::ostream &os, const EntitiesFieldData &e)
static auto	cmp_uid_lo (const boost::weak_ptr< FieldEntity > &a, const UId &b)
static auto	cmp_uid_hi (const UId &b, const boost::weak_ptr< FieldEntity > &a)
template<typename ENTMULTIINDEX >
static int	getMaxOrder (const ENTMULTIINDEX &multi_index)
boost::shared_ptr< BlockStructure >	createBlockMatStructure (DM dm, SchurFEOpsFEandFields schur_fe_op_vec)
	Create a Mat Diag Blocks object. More...
static MoFEMErrorCode	mult_schur_block_shell (Mat mat, Vec x, Vec y, InsertMode iora, boost::function< int(DiagBlockIndex::BlockIndex::nth_index< 0 >::type::iterator)> shift_extractor, boost::shared_ptr< std::vector< double >> data_blocks_ptr, bool multiply_by_preconditioner)
static MoFEMErrorCode	solve_schur_block_shell (Mat mat, Vec y, Vec x, InsertMode iora)
static PetscErrorCode	mult (Mat mat, Vec x, Vec y)
static PetscErrorCode	mult_add (Mat mat, Vec x, Vec y)
static PetscErrorCode	solve (Mat mat, Vec x, Vec y)
static PetscErrorCode	solve_add (Mat mat, Vec x, Vec y)
static PetscErrorCode	zero_rows_columns (Mat A, PetscInt N, const PetscInt rows[], PetscScalar diag, Vec x, Vec b)
static PetscErrorCode	mat_zero (Mat m)
static MoFEMErrorCode	setSchurBlockMatOps (Mat mat_raw)
SchurShellMatData	createBlockMat (DM dm, boost::shared_ptr< BlockStructure > data)
	Create a Schur Mat object. More...
MoFEMErrorCode	shell_block_mat_asmb_wrap_impl (BlockStructure *ctx, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora, boost::function< int(const DiagBlockIndex::Indexes *)> shift_extractor, boost::shared_ptr< std::vector< double >> data_blocks_ptr)
MoFEMErrorCode	shell_block_mat_asmb_wrap (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
MoFEMErrorCode	shell_block_preconditioner_mat_asmb_wrap (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
boost::shared_ptr< NestSchurData >	createSchurNestedMatrixStruture (std::pair< SmartPetscObj< DM >, SmartPetscObj< DM >> dms, boost::shared_ptr< BlockStructure > block_mat_data, std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range >> field_ents, bool add_preconditioner_block=false)
	Get the Schur Nest Mat Array object. More...
std::pair< SmartPetscObj< Mat >, boost::shared_ptr< NestSchurData > >	createSchurNestedMatrix (boost::shared_ptr< NestSchurData > schur_net_data_ptr)
	Create a Mat Diag Blocks object. More...
OpSchurAssembleBase *	createOpSchurAssembleBegin ()
OpSchurAssembleBase *	createOpSchurAssembleEnd (std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range >> field_ents, SmartPetscObj< AO > ao=SmartPetscObj< AO >(), SmartPetscObj< Mat > schur=SmartPetscObj< Mat >(), bool sym_schur=false, bool symm_op=false)
	Construct a new Op Schur Assemble End object. More...
OpSchurAssembleBase *	createOpSchurAssembleEnd (std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range >> field_ents, std::vector< SmartPetscObj< AO >> sequence_of_aos, std::vector< SmartPetscObj< Mat >> sequence_of_mats, std::vector< bool > sym_schur, bool symm_op, boost::shared_ptr< BlockStructure > diag_blocks)
OpSchurAssembleBase *	createOpSchurAssembleEnd (std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range >> field_ents, std::vector< SmartPetscObj< AO >> sequence_of_aos, std::vector< SmartPetscObj< Mat >> sequence_of_mats, std::vector< bool > sym_schur, std::vector< double > diag_eps, bool symm_op, boost::shared_ptr< BlockStructure > diag_blocks)
MoFEMErrorCode	setSchurA00MatSolvePC (SmartPetscObj< PC > pc)
	Set PC for A00 block. More...
MoFEMErrorCode	setSchurMatSolvePC (SmartPetscObj< PC > pc)
template<>
MoFEMErrorCode	MatSetValues< SchurElemMats > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
MoFEMErrorCode	schur_mat_set_values_wrap (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< AssemblyTypeSelector< SCHUR > > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< BlockStructure > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< SchurElemMatsBlock > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< SchurElemMatsPreconditionedBlock > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
MoFEMErrorCode	schurSwitchPreconditioner (boost::shared_ptr< BlockStructure > block_mat_data)
	Switch preconditioner. More...
MoFEMErrorCode	schurSaveBlockMesh (boost::shared_ptr< BlockStructure > block_mat_data, std::string filename)
	Save block matrix as a mesh. More...
template<>
MoFEMErrorCode	DMMoFEMSetNestSchurData (DM dm, boost::shared_ptr< NestSchurData >)
template<>
MoFEMErrorCode	VecSetValues< SchurElemMats > (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &nf, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< AssemblyTypeSelector< SCHUR > > (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &nf, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< AssemblyTypeSelector< BLOCK_MAT > > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< AssemblyTypeSelector< BLOCK_MAT > > (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &nf, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< SchurElemMatsBlock > (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &nf, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< AssemblyTypeSelector< BLOCK_SCHUR > > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< AssemblyTypeSelector< BLOCK_SCHUR > > (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &nf, InsertMode iora)
template<>
MoFEMErrorCode	MatSetValues< AssemblyTypeSelector< BLOCK_PRECONDITIONER_SCHUR > > (Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const MatrixDouble &mat, InsertMode iora)
template<>
MoFEMErrorCode	VecSetValues< AssemblyTypeSelector< BLOCK_PRECONDITIONER_SCHUR > > (Vec V, const EntitiesFieldData::EntData &data, const VectorDouble &nf, InsertMode iora)
DEPRECATED boost::shared_ptr< NestSchurData >	getNestSchurData (std::pair< SmartPetscObj< DM >, SmartPetscObj< DM >> dms, boost::shared_ptr< BlockStructure > block_mat_data, std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range >> field_ents, bool add_preconditioner_block=false)
template<class T >
static auto	get_sub_iface_options_imp (T *const ptr, int) -> decltype(ptr->getSubInterfaceOptions())
template<class T >
static auto	get_sub_iface_options_imp (T *const ptr, long) -> MoFEMErrorCode
template<class T >
static auto	get_event_options_imp (T *const ptr, int) -> decltype(ptr->getEventOptions())
template<class T >
static auto	get_event_options_imp (T *const ptr, long) -> MoFEMErrorCode
template<int V, typename std::enable_if<(V >=0), int >::type * = nullptr>
void	set_ref_ent_basic_data_ptr_impl (boost::shared_ptr< BasicEntityData > &ptr)
std::ostream &	operator<< (std::ostream &strm, const LogManager::SeverityLevel &level)
static std::vector< med_geometrie_element >	moab2med_element_type (const EntityType type)
std::ostream &	operator<< (std::ostream &os, const MedInterface::FieldData &field_data)
static auto	min_non_abs (const double a, const double b)
template<typename T1 , typename T2 >
MoFEMErrorCode	getLocalCoordinatesOnReferenceThreeNodeTriImpl (const T1 *elem_coords, const T2 *global_coords, const int nb_nodes, typename FTensor::promote< T1, T2 >::V *local_coords)
std::ostream &	operator<< (std::ostream &os, const FENumeredDofEntity &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 CubitMeshSets &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 FiniteElement &e)
std::ostream &	operator<< (std::ostream &os, const EntFiniteElement &e)
std::ostream &	operator<< (std::ostream &os, const NumeredEntFiniteElement &e)
template<typename ENTSVIEW , typename DOFSVIEW , typename EXTRACTOR , typename INSERTER >
static MoFEMErrorCode	get_cache_data_dofs_view (ENTSVIEW &ents_view, DOFSVIEW &dofs_view, EXTRACTOR &&extractor, INSERTER &&inserter)
std::ostream &	operator<< (std::ostream &os, const FieldEntity &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 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 Problem &e)
std::ostream &	operator<< (std::ostream &os, const RefElement &e)
std::ostream &	operator<< (std::ostream &os, const RefElementVolume &e)
std::ostream &	operator<< (std::ostream &os, const RefElementFace &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 RefEntity &e)
std::ostream &	operator<< (std::ostream &os, const FieldSeries &e)
std::ostream &	operator<< (std::ostream &os, const FieldSeriesStep &e)
template<EntityType TYPE>
EntityHandle	get_id_for_max_type ()
template<EntityType TYPE>
EntityHandle	get_id_for_min_type ()
EntityHandle	get_id_for_max_type (const EntityType type)
EntityHandle	get_id_for_min_type (const EntityType type)
void *	get_tag_ptr (moab::Interface &moab, Tag th, EntityHandle ent, int *tag_size)
	Get the tag ptr object. More...
PetscErrorCode	DMRegister_MoFEM (const char sname[])
	Register MoFEM problem. More...
PetscErrorCode	DMMoFEMCreateMoFEM (DM dm, MoFEM::Interface *m_field_ptr, const char problem_name[], const MoFEM::BitRefLevel bit_level, const MoFEM::BitRefLevel bit_mask=MoFEM::BitRefLevel().set())
	Must be called by user to set MoFEM data structures. More...
PetscErrorCode	DMMoFEMDuplicateDMCtx (DM dm, DM dm_duplicate)
	Duplicate internal data struture. More...
PetscErrorCode	DMMoFEMSwapDMCtx (DM dm, DM dm_swap)
	Swap internal data struture. More...
PetscErrorCode	DMMoFEMCreateSubDM (DM subdm, DM dm, const char problem_name[])
	Must be called by user to set Sub DM MoFEM data structures. More...
PetscErrorCode	DMoFEMGetInterfacePtr (DM dm, MoFEM::Interface **m_field_ptr)
	Get pointer to MoFEM::Interface. More...
PetscErrorCode	DMMoFEMGetProblemPtr (DM dm, const MoFEM::Problem **problem_ptr)
	Get pointer to problem data structure. More...
PetscErrorCode	DMMoFEMSetDestroyProblem (DM dm, PetscBool destroy_problem)
PetscErrorCode	DMMoFEMGetDestroyProblem (DM dm, PetscBool *destroy_problem)
PetscErrorCode	DMMoFEMSetSquareProblem (DM dm, PetscBool square_problem)
	set squared problem More...
PetscErrorCode	DMMoFEMGetSquareProblem (DM dm, PetscBool *square_problem)
	get squared problem More...
PetscErrorCode	DMMoFEMResolveSharedFiniteElements (DM dm, std::string fe_name)
	Resolve shared entities. More...
PetscErrorCode	DMMoFEMGetProblemFiniteElementLayout (DM dm, std::string fe_name, PetscLayout *layout)
	Get finite elements layout in the problem. More...
PetscErrorCode	DMMoFEMAddElement (DM dm, std::string fe_name)
	add element to dm More...
PetscErrorCode	DMMoFEMAddElement (DM dm, std::vector< std::string > fe_name)
	add element to dm More...
PetscErrorCode	DMMoFEMUnSetElement (DM dm, std::string fe_name)
	unset element from dm More...
PetscErrorCode	DMoFEMMeshToLocalVector (DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
	set local (or ghosted) vector values on mesh for partition only More...
PetscErrorCode	DMoFEMMeshToGlobalVector (DM dm, Vec g, InsertMode mode, ScatterMode scatter_mode)
	set ghosted vector values on all existing mesh entities More...
PetscErrorCode	DMoFEMPreProcessFiniteElements (DM dm, MoFEM::FEMethod *method)
	execute finite element method for each element in dm (problem) More...
PetscErrorCode	DMoFEMPostProcessFiniteElements (DM dm, MoFEM::FEMethod *method)
	execute finite element method for each element in dm (problem) More...
PetscErrorCode	DMoFEMLoopFiniteElementsUpAndLowRank (DM dm, const char fe_name[], MoFEM::FEMethod *method, int low_rank, int up_rank, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	DMoFEMLoopFiniteElementsUpAndLowRank (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, int low_rank, int up_rank, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	DMoFEMLoopFiniteElements (DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	DMoFEMLoopFiniteElements (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
	Executes FEMethod for finite elements in DM. More...
PetscErrorCode	DMoFEMLoopDofs (DM dm, const char field_name[], MoFEM::DofMethod *method)
	execute method for dofs on field in problem More...
PetscErrorCode	DMMoFEMKSPSetComputeRHS (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set KSP right hand side evaluation function More...
PetscErrorCode	DMMoFEMKSPSetComputeRHS (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set KSP right hand side evaluation function More...
PetscErrorCode	DMMoFEMKSPSetComputeOperators (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	Set KSP operators and push mofem finite element methods. More...
PetscErrorCode	DMMoFEMKSPSetComputeOperators (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	Set KSP operators and push mofem finite element methods. More...
PetscErrorCode	DMMoFEMSNESSetFunction (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set SNES residual evaluation function More...
PetscErrorCode	DMMoFEMSNESSetFunction (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set SNES residual evaluation function More...
PetscErrorCode	DMMoFEMSNESSetJacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set SNES Jacobian evaluation function More...
PetscErrorCode	DMMoFEMSNESSetJacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set SNES Jacobian evaluation function More...
PetscErrorCode	DMMoFEMTSSetIFunction (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS implicit function evaluation function More...
PetscErrorCode	DMMoFEMTSSetIFunction (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS implicit function evaluation function More...
PetscErrorCode	DMMoFEMTSSetIJacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS Jacobian evaluation function More...
PetscErrorCode	DMMoFEMTSSetIJacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS Jacobian evaluation function More...
PetscErrorCode	DMMoFEMTSSetRHSFunction (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS the right hand side function More...
PetscErrorCode	DMMoFEMTSSetRHSFunction (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
PetscErrorCode	DMMoFEMTSSetRHSJacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS the right hand side jacobian More...
PetscErrorCode	DMMoFEMTSSetRHSJacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
PetscErrorCode	DMMoFEMTSSetI2Function (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS implicit function evaluation function More...
PetscErrorCode	DMMoFEMTSSetI2Function (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS implicit function evaluation function More...
PetscErrorCode	DMMoFEMTSSetI2Jacobian (DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	set TS Jacobian evaluation function More...
PetscErrorCode	DMMoFEMTSSetI2Jacobian (DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	set TS Jacobian evaluation function More...
PetscErrorCode	DMMoFEMTSSetMonitor (DM dm, TS ts, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
	Set Monitor To TS solver. More...
PetscErrorCode	DMMoFEMTSSetMonitor (DM dm, TS ts, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
	Set Monitor To TS solver. More...
PetscErrorCode	DMMoFEMGetKspCtx (DM dm, MoFEM::KspCtx **ksp_ctx)
	get MoFEM::KspCtx data structure More...
PetscErrorCode	DMMoFEMGetKspCtx (DM dm, const boost::shared_ptr< MoFEM::KspCtx > &ksp_ctx)
	get MoFEM::KspCtx data structure More...
PetscErrorCode	DMMoFEMSetKspCtx (DM dm, boost::shared_ptr< MoFEM::KspCtx > ksp_ctx)
	set MoFEM::KspCtx data structure More...
PetscErrorCode	DMMoFEMGetSnesCtx (DM dm, MoFEM::SnesCtx **snes_ctx)
	get MoFEM::SnesCtx data structure More...
PetscErrorCode	DMMoFEMGetSnesCtx (DM dm, const boost::shared_ptr< MoFEM::SnesCtx > &snes_ctx)
	get MoFEM::SnesCtx data structure More...
PetscErrorCode	DMMoFEMSetSnesCtx (DM dm, boost::shared_ptr< MoFEM::SnesCtx > snes_ctx)
	Set MoFEM::SnesCtx data structure. More...
PetscErrorCode	DMMoFEMGetTsCtx (DM dm, MoFEM::TsCtx **ts_ctx)
	get MoFEM::TsCtx data structure More...
PetscErrorCode	DMMoFEMGetTsCtx (DM dm, const boost::shared_ptr< MoFEM::TsCtx > &ts_ctx)
	get MoFEM::TsCtx data structure More...
PetscErrorCode	DMMoFEMSetTsCtx (DM dm, boost::shared_ptr< MoFEM::TsCtx > ts_ctx)
	Set MoFEM::TsCtx data structure. More...
PetscErrorCode	DMMoFEMSetIsPartitioned (DM dm, PetscBool is_partitioned)
PetscErrorCode	DMMoFEMGetIsPartitioned (DM dm, PetscBool *is_partitioned)
PetscErrorCode	DMSetOperators_MoFEM (DM dm)
	Set operators for MoFEM dm. More...
PetscErrorCode	DMCreate_MoFEM (DM dm)
	Create dm data structure with MoFEM data structure. More...
PetscErrorCode	DMDestroy_MoFEM (DM dm)
	Destroys dm with MoFEM data structure. More...
PetscErrorCode	DMCreateGlobalVector_MoFEM (DM dm, Vec *g)
	DMShellSetCreateGlobalVector. More...
PetscErrorCode	DMCreateGlobalVector_MoFEM (DM dm, SmartPetscObj< Vec > &g_ptr)
	DMShellSetCreateGlobalVector. More...
PetscErrorCode	DMCreateLocalVector_MoFEM (DM dm, Vec *l)
	DMShellSetCreateLocalVector. More...
PetscErrorCode	DMCreateMatrix_MoFEM (DM dm, Mat *M)
PetscErrorCode	DMCreateMatrix_MoFEM (DM dm, SmartPetscObj< Mat > &M)
PetscErrorCode	DMSetFromOptions_MoFEM (DM dm)
PetscErrorCode	DMSetUp_MoFEM (DM dm)
PetscErrorCode	DMSubDMSetUp_MoFEM (DM subdm)
PetscErrorCode	DMMoFEMAddSubFieldRow (DM dm, const char field_name[])
PetscErrorCode	DMMoFEMAddSubFieldRow (DM dm, std::string field_name)
PetscErrorCode	DMMoFEMAddSubFieldRow (DM dm, const char field_name[], boost::shared_ptr< Range > r_ptr)
	Add field to sub dm problem on rows. More...
PetscErrorCode	DMMoFEMAddSubFieldRow (DM dm, std::string field_name, boost::shared_ptr< Range > r_ptr)
	Add field to sub dm problem on rows. More...
PetscErrorCode	DMMoFEMAddSubFieldCol (DM dm, const char field_name[])
PetscErrorCode	DMMoFEMAddSubFieldCol (DM dm, std::string field_name)
PetscErrorCode	DMMoFEMAddSubFieldCol (DM dm, const char field_name[], boost::shared_ptr< Range > r_ptr)
	Add field to sub dm problem on columns. More...
PetscErrorCode	DMMoFEMAddSubFieldCol (DM dm, std::string field_name, boost::shared_ptr< Range > r_ptr)
	Add field to sub dm problem on columns. More...
PetscErrorCode	DMMoFEMGetIsSubDM (DM dm, PetscBool *is_sub_dm)
PetscErrorCode	DMMoFEMGetSubRowIS (DM dm, IS *is)
	get sub problem is More...
PetscErrorCode	DMMoFEMGetSubColIS (DM dm, IS *is)
	get sub problem is More...
PetscErrorCode	DMMoFEMAddRowCompositeProblem (DM dm, const char prb_name[])
	Add problem to composite DM on row. More...
PetscErrorCode	DMMoFEMAddColCompositeProblem (DM dm, const char prb_name[])
	Add problem to composite DM on col. More...
PetscErrorCode	DMMoFEMGetIsCompDM (DM dm, PetscBool *is_comp_dm)
	Get if this DM is composite DM. More...
PetscErrorCode	DMGlobalToLocalBegin_MoFEM (DM dm, Vec, InsertMode, Vec)
PetscErrorCode	DMGlobalToLocalEnd_MoFEM (DM dm, Vec, InsertMode, Vec)
PetscErrorCode	DMLocalToGlobalBegin_MoFEM (DM, Vec, InsertMode, Vec)
PetscErrorCode	DMLocalToGlobalEnd_MoFEM (DM, Vec, InsertMode, Vec)
PetscErrorCode	DMCreateFieldIS_MoFEM (DM dm, PetscInt *numFields, char ***fieldNames, IS **fields)
PetscErrorCode	DMMoFEMGetFieldIS (DM dm, RowColData rc, const char field_name[], IS *is)
	get field is in the problem More...
PetscErrorCode	DMMoFEMSetVerbosity (DM dm, const int verb)
	Set verbosity level. More...
MoFEMErrorCode	DMMoFEMSetBlocMatData (DM dm, boost::shared_ptr< BlockStructure >)
	Set data for block mat. More...
MoFEMErrorCode	DMMoFEMGetBlocMatData (DM dm, boost::shared_ptr< BlockStructure > &)
	Get data for block mat. More...
MoFEMErrorCode	DMMoFEMCreateBlockMat (DM dm, Mat *mat)
	Create block matrix. More...
MoFEMErrorCode	DMMoFEMCreateBlockMat (DM dm, SmartPetscObj< Mat > &mat)
	Create block matrix. More...
template<typename T >
MoFEMErrorCode	DMMoFEMSetNestSchurData (DM dm, boost::shared_ptr< T >)
	Set data for nest schur (see specialisation in Schur.hpp) More...
MoFEMErrorCode	DMMoFEMCreateNestSchurMat (DM dm, Mat *mat)
	Create nest schur matrix. More...
MoFEMErrorCode	DMMoFEMCreateHybridL2Mat (DM dm, SmartPetscObj< Mat > &mat)
	Create matrix for hybridised system. More...
auto	getInterfacePtr (DM dm)
	Get the Interface Ptr object. More...
auto	getProblemPtr (DM dm)
	get problem pointer from DM More...
auto	createDMMatrix (DM dm)
	Get smart matrix from DM. More...
auto	createDMHybridisedL2Matrix (DM dm)
	Get smart hybridised L2 matrix from DM. More...
auto	createDMBlockMat (DM dm)
auto	createDMNestSchurMat (DM dm)
DEPRECATED auto	smartCreateDMMatrix (DM dm)
auto	createDMVector (DM dm)
	Get smart vector from DM. More...
DEPRECATED auto	smartCreateDMVector (DM dm)
auto	getDMKspCtx (DM dm)
	Get KSP context data structure used by DM. More...
DEPRECATED auto	smartGetDMKspCtx (DM dm)
auto	getDMSnesCtx (DM dm)
	Get SNES context data structure used by DM. More...
DEPRECATED auto	smartGetDMSnesCtx (DM dm)
auto	getDMTsCtx (DM dm)
	Get TS context data structure used by DM. More...
DEPRECATED auto	smartGetDMTsCtx (DM dm)
auto	getDMSubData (DM dm)
	Get sub problem data structure. More...
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMKSPSetComputeRHS (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMKSPSetComputeOperators (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMSNESSetFunction (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMSNESSetJacobian (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetIFunction (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetIJacobian (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetRHSFunction (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetRHSJacobian (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetI2Function (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetI2Jacobian (DM dm, S fe_name, T0 method, T1 pre_only, T2 post_only)
template<class S , class T0 , class T1 , class T2 >
static PetscErrorCode	DMMoFEMTSSetMonitor (DM dm, TS ts, S fe_name, T0 method, T1 pre_only, T2 post_only)
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 elements in the list. More...
template<InsertMode MODE>
MoFEMErrorCode	sub_mat_mult_generic (Mat a, Vec x, Vec f)
MoFEMErrorCode	sub_mat_mult (Mat a, Vec x, Vec f)
MoFEMErrorCode	sub_mat_mult_add (Mat a, Vec x, Vec f)
MoFEMErrorCode	sub_mat_sor (Mat mat, Vec b, PetscReal omega, MatSORType flag, PetscReal shift, PetscInt its, PetscInt lits, Vec x)
MoFEMErrorCode	DMMGViaApproxOrdersSetAO (DM dm, AO ao)
	Set DM ordering. More...
MoFEMErrorCode	DMMGViaApproxOrdersPushBackCoarseningIS (DM, IS is, Mat A, bool create_sub_matrix, bool shell_sub_a)
	Push back coarsening level to MG via approximation orders. More...
MoFEMErrorCode	DMMGViaApproxOrdersPopBackCoarseningIS (DM)
	Pop IS form MG via approximation orders. More...
MoFEMErrorCode	DMMGViaApproxOrdersClearCoarseningIS (DM)
	Clear approximation orders. More...
MoFEMErrorCode	DMRegister_MGViaApproxOrders (const char sname[])
	Register DM for Multi-Grid via approximation orders. More...
static MoFEMErrorCode	ksp_set_operators (KSP ksp, Mat A, Mat B, void *ctx)
MoFEMErrorCode	DMCreate_MGViaApproxOrders (DM dm)
	Create DM data structure for Multi-Grid via approximation orders. More...
PetscErrorCode	DMDestroy_MGViaApproxOrders (DM dm)
	Destroy DM. More...
MoFEMErrorCode	DMCreateMatrix_MGViaApproxOrders (DM dm, Mat *M)
	Create matrix for Multi-Grid via approximation orders. More...
MoFEMErrorCode	DMCoarsen_MGViaApproxOrders (DM dm, MPI_Comm comm, DM *dmc)
	Coarsen DM. More...
MoFEMErrorCode	DMCreateInterpolation_MGViaApproxOrders (DM dm1, DM dm2, Mat *mat, Vec *vec)
	Create interpolation matrix between data managers dm1 and dm2. More...
MoFEMErrorCode	DMCreateGlobalVector_MGViaApproxOrders (DM dm, Vec *g)
	Create global vector for DMGViaApproxOrders. More...
boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx >	createPCMGSetUpViaApproxOrdersCtx (DM dm, Mat A, bool use_shell_mat)
	createPCMGSetUpViaApproxOrdersCtx More...
MoFEMErrorCode	PCMGSetUpViaApproxOrders (PC pc, boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx > ctx, int verb=0)
	Function build MG structure. 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...
MoFEMErrorCode	SnesMoFEMSetAssemblyType (SNES snes, MatAssemblyType type)
	Set assembly type at the end of SnesMat. More...
MoFEMErrorCode	SnesMoFEMSetBehavior (SNES snes, MoFEMTypes bh)
	Set behavior if finite element in sequence does not exist. More...
MoFEMErrorCode	MoFEMSNESMonitorFields (SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx *snes_ctx)
	Sens monitor printing residual field by field. More...
PetscErrorCode	TsSetIFunction (TS ts, PetscReal t, Vec u, Vec u_t, Vec F, void *ctx)
	Set IFunction for TS solver. More...
PetscErrorCode	TsSetIJacobian (TS ts, PetscReal t, Vec u, Vec u_t, PetscReal a, Mat A, Mat B, void *ctx)
	Set function evaluating jacobian in TS solver. More...
PetscErrorCode	TsMonitorSet (TS ts, PetscInt step, PetscReal t, Vec u, void *ctx)
	Set monitor for TS solver. More...
PetscErrorCode	TsSetRHSFunction (TS ts, PetscReal t, Vec u, Vec F, void *ctx)
	TS solver function. More...
PetscErrorCode	TsSetRHSJacobian (TS ts, PetscReal t, Vec u, Mat A, Mat B, void *ctx)
	TS solver function. More...
PetscErrorCode	TsSetI2Jacobian (TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, PetscReal a, PetscReal aa, Mat A, Mat B, void *ctx)
	Calculation Jacobian for second order PDE in time. More...
PetscErrorCode	TsSetI2Function (TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, Vec F, void *ctx)
	Calculation the right hand side for second order PDE in time. More...
PetscErrorCode	TSAdaptChooseMoFEM (TSAdapt adapt, TS ts, PetscReal h, PetscInt *next_sc, PetscReal *next_h, PetscBool *accept, PetscReal *wlte, PetscReal *wltea, PetscReal *wlter)
PetscErrorCode	TSAdaptResetMoFEM (TSAdapt adapt)
PetscErrorCode	TSAdaptDestroyMoFEM (TSAdapt adapt)
PetscErrorCode	TSAdaptCreateMoFEM (TSAdapt adapt)
	Craete MOFEM adapt. More...

Variables
DEPRECATED typedef EdgeElementForcesAndSourcesCore	EdgeElementForcesAndSourcesCoreBase
DEPRECATED typedef EntitiesFieldData	DataForcesAndSourcesCore
DEPRECATED typedef DerivedEntitiesFieldData	DerivedDataForcesAndSourcesCore
DEPRECATED typedef FaceElementForcesAndSourcesCore	FaceElementForcesAndSourcesCoreBase
DEPRECATED typedef FlatPrismElementForcesAndSourcesCore	FlatPrismElementForcesAndSurcesCore
	USe FlatPrismElementForcesAndSourcesCore. More...
DEPRECATED typedef ForcesAndSourcesCore	ForcesAndSurcesCore
DEPRECATED typedef VolumeElementForcesAndSourcesCore	VolumeElementForcesAndSourcesCoreBase
DEPRECATED typedef VolumeElementForcesAndSourcesCoreOnContactPrismSide	VolumeElementForcesAndSourcesCoreOnContactPrismSideBase
DEPRECATED typedef VolumeElementForcesAndSourcesCoreOnSide	VolumeElementForcesAndSourcesCoreOnSideBase
DEPRECATED typedef DofMethod	EntMethod
const EntityHandle	no_handle
	No entity handle is indicated by zero handle, i.e. root meshset. More...
static constexpr int	edges_conn [] = {0, 1, 1, 2, 2, 0, 0, 3, 1, 3, 2, 3}
static constexpr int	oposite_edge [] = {5, 3, 4, 1, 2, 0}
static constexpr int	edge_permutations [6][6]
static constexpr int	edge_mirror_cross [6] = {0, 3, 4, 1, 2, 5}
static constexpr int	edge_mirror_vertical [6] = {0, 4, 3, 2, 1, 5}
static constexpr int	cyclic_node_rotate_face_3 [3][4]
static constexpr int	cyclic_edge_rotate_face_3 [3][6]
static constexpr char	edge_bits_mark [] = {1, 2, 4, 8, 16, 32}
Tag	th
Field_multiIndex::index< FieldName_mi_tag >::type::iterator	field_it
VectorDouble	L
VectorDouble	K
const static bool	debug = false
constexpr bool	debug_schur = false
constexpr int	max_gemv_size = 2
constexpr const char	MoFEM_BLOCK_MAT [] = "mofem_block_mat"
static char	dummy_file

Detailed Description

implementation of Data Operators for Forces and Sources

name space of MoFEM library functions and classes

file DataOperators.cpp

Typedef Documentation

BaseDerivatives

using MoFEM::BaseDerivatives = typedef EntitiesFieldData::EntData::BaseDerivatives

Definition at line 1126 of file EntitiesFieldData.hpp.

BasicMethodsSequence

typedef std::deque<BasicMethodPtr> MoFEM::BasicMethodsSequence

Definition at line 57 of file AuxPETSc.hpp.

BcTemperature

template<CubitBC BC>

using MoFEM::BcTemperature = typedef BcScalarMeshsetType<BC>

Definition at line 16 of file BcManager.hpp.

BlockFieldPair

using MoFEM::BlockFieldPair = typedef Problem::BlockFieldPair

Definition at line 566 of file ProblemsMultiIndices.hpp.

CacheMatsTypeType

using MoFEM::CacheMatsTypeType = typedef std::map<std::pair<int, int>, boost::shared_ptr<MatrixDouble> >

Definition at line 19 of file BiLinearFormsIntegratorsImpl.hpp.

CacheTuple

using MoFEM::CacheTuple = typedef std::tuple< std::vector<EntityCacheDofs>, std::vector<EntityCacheNumeredDofs>, std::vector<EntityCacheNumeredDofs> >

Definition at line 492 of file FEMultiIndices.hpp.

CacheTupleSharedPtr

using MoFEM::CacheTupleSharedPtr = typedef boost::shared_ptr<CacheTuple>

Definition at line 495 of file FEMultiIndices.hpp.

CacheTupleWeakPtr

using MoFEM::CacheTupleWeakPtr = typedef boost::weak_ptr<CacheTuple>

Definition at line 494 of file FEMultiIndices.hpp.

ConstantFun

using MoFEM::ConstantFun = typedef boost::function<double()>

Constant function type.

Definition at line 166 of file FormsIntegrators.hpp.

Core

using MoFEM::Core = typedef CoreTmp<0>

Examples

add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.cpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, approx_sphere.cpp, bernstein_bezier_generate_base.cpp, bone_adaptation.cpp, boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, cell_forces.cpp, child_and_parent.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, cubit_bc_test.cpp, delete_ho_nodes.cpp, dg_projection.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, edge_and_bubble_shape_functions_on_quad.cpp, eigen_elastic.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, ep.cpp, EshelbianPlasticity.cpp, field_blas.cpp, field_evaluator.cpp, field_to_vertices.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_check_approx_in_3d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.cpp, hertz_surface.cpp, higher_derivatives.cpp, level_set.cpp, log.cpp, loop_entities.cpp, lorentz_force.cpp, magnetostatic.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, minimal_surface_area.cpp, mixed_poisson.cpp, mortar_contact.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, operators_tests.cpp, partition_mesh.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, seepage.cpp, shallow_wave.cpp, simple_contact.cpp, simple_contact_thermal.cpp, simple_elasticity.cpp, simple_interface.cpp, simple_l2_only.cpp, split_sideset.cpp, tensor_divergence_operator.cpp, test_broken_space.cpp, test_cache_on_entities.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, wave_equation.cpp, and wavy_surface.cpp.

Definition at line 1148 of file Core.hpp.

CreateRowComressedADJMatrix

using MoFEM::CreateRowComressedADJMatrix = typedef CreateRowCompressedADJMatrix

Deprecated:

do not use, instead use CreateRowCompressedADJMatrix

Definition at line 78 of file MatrixManager.cpp.

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
CubitMeshsetType_mi_tag	index by bc type, see CubitBC
CubitMeshsetMaskedType_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;
  CHKERR m_field.getInterface(m_mng);
  auto &index = m_mng->getMeshsetsMultindex();
 
 
  auto mit =
index.get<CubitMeshsetMaskedType_mi_tag>().lower_bound(BLOCKSET); auto
hi_mit =
index.get<CubitMeshsetMaskedType_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
    auto mit->getAttributes(attributes);
    // do something
  }

Definition at line 388 of file BCMultiIndices.hpp.

CubitMeshsetById

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

Definition at line 24 of file MeshsetsManager.hpp.

CubitMeshsetByMask

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

Definition at line 18 of file MeshsetsManager.hpp.

CubitMeshsetByName

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

Definition at line 21 of file MeshsetsManager.hpp.

CubitMeshsetByType

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

Definition at line 15 of file MeshsetsManager.hpp.

DofEntityByUId

using MoFEM::DofEntityByUId = typedef DofEntity_multiIndex::index<Unique_mi_tag>::type

Definition at line 319 of file DofsMultiIndices.hpp.

DofsAllocator

using MoFEM::DofsAllocator = typedef ublas::unbounded_array< FEDofEntity *, std::allocator<FEDofEntity *> >

Definition at line 21 of file EntitiesFieldData.hpp.

EmptyFieldBlocks

typedef Problem::EmptyFieldBlocks MoFEM::EmptyFieldBlocks

Definition at line 567 of file ProblemsMultiIndices.hpp.

FEFun

using MoFEM::FEFun = typedef boost::function<double(const FEMethod *fe_ptr)>

Lambda function used to scale with time.

Definition at line 160 of file FormsIntegrators.hpp.

FEMethodsSequence

typedef std::deque<PairNameFEMethodPtr> MoFEM::FEMethodsSequence

Definition at line 56 of file AuxPETSc.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 516 of file FieldMultiIndices.hpp.

FieldEntAllocator

using MoFEM::FieldEntAllocator = typedef ublas::unbounded_array< FieldEntity *, std::allocator<FieldEntity *> >

Definition at line 29 of file EntitiesFieldData.hpp.

FieldEntity_multiIndex

using MoFEM::FieldEntity_multiIndex = typedef multi_index_container< boost::shared_ptr<FieldEntity>, indexed_by< ordered_unique<tag<Unique_mi_tag>, member<FieldEntity, UId, &FieldEntity::localUId> >, ordered_non_unique<tag<Ent_mi_tag>, const_mem_fun<FieldEntity::interface_type_RefEntity, EntityHandle, &FieldEntity::getEnt> > > >

Definition at line 489 of file FieldEntsMultiIndices.hpp.

FieldEntity_multiIndex_ent_view

using MoFEM::FieldEntity_multiIndex_ent_view = typedef multi_index_container< boost::shared_ptr<FieldEntity>, indexed_by< sequenced<>, ordered_non_unique<tag<Ent_mi_tag>, const_mem_fun<FieldEntity::interface_type_RefEntity, EntityHandle, &FieldEntity::getEnt> > > >

Definition at line 456 of file FieldEntsMultiIndices.hpp.

FieldEntity_multiIndex_spaceType_view

using MoFEM::FieldEntity_multiIndex_spaceType_view = typedef multi_index_container< boost::shared_ptr<FieldEntity>, indexed_by< sequenced<>, ordered_non_unique< tag<Composite_EntType_and_Space_mi_tag>, composite_key<FieldEntity, const_mem_fun<FieldEntity::interface_type_RefEntity, EntityType, &FieldEntity::getEntType>, const_mem_fun<FieldEntity::interface_type_Field, FieldSpace, &FieldEntity::getSpace> > > > >

Definition at line 476 of file FieldEntsMultiIndices.hpp.

FieldEntity_vector_view

typedef std::vector<boost::weak_ptr<FieldEntity> > MoFEM::FieldEntity_vector_view

Definition at line 478 of file FieldEntsMultiIndices.hpp.

i_FTIndex

template<int DIM>

using MoFEM::i_FTIndex = typedef FTensor::Index<'i', DIM>

Definition at line 1998 of file Templates.hpp.

I_FTIndex

template<int DIM>

using MoFEM::I_FTIndex = typedef FTensor::Index<'I', DIM>

Definition at line 2004 of file Templates.hpp.

Interface

using MoFEM::Interface = typedef DeprecatedCoreInterface

Examples

add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.cpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, analytical_poisson_field_split.cpp, approx_sphere.cpp, bernstein_bezier_generate_base.cpp, bone_adaptation.cpp, boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, cell_forces.cpp, child_and_parent.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, cubit_bc_test.cpp, delete_ho_nodes.cpp, dg_projection.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, edge_and_bubble_shape_functions_on_quad.cpp, eigen_elastic.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, ElasticityMixedFormulation.hpp, ep.cpp, EshelbianPlasticity.cpp, field_blas.cpp, field_evaluator.cpp, field_to_vertices.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_check_approx_in_3d.cpp, hdiv_divergence_operator.cpp, heat_equation.cpp, heat_method.cpp, hello_world.cpp, helmholtz.cpp, hertz_surface.cpp, higher_derivatives.cpp, HookeElement.hpp, HookeInternalStressElement.hpp, level_set.cpp, log.cpp, loop_entities.cpp, lorentz_force.cpp, MagneticElement.hpp, magnetostatic.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, minimal_surface_area.cpp, mixed_poisson.cpp, mortar_contact.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, NavierStokesElement.hpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, operators_tests.cpp, partition_mesh.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, Remodeling.cpp, Remodeling.hpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, seepage.cpp, shallow_wave.cpp, simple_contact.cpp, simple_contact_thermal.cpp, simple_elasticity.cpp, simple_interface.cpp, simple_l2_only.cpp, split_sideset.cpp, tensor_divergence_operator.cpp, test_broken_space.cpp, test_cache_on_entities.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, unsaturated_transport.cpp, UnsaturatedFlow.hpp, wave_equation.cpp, and wavy_surface.cpp.

Definition at line 2010 of file Interface.hpp.

j_FTIndex

template<int DIM>

using MoFEM::j_FTIndex = typedef FTensor::Index<'j', DIM>

Definition at line 1999 of file Templates.hpp.

J_FTIndex

template<int DIM>

using MoFEM::J_FTIndex = typedef FTensor::Index<'J', DIM>

Definition at line 2005 of file Templates.hpp.

k_FTIndex

template<int DIM>

using MoFEM::k_FTIndex = typedef FTensor::Index<'k', DIM>

Definition at line 2000 of file Templates.hpp.

K_FTIndex

template<int DIM>

using MoFEM::K_FTIndex = typedef FTensor::Index<'K', DIM>

Definition at line 2006 of file Templates.hpp.

l_FTIndex

template<int DIM>

using MoFEM::l_FTIndex = typedef FTensor::Index<'l', DIM>

Definition at line 2001 of file Templates.hpp.

L_FTIndex

template<int DIM>

using MoFEM::L_FTIndex = typedef FTensor::Index<'L', DIM>

Definition at line 2007 of file Templates.hpp.

m_FTIndex

template<int DIM>

using MoFEM::m_FTIndex = typedef FTensor::Index<'m', DIM>

Definition at line 2002 of file Templates.hpp.

M_FTIndex

template<int DIM>

using MoFEM::M_FTIndex = typedef FTensor::Index<'M', DIM>

Definition at line 2008 of file Templates.hpp.

n_FTIndex

template<int DIM>

using MoFEM::n_FTIndex = typedef FTensor::Index<'n', DIM>

Definition at line 2003 of file Templates.hpp.

N_FTIndex

template<int DIM>

using MoFEM::N_FTIndex = typedef FTensor::Index<'N', DIM>

Definition at line 2009 of file Templates.hpp.

NestSchurData

using MoFEM::NestSchurData = typedef std::tuple< std::array<SmartPetscObj<Mat>, 4>, std::array<boost::shared_ptr<BlockStructure>, 4>, boost::shared_ptr<BlockStructure>, std::pair<SmartPetscObj<IS>, SmartPetscObj<IS> > >

Definition at line 106 of file Schur.hpp.

NumeredDofEntity_multiIndex_coeff_idx_ordered_non_unique

using MoFEM::NumeredDofEntity_multiIndex_coeff_idx_ordered_non_unique = typedef multi_index_container< boost::shared_ptr<NumeredDofEntity>, indexed_by<ordered_non_unique<const_mem_fun< NumeredDofEntity::interface_type_DofEntity, FieldCoefficientsNumber, &NumeredDofEntity::getDofCoeffIdx> >> >

Definition at line 521 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_idx_view_hashed

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

Definition at line 508 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_petsc_local_dof_view_ordered_non_unique

using MoFEM::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> >> >

Definition at line 514 of file DofsMultiIndices.hpp.

NumeredDofEntity_multiIndex_uid_view_ordered

using MoFEM::NumeredDofEntity_multiIndex_uid_view_ordered = typedef multi_index_container<boost::shared_ptr<NumeredDofEntity>, indexed_by< ordered_unique<const_mem_fun< NumeredDofEntity::interface_type_DofEntity, UId, &NumeredDofEntity::getLocalUniqueId > > > >

Definition at line 503 of file DofsMultiIndices.hpp.

OpCalculateHOJacForFace

using MoFEM::OpCalculateHOJacForFace = typedef OpCalculateHOJacForFaceImpl<2>

Examples

continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, higher_derivatives.cpp, minimal_surface_area.cpp, phase.cpp, plot_base.cpp, and poisson_2d_dis_galerkin.cpp.

Definition at line 264 of file HODataOperators.hpp.

OpCalculateHOJacForFaceEmbeddedIn3DSpace

using MoFEM::OpCalculateHOJacForFaceEmbeddedIn3DSpace = typedef OpCalculateHOJacForFaceImpl<3>

Examples

EshelbianOperators.cpp, heat_method.cpp, and shallow_wave.cpp.

Definition at line 265 of file HODataOperators.hpp.

OpCalculateHOJacVolume

using MoFEM::OpCalculateHOJacVolume = typedef OpCalculateHOJacForVolume

Deprecated:

use OpCalculateHOJacForVolume

Definition at line 34 of file HODataOperators.hpp.

OpCalculateScalarFieldValuesDot

using MoFEM::OpCalculateScalarFieldValuesDot = typedef OpCalculateScalarFieldValuesFromPetscVecImpl<PetscData::CTX_SET_X_T>

Examples

free_surface.cpp, heat_equation.cpp, photon_diffusion.cpp, PlasticOps.hpp, reaction_diffusion.cpp, seepage.cpp, shallow_wave.cpp, and thermo_elastic.cpp.

Definition at line 273 of file UserDataOperators.hpp.

OpCalculateScalarFieldValuesDotDot

using MoFEM::OpCalculateScalarFieldValuesDotDot = typedef OpCalculateScalarFieldValuesFromPetscVecImpl<PetscData::CTX_SET_X_TT>

Examples

wave_equation.cpp.

Definition at line 275 of file UserDataOperators.hpp.

OpCalculateScalarValuesDot

using MoFEM::OpCalculateScalarValuesDot = typedef OpCalculateScalarFieldValuesDot

Deprecated:

Name inconsistent with other operators

Definition at line 281 of file UserDataOperators.hpp.

OpSetContrariantPiolaTransformOnEdge

using MoFEM::OpSetContrariantPiolaTransformOnEdge = typedef OpSetContravariantPiolaTransformOnEdge2D

Deprecated:

Name is deprecated and this is added for back compatibility

Definition at line 3100 of file UserDataOperators.hpp.

OpSetContravariantPiolaTransformOnFace2D

using MoFEM::OpSetContravariantPiolaTransformOnFace2D = typedef OpSetContravariantPiolaTransformOnFace2DImpl<2>

Examples

continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, hcurl_check_approx_in_2d.cpp, phase.cpp, and plot_base.cpp.

Definition at line 3076 of file UserDataOperators.hpp.

OpSetContravariantPiolaTransformOnFace2DEmbeddedIn3DSpace

using MoFEM::OpSetContravariantPiolaTransformOnFace2DEmbeddedIn3DSpace = typedef OpSetContravariantPiolaTransformOnFace2DImpl<3>

Definition at line 3078 of file UserDataOperators.hpp.

OpSetCovariantPiolaTransformOnFace2D

using MoFEM::OpSetCovariantPiolaTransformOnFace2D = typedef OpSetCovariantPiolaTransformOnFace2DImpl<2>

Definition at line 3028 of file UserDataOperators.hpp.

OpSetInvJacHcurlFace

using MoFEM::OpSetInvJacHcurlFace = typedef OpSetInvJacHcurlFaceImpl<2>

Examples

cell_forces.cpp, hcurl_check_approx_in_2d.cpp, and phase.cpp.

Definition at line 2978 of file UserDataOperators.hpp.

OpSetInvJacHcurlFaceEmbeddedIn3DSpace

using MoFEM::OpSetInvJacHcurlFaceEmbeddedIn3DSpace = typedef OpSetInvJacHcurlFaceImpl<3>

Definition at line 2979 of file UserDataOperators.hpp.

PostProcBrokenMeshInMoabBaseBegin

using MoFEM::PostProcBrokenMeshInMoabBaseBegin = typedef PostProcBrokenMeshInMoabBaseBeginImpl< PostProcBrokenMeshInMoabBase<ForcesAndSourcesCore> >

Enable to run stack of post-processing elements. Use this to begin stack.

See scalar_check_approximation.cpp

Examples

EshelbianPlasticity.cpp.

Definition at line 934 of file PostProcBrokenMeshInMoabBase.hpp.

PostProcBrokenMeshInMoabBaseCont

template<typename E >

using MoFEM::PostProcBrokenMeshInMoabBaseCont = typedef PostProcBrokenMeshInMoabBaseContImpl<PostProcBrokenMeshInMoabBase<E> >

Enable to run stack of post-processing elements.

See scalar_check_approximation.cpp

Template Parameters

E

Definition at line 945 of file PostProcBrokenMeshInMoabBase.hpp.

PostProcBrokenMeshInMoabBaseEnd

using MoFEM::PostProcBrokenMeshInMoabBaseEnd = typedef PostProcBrokenMeshInMoabBaseEndImpl< PostProcBrokenMeshInMoabBase<ForcesAndSourcesCore> >

Enable to run stack of post-processing elements. Use this to end stack.

Examples

EshelbianPlasticity.cpp.

Definition at line 952 of file PostProcBrokenMeshInMoabBase.hpp.

PostProcGenerateRefMeshPtr

using MoFEM::PostProcGenerateRefMeshPtr = typedef boost::shared_ptr<PostProcGenerateRefMeshBase>

Definition at line 54 of file PostProcBrokenMeshInMoabBase.hpp.

RefElement_multiIndex_parents_view

typedef multi_index_container< boost::shared_ptr<RefElement>, indexed_by< ordered_unique<tag<Ent_mi_tag>, const_mem_fun<RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getEnt> >, ordered_non_unique< tag<Ent_Ent_mi_tag>, const_mem_fun<RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getParentEnt> >, ordered_non_unique< tag<Composite_ParentEnt_And_BitsOfRefinedEdges_mi_tag>, composite_key< RefElement, const_mem_fun<RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getParentEnt>, const_mem_fun<RefElement, int, &RefElement::getBitRefEdgesUlong> > > > > MoFEM::RefElement_multiIndex_parents_view

Definition at line 30 of file MeshRefinement.cpp.

RefEntity

using MoFEM::RefEntity = typedef RefEntityTmp<0>

Definition at line 566 of file RefEntsMultiIndices.hpp.

RefEntity_multiIndex_view_by_ordered_parent_entity

using MoFEM::RefEntity_multiIndex_view_by_ordered_parent_entity = typedef multi_index_container< boost::shared_ptr<RefEntity>, indexed_by<ordered_non_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::getEnt>, const_mem_fun<RefEntity, EntityHandle, &RefEntity::getParentEnt> >> > >

Definition at line 792 of file RefEntsMultiIndices.hpp.

RefEntity_multiIndex_view_sequence_ordered_view

using MoFEM::RefEntity_multiIndex_view_sequence_ordered_view = typedef multi_index_container< boost::shared_ptr<RefEntity>, indexed_by< sequenced<>, ordered_unique<tag<Ent_mi_tag>, const_mem_fun<RefEntity, EntityHandle, &RefEntity::getEnt> >> >

Definition at line 799 of file RefEntsMultiIndices.hpp.

SchurFEOpsFEandFields

using MoFEM::SchurFEOpsFEandFields = typedef std::vector< std::pair<std::string, std::vector<SchurFieldPair> > >

Definition at line 73 of file Schur.hpp.

SchurFieldPair

using MoFEM::SchurFieldPair = typedef std::pair<std::string, std::string>

Definition at line 67 of file Schur.hpp.

SchurShellMatData

using MoFEM::SchurShellMatData = typedef std::pair<SmartPetscObj<Mat>, boost::shared_ptr<BlockStructure> >

Definition at line 88 of file Schur.hpp.

Sev

typedef LogManager::SeverityLevel MoFEM::Sev

Examples

ADOLCPlasticity.hpp, ADOLCPlasticityMaterialModels.hpp, HenckyOps.hpp, PlasticOps.hpp, and ThermoElasticOps.hpp.

Definition at line 17 of file CoreTemplates.hpp.

ShardVec

template<typename T >

using MoFEM::ShardVec = typedef boost::shared_ptr<std::vector<T> >

Definition at line 10 of file Templates.hpp.

TimeFun

using MoFEM::TimeFun = typedef boost::function<double(double)>

Lambda function used to scale with time.

Definition at line 154 of file FormsIntegrators.hpp.

TimeScaleVector2

using MoFEM::TimeScaleVector2 = typedef TimeScaleVector<3>

Definition at line 134 of file ScalingMethod.hpp.

TimeScaleVector3

using MoFEM::TimeScaleVector3 = typedef TimeScaleVector<3>

Definition at line 133 of file ScalingMethod.hpp.

VecOfTimeScalingMethods

using MoFEM::VecOfTimeScalingMethods = typedef std::vector<boost::shared_ptr<ScalingMethod> >

Vector of time scaling methods.

Definition at line 20 of file Natural.hpp.

VecOfTimeVectorScalingMethods

template<int FIELD_DIM>

using MoFEM::VecOfTimeVectorScalingMethods = typedef std::vector<boost::shared_ptr<TimeScaleVector<FIELD_DIM> >>

Vector of time vector scaling methods.

Definition at line 28 of file Natural.hpp.

VectorDofs

using MoFEM::VectorDofs = typedef ublas::vector<FEDofEntity *, DofsAllocator>

Definition at line 23 of file EntitiesFieldData.hpp.

VectorFieldEntities

using MoFEM::VectorFieldEntities = typedef ublas::vector<FieldEntity *, FieldEntAllocator>

Definition at line 31 of file EntitiesFieldData.hpp.

VectorFunc

typedef boost::function<VectorDouble(const double, const double, const double)> MoFEM::VectorFunc

Definition at line 98 of file NormsOperators.hpp.

Enumeration Type Documentation

MPC

enum MoFEM::MPC

strong

Enumerator
TIE
RIGID_BODY
COUPLING
EMBEDDED_REGION
EQUATION
LAST

Definition at line 16 of file EssentialMPCsData.hpp.

{ TIE, RIGID_BODY, COUPLING, EMBEDDED_REGION, EQUATION, LAST };

Function Documentation

addHOOpsFace3D()

template<typename E >

MoFEMErrorCode MoFEM::addHOOpsFace3D	(	const std::string	field,
		E &	e,
		bool	hcurl,
		bool	hdiv
	)

Deprecated:

do not use this function, instead use AddHOOps.

Template Parameters

E

Parameters

field
e
hcurl
hdiv

Returns

MoFEMErrorCode

Examples

elasticity.cpp, mortar_contact_thermal.cpp, nonlinear_dynamics.cpp, simple_contact.cpp, and simple_contact_thermal.cpp.

Definition at line 701 of file HODataOperators.hpp.

                                                                {
  std::vector<FieldSpace> spaces;
  if (hcurl)
    spaces.push_back(HCURL);
  if (hdiv)
    spaces.push_back(HDIV);
  return AddHOOps<2, 3, 3>::add(e.getOpPtrVector(), spaces, field);
}

addHOOpsVol()

template<typename E >

MoFEMErrorCode MoFEM::addHOOpsVol	(	const std::string	field,
		E &	e,
		bool	h1,
		bool	hcurl,
		bool	hdiv,
		bool	l2
	)

Deprecated:

do not use this function, instead use AddHOOps.

Template Parameters

E

Parameters

field
e
h1
hcurl
hdiv
l2

Returns

MoFEMErrorCode

Examples

elasticity.cpp, HookeElement.cpp, MagneticElement.hpp, navier_stokes.cpp, nonlinear_dynamics.cpp, NonlinearElasticElementInterface.hpp, and Remodeling.cpp.

Definition at line 676 of file HODataOperators.hpp.

                                                                      {
  std::vector<FieldSpace> spaces;
  if (h1)
    spaces.push_back(H1);
  if (hcurl)
    spaces.push_back(HCURL);
  if (hdiv)
    spaces.push_back(HDIV);
  if (l2)
    spaces.push_back(L2);
  return AddHOOps<3, 3, 3>::add(e.getOpPtrVector(), spaces, field);
}

cmp_uid_hi()

static auto MoFEM::cmp_uid_hi ( const UId &  b, const boost::weak_ptr< FieldEntity > &  a  )

static

Definition at line 29 of file ForcesAndSourcesCore.cpp.

                                                                          {
  if (auto a_ptr = a.lock()) {
    if (b < a_ptr->getLocalUniqueId())
      return true;
    else
      return false;
  } else {
    return true;
  }
}

cmp_uid_lo()

static auto MoFEM::cmp_uid_lo ( const boost::weak_ptr< FieldEntity > &  a, const UId &  b  )

static

Definition at line 18 of file ForcesAndSourcesCore.cpp.

                                                                          {
  if (auto a_ptr = a.lock()) {
    if (a_ptr->getLocalUniqueId() < b)
      return true;
    else
      return false;
  } else {
    return false;
  }
}

computeEigenValuesSymmetric() [1/3]

template<int DIM, typename T1 , typename T2 , typename T3 >

MoFEMErrorCode MoFEM::computeEigenValuesSymmetric ( const FTensor::Tensor2_symmetric< T1, DIM > &  mat, FTensor::Tensor1< T2, DIM > &  eig, FTensor::Tensor2< T3, DIM, DIM > &  eigen_vec  )

inline

compute eigenvalues of a symmetric tensor using lapack dsyev

Template Parameters

DIM

Parameters

mat	input tensor pointer of size DIM x DIM
eig	output eigen values sorted
eigen_vec	output matrix of row eigen vectors

Returns

MoFEMErrorCode

Definition at line 1520 of file Templates.hpp.

                                                                     {
  MoFEMFunctionBegin;
  for (int ii = 0; ii != DIM; ii++)
    for (int jj = 0; jj != DIM; jj++)
      eigen_vec(ii, jj) = mat(ii, jj);
 
  CHKERR computeEigenValuesSymmetric(eigen_vec, eig);
 
  MoFEMFunctionReturn(0);
}

computeEigenValuesSymmetric() [2/3]

MoFEMErrorCode MoFEM::computeEigenValuesSymmetric ( const MatrixDouble &  mat, VectorDouble &  eig, MatrixDouble &  eigen_vec  )

inline

compute eigenvalues of a symmetric matrix using lapack dsyev

Parameters

mat	input symmetric matrix
eig	output eigen values sorted
eigen_vec	output matrix of row eigen vectors

Returns

MoFEMErrorCode

Examples

EshelbianOperators.cpp, and HenckyOps.hpp.

Definition at line 1452 of file Templates.hpp.

                                                                           {
  MoFEMFunctionBegin;
 
  const size_t M = mat.size1();
  const size_t N = mat.size2();
 
  if (M == 0 || M != N)
    SETERRQ2(
        PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
        "The input matrix for eigen value computation is not square %d != %d",
        M, N);
  if (eig.size() != M)
    eig.resize(M, false);
 
  eigen_vec = mat;
  const int n = M;
  const int lda = M;
  const int size = (M + 2) * M;
  int lwork = size;
  double *work = new double[size];
 
  if (lapack_dsyev('V', 'U', n, &*eigen_vec.data().begin(), lda,
                   &*eig.data().begin(), work, lwork) > 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "The algorithm failed to compute eigenvalues.");
 
  delete[] work;
  MoFEMFunctionReturn(0);
}

computeEigenValuesSymmetric() [3/3]

template<int DIM, typename T1 , typename T2 >

MoFEMErrorCode MoFEM::computeEigenValuesSymmetric ( FTensor::Tensor2< T1, DIM, DIM > &  eigen_vec, FTensor::Tensor1< T2, DIM > &  eig  )

inline

compute eigenvalues of a symmetric matrix using lapack dsyev

Template Parameters

DIM

Parameters

eigen_vec	input / output DIM x DIM matrix of row eigen vectors
eig	output eigen values sorted

Returns

MoFEMErrorCode

Definition at line 1493 of file Templates.hpp.

                                                          {
  MoFEMFunctionBegin;
 
  const int n = DIM;
  const int lda = DIM;
  const int lwork = (DIM + 2) * DIM;
  std::array<double, (DIM + 2) * DIM> work;
 
  if (lapack_dsyev('V', 'U', n, &eigen_vec(0, 0), lda, &eig(0), work.data(),
                   lwork) > 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "The algorithm failed to compute eigenvalues.");
  MoFEMFunctionReturn(0);
}

computeMatrixInverse()

MoFEMErrorCode MoFEM::computeMatrixInverse ( MatrixDouble &  mat )

inline

compute matrix inverse with lapack dgetri

Parameters

mat	input square matrix / output inverse matrix

Returns

MoFEMErrorCode

Definition at line 1365 of file Templates.hpp.

                                                              {
  MoFEMFunctionBegin;
 
  const size_t M = mat.size1();
  const size_t N = mat.size2();
 
  if (M != N)
    SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "The input matrix for inverse computation is not square %d != %d",
             M, N);
 
  int *ipv = new int[N];
  int lwork = N * N;
  double *work = new double[lwork];
  int info;
  info = lapack_dgetrf(N, N, &*mat.data().begin(), N, ipv);
  if (info != 0)
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "lapack error info = %d", info);
  info = lapack_dgetri(N, &*mat.data().begin(), N, ipv, work, lwork);
  if (info != 0)
    SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
             "lapack error info = %d", info);
 
  delete[] ipv;
  delete[] work;
 
  MoFEMFunctionReturn(0);
}

constructor_data()

static void MoFEM::constructor_data ( EntitiesFieldData *  data, const EntityType  type  )

static

Definition at line 42 of file EntitiesFieldData.cpp.

                                                                             {
 
  using EntData = EntitiesFieldData::EntData;
 
  auto set_default = [&]() {
    std::array<size_t, MBMAXTYPE> count;
    std::fill(count.begin(), count.end(), 0);
    const int dim_type = moab::CN::Dimension(type);
    data->dataOnEntities[MBVERTEX].resize(1);
    if (type != MBVERTEX) {
      for (auto dd = dim_type; dd > 0; --dd) {
        int nb_ents = moab::CN::NumSubEntities(type, dd);
        for (int ii = 0; ii != nb_ents; ++ii) {
          auto sub_ent_type = moab::CN::SubEntityType(type, dd, ii);
          count[sub_ent_type] = nb_ents;
        }
        for (auto tt = moab::CN::TypeDimensionMap[dd].first;
             tt <= moab::CN::TypeDimensionMap[dd].second; ++tt) {
          data->dataOnEntities[tt].resize(count[tt]);
        }
      }
    }
  };
 
  switch (type) {
  case MBENTITYSET:
    break;
 
  default:
    set_default();
  }
}

constructor_derived_data()

static void MoFEM::constructor_derived_data ( DerivedEntitiesFieldData *  derived_data, const boost::shared_ptr< EntitiesFieldData > &  data_ptr  )

static

Definition at line 86 of file EntitiesFieldData.cpp.

                                                                             {
 
  using EntData = EntitiesFieldData::EntData;
  using DerivedEntData = DerivedEntitiesFieldData::DerivedEntData;
 
  for (int tt = MBVERTEX; tt != MBMAXTYPE; ++tt) {
    auto &ent_data = data_ptr->dataOnEntities[tt];
    auto &derived_ent_data = derived_data->dataOnEntities[tt];
    for (auto c = derived_ent_data.size(); c < ent_data.size(); ++c) {
      boost::shared_ptr<EntData> ent_data_ptr(data_ptr, &ent_data[c]);
      derived_ent_data.push_back(new DerivedEntData(ent_data_ptr));
    }
    derived_ent_data.resize(ent_data.size());
  }
}

createAOMapping()

auto MoFEM::createAOMapping ( MPI_Comm  comm, PetscInt  napp, const PetscInt  myapp[], const PetscInt  mypetsc[]  )

inline

Creates an application mapping using two integer arrays.

AOCreateMappingIS.

Parameters

comm	MPI communicator that is to share the AO
napp	size of integer arrays
myapp	integer array that defines an ordering
mypetsc	integer array that defines another ordering (may be NULL to indicate the identity ordering)

Returns

SmartPetscObj<AO>(ao);

Definition at line 338 of file PetscSmartObj.hpp.

                                                                              {
  AO ao;
  CHK_THROW_MESSAGE(AOCreateMapping(comm, napp, myapp, mypetsc, &ao),
                    "create ao");
  return SmartPetscObj<AO>(ao);
}

createAOMappingIS()

auto MoFEM::createAOMappingIS ( IS  isapp, IS  ispetsc  )

inline

Creates an application mapping using two index sets.

AOCreateMappingIS.

Parameters

isapp	index set that defines an ordering
ispetsc	index set that defines another ordering, maybe NULL for identity
aoout	the new application ordering

Returns

SmartPetscObj<AO>(ao)

Examples

schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 318 of file PetscSmartObj.hpp.

                                                    {
  AO ao;
  CHK_THROW_MESSAGE(AOCreateMappingIS(isapp, ispetsc, &ao),
                    "Failed to create AO");
  return SmartPetscObj<AO>(ao);
};

createBlockMat()

SchurShellMatData MoFEM::createBlockMat	(	DM	dm,
		boost::shared_ptr< BlockStructure >	data
	)

Create a Schur Mat object.

Parameters

dm
data

Returns

std::pair<SmartPetscObj<Mat>, boost::shared_ptr<BlockStructure>>

Examples

schur_test_diag_mat.cpp.

Definition at line 1379 of file Schur.cpp.

                                                                       {
 
  auto problem_ptr = getProblemPtr(dm);
  auto nb_local = problem_ptr->nbLocDofsRow;
  auto nb_global = problem_ptr->nbDofsRow;
 
  // check in nb, rows is equal to nb. columns.
  if (nb_local != problem_ptr->nbLocDofsCol) {
    MOFEM_LOG("SELF", Sev::error)
        << "Wrong size " << nb_local << " != " << problem_ptr->nbLocDofsCol;
    CHK_MOAB_THROW(MOFEM_DATA_INCONSISTENCY,
                   "nb. cols is inconsistent with nb. rows");
  }
  if (nb_global != problem_ptr->nbDofsCol) {
    MOFEM_LOG("SELF", Sev::error)
        << "Wrong size " << nb_global << " != " << problem_ptr->nbDofsCol;
    CHK_MOAB_THROW(MOFEM_DATA_INCONSISTENCY,
                   "nb. cols is inconsistent with nb. rows");
  }
 
  // get comm from DM
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
 
  Mat mat_raw;
  CHKERR MatCreateShell(comm, nb_local, nb_local, nb_global, nb_global,
                        (void *)data.get(), &mat_raw);
  CHKERR setSchurBlockMatOps(mat_raw);
  // CHKERR PetscObjectSetName((PetscObject)mat_raw, MoFEM_BLOCK_MAT);
 
  return std::make_pair(SmartPetscObj<Mat>(mat_raw), data);
}

createBlockMatStructure()

boost::shared_ptr< BlockStructure > MoFEM::createBlockMatStructure	(	DM	dm,
		SchurFEOpsFEandFields	schur_fe_op_vec
	)

Create a Mat Diag Blocks object.

Returns

Mat

Examples

plastic.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 1009 of file Schur.cpp.

  {
 
  auto cmp_uid_lo = [](const boost::weak_ptr<FieldEntity> &a, const UId &b) {
    if (auto a_ptr = a.lock()) {
      if (a_ptr->getLocalUniqueId() < b)
        return true;
      else
        return false;
    } else {
      return false;
    }
  };
 
  auto cmp_uid_hi = [](const UId &b, const boost::weak_ptr<FieldEntity> &a) {
    if (auto a_ptr = a.lock()) {
      if (b < a_ptr->getLocalUniqueId())
        return true;
      else
        return false;
    } else {
      return true;
    }
  };
 
  // get uids for fields
  auto get_uid_pair = [](const auto &field_id) {
    auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
        field_id, get_id_for_min_type<MBVERTEX>());
    auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
        field_id, get_id_for_max_type<MBENTITYSET>());
    return std::make_pair(lo_uid, hi_uid);
  };
 
  // get uids pair
  auto get_it_pair = [cmp_uid_lo, cmp_uid_hi](auto &&field_ents, auto &&p_uid) {
    auto lo = std::lower_bound(field_ents.begin(), field_ents.end(),
                               p_uid.first, cmp_uid_lo);
    auto hi = std::upper_bound(field_ents.begin(), field_ents.end(),
                               p_uid.second, cmp_uid_hi);
    return std::make_pair(lo, hi);
  };
 
  // extract DOFs for rows/columns. DOFs are associated with fields entities
  // for given problem.
  auto row_extractor = [](auto &e) { return e->entityCacheRowDofs; };
  auto col_extractor = [](auto &e) { return e->entityCacheColDofs; };
 
  auto extract_data = [](auto &&its, auto extractor) {
    std::vector<std::tuple<UId, int, int, int>> data;
    data.reserve(std::distance(its.first, its.second));
    // iterate field dofs
    for (; its.first != its.second; ++its.first) {
      if (auto e = its.first->lock()) {
        if (auto cache = extractor(e).lock()) {
          int nb_dofs = 0;
          for (auto dof = cache->loHi[0]; dof != cache->loHi[1]; ++dof) {
            if ((*dof)->getPetscGlobalDofIdx() != -1)
              ++nb_dofs;
          }
          auto uid = e->getLocalUniqueId();
          if (nb_dofs) {
 
            auto glob = (*cache->loHi[0])->getPetscGlobalDofIdx();
            auto loc = (*cache->loHi[0])->getPetscLocalDofIdx();
            while (glob == -1 && cache->loHi[0] != cache->loHi[1]) {
              ++cache->loHi[0];
              glob = (*cache->loHi[0])->getPetscGlobalDofIdx();
              loc = (*cache->loHi[0])->getPetscLocalDofIdx();
            }
            data.emplace_back(uid, glob, nb_dofs, loc);
 
#ifndef NDEBUG
 
            for (auto lo = cache->loHi[0]; lo != cache->loHi[1]; ++lo) {
              auto glob = (*lo)->getPetscGlobalDofIdx();
              if (glob == -1) {
                CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                                  "Wrong global index");
              }
            }
 
#endif
          } else {
            data.emplace_back(uid, -1, 0, -1);
          }
        }
      }
    }
    return data;
  };
 
  auto data_ptr = boost::make_shared<BlockStructure>();
  auto m_field_ptr = getInterfacePtr(dm);
 
  // create element to extract data
  auto fe_method = boost::shared_ptr<MoFEM::FEMethod>(new MoFEM::FEMethod());
 
  for (auto &d : schur_fe_op_vec) {
 
    // extract bit numbers  for row and column
    auto get_bit_numbers = [&d](auto op) {
      std::vector<FieldBitNumber> bit_numbers(d.second.size());
      std::transform(d.second.begin(), d.second.end(), bit_numbers.begin(), op);
      return bit_numbers;
    };
 
    // extract bit numbers  for row
    auto row_bit_numbers = get_bit_numbers(
        [&](auto &p) { return m_field_ptr->get_field_bit_number(p.first); });
    // extract bit numbers  for row
    auto col_bit_numbers = get_bit_numbers(
        [&](auto &p) { return m_field_ptr->get_field_bit_number(p.second); });
 
    fe_method->preProcessHook = []() { return 0; };
    fe_method->postProcessHook = []() { return 0; };
    fe_method->operatorHook = [&]() {
      MoFEMFunctionBegin;
 
      auto fe_uid = fe_method->numeredEntFiniteElementPtr->getLocalUniqueId();
 
      for (auto f = 0; f != row_bit_numbers.size(); ++f) {
 
        auto row_data =
            extract_data(get_it_pair(fe_method->getRowFieldEnts(),
                                     get_uid_pair(row_bit_numbers[f])),
                         row_extractor);
        auto col_data =
            extract_data(get_it_pair(fe_method->getColFieldEnts(),
                                     get_uid_pair(col_bit_numbers[f])),
                         col_extractor);
 
        for (auto &r : row_data) {
          auto [r_uid, r_glob, r_nb_dofs, r_loc] = r;
          for (auto &c : col_data) {
            auto [c_uid, c_glob, c_nb_dofs, c_loc] = c;
            data_ptr->blockIndex.insert(BlockStructure::Indexes{
                r_uid, c_uid, fe_uid, r_glob, c_glob, r_nb_dofs, c_nb_dofs,
                r_loc, c_loc, -1});
          }
        }
      }
 
      MoFEMFunctionReturn(0);
    };
 
    CHKERR DMoFEMLoopFiniteElementsUpAndLowRank(dm, d.first, fe_method, 0,
                                                m_field_ptr->get_comm_size());
  };
 
  // order by column (that is for matrix multiplication)
  auto mem_size = 0;
  for (auto &v : data_ptr->blockIndex.get<0>()) {
    v.getMatShift() = mem_size;
    mem_size += v.getNbCols() * v.getNbRows();
  }
 
  std::vector<double> tmp;
  if (mem_size > tmp.max_size())
    CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL, "Vector too big");
 
  data_ptr->dataBlocksPtr =
      boost::make_shared<std::vector<double>>(mem_size, 0);
 
  auto ghost_x = createDMVector(dm);
  auto ghost_y = createDMVector(dm);
  CHKERR VecSetDM(ghost_x, PETSC_NULL);
  CHKERR VecSetDM(ghost_y, PETSC_NULL);
 
  data_ptr->ghostX = ghost_x;
  data_ptr->ghostY = ghost_y;
 
  return data_ptr;
}

createDM()

auto MoFEM::createDM ( MPI_Comm  comm, const std::string  dm_type_name  )

inline

Creates smart DM object.

DM object can be used as any other object, but is destroyed as smart pointer when no longer used.

CHKERR DMRegister_MoFEM("MOFEM")
{
   auto dm = createDM(PETSC_COMM_WORLD, "MOFEM");
 
   // ...
 
   // dm is automatically destroyed when program goes out of the scope
}

Examples

elasticity.cpp, EshelbianPlasticity.cpp, free_surface.cpp, level_set.cpp, plastic.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 141 of file PetscSmartObj.hpp.

                                                                  {
  DM dm;
  CHK_THROW_MESSAGE(DMCreate(comm, &dm), "Failed to create DM");
  CHK_THROW_MESSAGE(DMSetType(dm, dm_type_name.c_str()), "Failed set DM type");
  return SmartPetscObj<DM>(dm);
};

createDMBlockMat()

auto MoFEM::createDMBlockMat ( DM  dm )

inline

Examples

plastic.cpp, and test_broken_space.cpp.

Definition at line 1076 of file DMMoFEM.hpp.

                                    {
  Mat raw_a;
  ierr = DMMoFEMCreateBlockMat(dm, &raw_a);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return SmartPetscObj<Mat>(raw_a);
};

createDMHybridisedL2Matrix()

auto MoFEM::createDMHybridisedL2Matrix ( DM  dm )

inline

Get smart hybridised L2 matrix from DM.

Parameters

dm

Returns

auto

Examples

test_broken_space.cpp.

Definition at line 1069 of file DMMoFEM.hpp.

                                              {
  SmartPetscObj<Mat> a;
  ierr = DMMoFEMCreateHybridL2Mat(dm, a);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return a;
};

createDMNestSchurMat()

auto MoFEM::createDMNestSchurMat ( DM  dm )

inline

Examples

plastic.cpp, and test_broken_space.cpp.

Definition at line 1083 of file DMMoFEM.hpp.

                                        {
  Mat raw_a;
  ierr = DMMoFEMCreateNestSchurMat(dm, &raw_a);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return SmartPetscObj<Mat>(raw_a);
};

createGhostVector()

auto MoFEM::createGhostVector ( MPI_Comm  comm, PetscInt  n, PetscInt  N, PetscInt  nghost, const PetscInt  ghosts[]  )

inline

Create smart ghost vector.

For details abut arguments see here: VecCreateGhost.

auto vec = createGhostVector(...);

Examples

ContactOps.hpp, mixed_poisson.cpp, photon_diffusion.cpp, and simple_interface.cpp.

Definition at line 179 of file PetscSmartObj.hpp.

                                                                        {
  Vec vv;
  CHK_THROW_MESSAGE(VecCreateGhost(comm, n, N, nghost, ghosts, &vv),
                    "Failed to create ghosted Vec");
  return SmartPetscObj<Vec>(vv);
};

createISGeneral()

auto MoFEM::createISGeneral ( MPI_Comm  comm, PetscInt  n, const PetscInt  idx[], PetscCopyMode  mode  )

inline

Creates a data structure for an index set containing a list of integers.

AOCreateMappingIS.

Parameters

comm	the MPI communicator
n	the length of the index set
idx	the list of integers
mode	PETSC_COPY_VALUES, PETSC_OWN_POINTER, or PETSC_USE_POINTER; see PetscCopyMode for meaning of this flag.

Returns

SmartPetscObj<IS>(is)

Definition at line 287 of file PetscSmartObj.hpp.

                                                {
  IS is;
  CHK_THROW_MESSAGE(ISCreateGeneral(comm, n, idx, mode, &is), "Create IS");
  return SmartPetscObj<IS>(is);
}

createISLocalToGlobalMapping()

auto MoFEM::createISLocalToGlobalMapping ( IS  is )

inline

Definition at line 383 of file PetscSmartObj.hpp.

                                                {
  ISLocalToGlobalMapping map_raw;
  CHK_THROW_MESSAGE(ISLocalToGlobalMappingCreateIS(is, &map_raw),
                    "create local to global mapping");
  return SmartPetscObj<ISLocalToGlobalMapping>(map_raw);
}

createKSP()

auto MoFEM::createKSP ( MPI_Comm  comm )

inline

Examples

dynamic_first_order_con_law.cpp, elasticity.cpp, free_surface.cpp, level_set.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, and schur_test_diag_mat.cpp.

Definition at line 261 of file PetscSmartObj.hpp.

                                     {
  KSP ksp;
  CHK_THROW_MESSAGE(KSPCreate(comm, &ksp), "Failed to create KSP");
  return SmartPetscObj<KSP>(ksp);
};

createOpSchurAssembleBegin()

OpSchurAssembleBase * MoFEM::createOpSchurAssembleBegin

(

)

Examples

plastic.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 2181 of file Schur.cpp.

                                                  {
  return new OpSchurAssembleBegin();
}

createOpSchurAssembleEnd() [1/3]

OpSchurAssembleBase * MoFEM::createOpSchurAssembleEnd	(	std::vector< std::string >	fields_name,
		std::vector< boost::shared_ptr< Range >>	field_ents,
		SmartPetscObj< AO >	ao = SmartPetscObj< AO >(),
		SmartPetscObj< Mat >	schur = SmartPetscObj< Mat >(),
		bool	sym_schur = false,
		bool	symm_op = false
	)

Construct a new Op Schur Assemble End object.

Parameters

fields_name	list of fields (can be empty)
field_ents	list of entities on which schur complement is applied
schur_aos	maps dofs indices from main problem to schur complement
schur_mat	schur matrix
sym_schur	true if schur (matrix) complement is symmetric
symm_op	true if block diagonal is symmetric

Examples

plastic.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 2186 of file Schur.cpp.

                                                       {
  if (symm_op)
    return new OpSchurAssembleEnd<SchurDSYSV>(fields_name, field_ents, ao,
                                              schur, sym_schur, symm_op);
  else
    return new OpSchurAssembleEnd<SchurDGESV>(fields_name, field_ents, ao,
                                              schur, sym_schur, symm_op);
}

createOpSchurAssembleEnd() [2/3]

DEPRECATED OpSchurAssembleBase * MoFEM::createOpSchurAssembleEnd	(	std::vector< std::string >	fields_name,
		std::vector< boost::shared_ptr< Range >>	field_ents,
		std::vector< SmartPetscObj< AO >>	sequence_of_aos,
		std::vector< SmartPetscObj< Mat >>	sequence_of_mats,
		std::vector< bool >	sym_schur,
		bool	symm_op,
		boost::shared_ptr< BlockStructure >	diag_blocks = nullptr
	)

Deprecated:

do not use

Definition at line 2199 of file Schur.cpp.

                                                                      {
  return createOpSchurAssembleEnd(
      fields_name, field_ents, sequence_of_aos.back(), sequence_of_mats.back(),
      sym_schur.back(), symm_op);
}

createOpSchurAssembleEnd() [3/3]

DEPRECATED OpSchurAssembleBase * MoFEM::createOpSchurAssembleEnd	(	std::vector< std::string >	fields_name,
		std::vector< boost::shared_ptr< Range >>	field_ents,
		std::vector< SmartPetscObj< AO >>	sequence_of_aos,
		std::vector< SmartPetscObj< Mat >>	sequence_of_mats,
		std::vector< bool >	sym_schur,
		std::vector< double >	diag_eps,
		bool	symm_op,
		boost::shared_ptr< BlockStructure >	diag_blocks = nullptr
	)

Deprecated:

do not use

Definition at line 2211 of file Schur.cpp.

                                                                      {
  return createOpSchurAssembleEnd(
      fields_name, field_ents, sequence_of_aos.back(), sequence_of_mats.back(),
      sym_schur.back(), symm_op);
}

createPC()

auto MoFEM::createPC ( MPI_Comm  comm )

inline

Examples

free_surface.cpp.

Definition at line 267 of file PetscSmartObj.hpp.

                                    {
  PC pc;
  CHK_THROW_MESSAGE(PCCreate(comm, &pc), "Failed to create PC");
  return SmartPetscObj<PC>(pc);
};

createPCMGSetUpViaApproxOrdersCtx()

boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx > MoFEM::createPCMGSetUpViaApproxOrdersCtx	(	DM	dm,
		Mat	A,
		bool	use_shell_mat
	)

createPCMGSetUpViaApproxOrdersCtx

Parameters

dm
A
use_shell_mat

Returns

PCMGSetUpViaApproxOrdersCtx

Examples

elasticity.cpp, and test_broken_space.cpp.

Definition at line 630 of file PCMGSetUpViaApproxOrders.cpp.

                                                                    {
  return boost::make_shared<PCMGSetUpViaApproxOrdersCtx>(dm, A, use_shell_mat);
}

createSchurNestedMatrix()

std::pair< SmartPetscObj< Mat >, boost::shared_ptr< NestSchurData > > MoFEM::createSchurNestedMatrix

(

boost::shared_ptr< NestSchurData >

schur_net_data_ptr

)

Create a Mat Diag Blocks object.

auto [nested_mat, nested_data_ptr] = createSchurNestedMatrix(
 
      createSchurNestedMatrixStruture(
 
          {schur_dm, block_dm}, shell_data,
 
          {"TENSOR"}, {nullptr}
 
      )
 
 );

Returns

Mat

Examples

schur_test_diag_mat.cpp.

Definition at line 2153 of file Schur.cpp.

                                                                           {
 
  if (!schur_net_data_ptr)
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "No data");
 
  auto [mat_arrays, data_ptrs, block_mat_data_ptr, iss] = *schur_net_data_ptr;
  auto [schur_is, block_is] = iss;
 
  std::array<IS, 2> is_a = {schur_is, block_is};
  std::array<Mat, 4> mats_a = {
 
      mat_arrays[0], mat_arrays[1], mat_arrays[2], mat_arrays[3]
 
  };
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)mat_arrays[0], &comm);
 
  Mat mat_raw;
  CHKERR MatCreateNest(
 
      comm, 2, is_a.data(), 2, is_a.data(), mats_a.data(), &mat_raw
 
  );
 
  return std::make_pair(SmartPetscObj<Mat>(mat_raw), schur_net_data_ptr);
}

createSchurNestedMatrixStruture()

boost::shared_ptr< NestSchurData > MoFEM::createSchurNestedMatrixStruture	(	std::pair< SmartPetscObj< DM >, SmartPetscObj< DM >>	dms,
		boost::shared_ptr< BlockStructure >	block_mat_data,
		std::vector< std::string >	fields_name,
		std::vector< boost::shared_ptr< Range >>	field_ents,
		bool	add_preconditioner_block = false
	)

Get the Schur Nest Mat Array object.

Parameters

dms	schur dm, and block dm
block	mat A data
fields_name	list of fields
field_ents	list of entities on which schur complement is applied
add_preconditioner_block	add block for preconditioner

Returns

boost::shared_ptr<NestSchurData>

Examples

plastic.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 1944 of file Schur.cpp.

                                   {
 
  if (!block_mat_data_ptr) {
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "Block data not set");
  }
 
  if (fields_names.size() != field_ents.size())
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                      "fields_names.size() != field_ents.size()");
 
  auto [schur_dm, block_dm] = dms;
  auto schur_prb = getProblemPtr(schur_dm);
  auto block_prb = getProblemPtr(block_dm);
  // auto m_field_ptr = getInterfacePtr(block_dm);
 
  auto schur_dofs_row = schur_prb->getNumeredRowDofsPtr();
  auto schur_dofs_col = schur_prb->getNumeredColDofsPtr();
  auto block_dofs_row = block_prb->getNumeredRowDofsPtr();
  auto block_dofs_col = block_prb->getNumeredColDofsPtr();
 
  auto ao_schur_row = schur_prb->getSubData()->getSmartRowMap();
  auto ao_schur_col = schur_prb->getSubData()->getSmartColMap();
  auto ao_block_row = block_prb->getSubData()->getSmartRowMap();
  auto ao_block_col = block_prb->getSubData()->getSmartColMap();
 
  auto schur_vec_x = createDMVector(schur_dm);
  auto block_vec_x = createDMVector(block_dm);
  auto schur_vec_y = vectorDuplicate(schur_vec_x);
  auto block_vec_y = vectorDuplicate(block_vec_x);
  CHKERR VecSetDM(schur_vec_x, PETSC_NULL);
  CHKERR VecSetDM(block_vec_x, PETSC_NULL);
  CHKERR VecSetDM(schur_vec_y, PETSC_NULL);
  CHKERR VecSetDM(block_vec_y, PETSC_NULL);
 
  auto find_field_ent = [&](auto uid, auto prb, auto rc) {
    boost::shared_ptr<NumeredDofEntity_multiIndex> dofs;
 
    switch (rc) {
    case ROW:
      dofs = prb->getNumeredRowDofsPtr();
      break;
    case COL:
      dofs = prb->getNumeredColDofsPtr();
      break;
    default:
      CHK_MOAB_THROW(MOFEM_NOT_IMPLEMENTED, "Wrong RowCol");
      break;
    }
 
    auto lo = dofs->get<Unique_mi_tag>().lower_bound(uid);
    if (lo == dofs->get<Unique_mi_tag>().end())
      return boost::shared_ptr<NumeredDofEntity>();
    auto hi = dofs->get<Unique_mi_tag>().upper_bound(
        DofEntity::getUniqueIdCalculate(MAX_DOFS_ON_ENTITY - 1, uid));
    if (lo != hi)
      return *lo;
 
    return boost::shared_ptr<NumeredDofEntity>();
  };
 
  std::array<boost::shared_ptr<BlockStructure>, 4> data_ptrs;
 
  for (auto r = 0; r != 3; ++r) {
    data_ptrs[r] = boost::make_shared<BlockStructure>();
    data_ptrs[r]->dataBlocksPtr = block_mat_data_ptr->dataBlocksPtr;
  }
  data_ptrs[3] = boost::make_shared<BlockStructure>();
  data_ptrs[3]->dataBlocksPtr = block_mat_data_ptr->dataBlocksPtr;
 
  data_ptrs[0]->ghostX = schur_vec_x;
  data_ptrs[0]->ghostY = schur_vec_y;
  data_ptrs[1]->ghostX = block_vec_x;
  data_ptrs[1]->ghostY = schur_vec_y;
  data_ptrs[2]->ghostX = schur_vec_x;
  data_ptrs[2]->ghostY = block_vec_y;
  data_ptrs[3]->ghostX = block_vec_x;
  data_ptrs[3]->ghostY = block_vec_y;
 
  int idx = 0;
  for (auto &d : block_mat_data_ptr->blockIndex.get<0>()) {
 
    auto insert = [&](auto &m, auto &dof_r, auto &dof_c, auto &d) {
      m.insert(
 
          BlockStructure::Indexes{
              d.getRowUId(), d.getColUId(), d.getFEUId(),
 
              dof_r->getPetscGlobalDofIdx(), dof_c->getPetscGlobalDofIdx(),
 
              d.getNbRows(), d.getNbCols(),
 
              dof_r->getPetscLocalDofIdx(), dof_c->getPetscLocalDofIdx(),
 
              d.getMatShift()}
 
      );
    };
 
    auto dof_schur_row = find_field_ent(d.getRowUId(), schur_prb, ROW);
    auto dof_schur_col = find_field_ent(d.getColUId(), schur_prb, COL);
    auto dof_block_row = find_field_ent(d.getRowUId(), block_prb, ROW);
    auto dof_block_col = find_field_ent(d.getColUId(), block_prb, COL);
 
    if (dof_schur_row && dof_schur_col) {
      insert(data_ptrs[0]->blockIndex, dof_schur_row, dof_schur_col, d);
    }
 
    if (dof_schur_row && dof_block_col) {
      insert(data_ptrs[1]->blockIndex, dof_schur_row, dof_block_col, d);
    }
 
    if (dof_block_row && dof_schur_col) {
      insert(data_ptrs[2]->blockIndex, dof_block_row, dof_schur_col, d);
    }
 
    if (dof_block_row && dof_block_col) {
      insert(data_ptrs[3]->blockIndex, dof_block_row, dof_block_col, d);
    }
 
    ++idx;
  }
 
  // set data for a00 solve (inverse blocks)
  auto set_up_a00_data = [&](auto inv_block_data) {
    MoFEMFunctionBegin;
 
    if (add_preconditioner_block) {
      auto preconditioned_block = boost::make_shared<std::vector<double>>(
          inv_block_data->dataBlocksPtr->size(), 0);
      inv_block_data->preconditionerBlocksPtr = preconditioned_block;
      inv_block_data->multiplyByPreconditioner = true;
      block_mat_data_ptr->preconditionerBlocksPtr =
          inv_block_data->preconditionerBlocksPtr;
      block_mat_data_ptr->multiplyByPreconditioner = false;
    }
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR set_up_a00_data(data_ptrs[3]);
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)schur_dm, &comm);
 
  auto create_shell_mat = [&](auto nb_r_loc, auto nb_c_loc, auto nb_r_glob,
                              auto nb_c_glob, auto data_ptr) {
    Mat mat_raw;
    CHKERR MatCreateShell(comm, nb_r_loc, nb_c_loc, nb_r_glob, nb_c_glob,
                          (void *)data_ptr.get(), &mat_raw);
    CHKERR setSchurBlockMatOps(mat_raw);
    return SmartPetscObj<Mat>(mat_raw);
  };
 
  auto schur_nb_global = schur_prb->getNbDofsRow();
  auto block_nb_global = block_prb->getNbDofsRow();
  auto schur_nb_local = schur_prb->getNbLocalDofsRow();
  auto block_nb_local = block_prb->getNbLocalDofsRow();
 
  std::array<SmartPetscObj<Mat>, 4> mats_array;
  mats_array[0] =
      create_shell_mat(schur_nb_local, schur_nb_local, schur_nb_global,
                       schur_nb_global, data_ptrs[0]);
  mats_array[1] =
      create_shell_mat(schur_nb_local, block_nb_local, schur_nb_global,
                       block_nb_global, data_ptrs[1]);
  mats_array[2] =
      create_shell_mat(block_nb_local, schur_nb_local, block_nb_global,
                       schur_nb_global, data_ptrs[2]);
  mats_array[3] =
      create_shell_mat(block_nb_local, block_nb_local, block_nb_global,
                       block_nb_global, data_ptrs[3]);
 
  MOFEM_TAG_AND_LOG("SYNC", Sev::verbose, "NestedSchur")
      << "(0, 0) " << schur_nb_local << " " << schur_nb_global << " "
      << data_ptrs[0]->blockIndex.size();
  MOFEM_TAG_AND_LOG("SYNC", Sev::verbose, "NestedSchur")
      << "(0, 1) " << schur_nb_local << " " << block_nb_local << " "
      << schur_nb_global << " " << block_nb_global << " "
      << data_ptrs[1]->blockIndex.size();
  MOFEM_TAG_AND_LOG("SYNC", Sev::verbose, "NestedSchur")
      << "(1, 0) " << block_nb_local << " " << schur_nb_local << " "
      << block_nb_global << " " << schur_nb_global << " "
      << data_ptrs[2]->blockIndex.size();
  MOFEM_TAG_AND_LOG("SYNC", Sev::verbose, "NestedSchur")
      << "(1, 1) " << block_nb_local << " " << block_nb_global << " "
      << data_ptrs[3]->blockIndex.size();
 
  MOFEM_LOG_SEVERITY_SYNC(comm, Sev::verbose);
 
  auto schur_is = schur_prb->getSubData()->getSmartRowIs();
  auto block_is = block_prb->getSubData()->getSmartRowIs();
 
  return boost::make_shared<NestSchurData>(
 
      mats_array, data_ptrs, block_mat_data_ptr,
      std::make_pair(schur_is, block_is)
 
  );
}

createSmartDM()

DEPRECATED auto MoFEM::createSmartDM ( MPI_Comm  comm, const std::string  dm_type_name  )

inline

Deprecated:

use createDM

Examples

mortar_contact.cpp, mortar_contact_thermal.cpp, simple_contact.cpp, simple_contact_thermal.cpp, and test_jacobian_of_simple_contact_element.cpp.

Definition at line 149 of file PetscSmartObj.hpp.

                                                                   {
  return createDM(comm, dm_type_name);
}

createSmartGhostVector()

DEPRECATED auto MoFEM::createSmartGhostVector ( MPI_Comm  comm, PetscInt  n, PetscInt  N, PetscInt  nghost, const PetscInt  ghosts[]  )

inline

Deprecated:

use createGhostVector

Definition at line 188 of file PetscSmartObj.hpp.

                                                                       {
  return createGhostVector(comm, n, N, nghost, ghosts);
}

createSmartVectorMPI()

DEPRECATED auto MoFEM::createSmartVectorMPI ( MPI_Comm  comm, PetscInt  n, PetscInt  N  )

inline

Deprecated:

use createVectorMPI

Definition at line 209 of file PetscSmartObj.hpp.

                                                        {
  return createVectorMPI(comm, n, N);
}

createSNES()

auto MoFEM::createSNES ( MPI_Comm  comm )

inline

Examples

mortar_contact.cpp, mortar_contact_thermal.cpp, simple_contact.cpp, simple_contact_thermal.cpp, and test_jacobian_of_simple_contact_element.cpp.

Definition at line 255 of file PetscSmartObj.hpp.

                                      {
  SNES snes;
  CHK_THROW_MESSAGE(SNESCreate(comm, &snes), "Failed to create SNES");
  return SmartPetscObj<SNES>(snes);
};

createTS()

auto MoFEM::createTS ( MPI_Comm  comm )

inline

Examples

ep.cpp, free_surface.cpp, and reaction_diffusion.cpp.

Definition at line 249 of file PetscSmartObj.hpp.

                                    {
  TS ts;
  CHK_THROW_MESSAGE(TSCreate(comm, &ts), "Failed to create TS");
  return SmartPetscObj<TS>(ts);
};

createVecScatter()

auto MoFEM::createVecScatter ( Vec  x, IS  ix, Vec  y, IS  iy  )

inline

Create a Vec Scatter object.

VecScatterCreate.

Parameters

x	a vector that defines the shape (parallel data layout of the vector) of vectors from which we scatter
ix	the indices of xin to scatter (if NULL scatters all values)
y	a vector that defines the shape (parallel data layout of the vector) of vectors to which we scatter
iy	the indices of yin to hold results (if NULL fills entire vector yin in order)

Returns

Examples

free_surface.cpp.

Definition at line 361 of file PetscSmartObj.hpp.

                                                         {
  VecScatter s;
  CHK_THROW_MESSAGE(VecScatterCreate(x, ix, y, iy, &s), "create scatter");
  return SmartPetscObj<VecScatter>(s);
}

createVectorMPI()

auto MoFEM::createVectorMPI ( MPI_Comm  comm, PetscInt  n, PetscInt  N  )

inline

Create MPI Vector.

For details abut arguments see here: VecCreateMPI.

Examples

adolc_plasticity.cpp, approx_sphere.cpp, child_and_parent.cpp, EshelbianPlasticity.cpp, hanging_node_approx.cpp, higher_derivatives.cpp, HookeElement.cpp, level_set.cpp, NavierStokesElement.hpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, test_broken_space.cpp, and thermo_elastic.cpp.

Definition at line 202 of file PetscSmartObj.hpp.

                                                                   {
  Vec vv;
  CHK_THROW_MESSAGE(VecCreateMPI(comm, n, N, &vv), "Failed to create Vec");
  return SmartPetscObj<Vec>(vv);
};

determinantTensor() [1/2]

template<typename T , int DIM>

static auto MoFEM::determinantTensor ( FTensor::Tensor2< T, DIM, DIM > &  t )

inlinestatic

Calculate the determinant of a tensor of rank DIM.

Examples

ContactOps.hpp.

Definition at line 1571 of file Templates.hpp.

                                                                     {
  return DeterminantTensorImpl<FTensor::Tensor2<T, DIM, DIM>, DIM>::get(t);
}

determinantTensor() [2/2]

template<typename T , int DIM>

static auto MoFEM::determinantTensor ( FTensor::Tensor2_symmetric< T, DIM > &  t )

inlinestatic

Calculate the determinant of a tensor of rank DIM.

Definition at line 1579 of file Templates.hpp.

                                                                          {
  return DeterminantTensorImpl<FTensor::Tensor2_symmetric<T, DIM>, DIM>::get(t);
}

determinantTensor2by2() [1/2]

template<typename T >

static auto MoFEM::determinantTensor2by2 ( T &  t )

inlinestatic

Calculate the determinant of a 2x2 matrix or a tensor of rank 2.

Template Parameters

T

Parameters

t

Returns

double

Definition at line 1553 of file Templates.hpp.

                                                                     {
  return t(0, 0) * t(1, 1) - t(0, 1) * t(1, 0);
}

determinantTensor2by2() [2/2]

template<class T1 , class T2 >

MoFEMErrorCode MoFEM::determinantTensor2by2 ( T1 &  t, T2 &  det  )

inline

Calculate determinant 2 by 2.

Definition at line 1618 of file Templates.hpp.

                                                            {
  MoFEMFunctionBeginHot;
  det = determinantTensor2by2(t);
  MoFEMFunctionReturnHot(0);
}

determinantTensor3by3() [1/2]

template<typename T >

static auto MoFEM::determinantTensor3by3 ( T &  t )

inlinestatic

Calculate the determinant of a 3x3 matrix or a tensor of rank 2.

Template Parameters

T

Parameters

t

Returns

double

Examples

EshelbianOperators.cpp, HookeElement.cpp, HookeElement.hpp, HookeInternalStressElement.hpp, lorentz_force.cpp, NeoHookean.hpp, Remodeling.cpp, and Remodeling.hpp.

Definition at line 1540 of file Templates.hpp.

                                                                     {
  return t(0, 0) * t(1, 1) * t(2, 2) + t(1, 0) * t(2, 1) * t(0, 2) +
         t(2, 0) * t(0, 1) * t(1, 2) - t(0, 0) * t(2, 1) * t(1, 2) -
         t(2, 0) * t(1, 1) * t(0, 2) - t(1, 0) * t(0, 1) * t(2, 2);
}

determinantTensor3by3() [2/2]

template<class T1 , class T2 >

MoFEMErrorCode MoFEM::determinantTensor3by3 ( T1 &  t, T2 &  det  )

inline

Calculate determinant 3 by 3.

Definition at line 1607 of file Templates.hpp.

                                                            {
  MoFEMFunctionBeginHot;
  det = determinantTensor3by3(t);
  MoFEMFunctionReturnHot(0);
}

dimension_from_handle()

auto MoFEM::dimension_from_handle ( const EntityHandle  h )

inline

get entity dimension form handle

Definition at line 1914 of file Templates.hpp.

                                                        {
  return moab::CN::Dimension(type_from_handle(h));
};

DMCreate_MGViaApproxOrders()

MoFEMErrorCode MoFEM::DMCreate_MGViaApproxOrders

(

DM

dm

)

Create DM data structure for Multi-Grid via approximation orders.

It set data structure and operators needed

Parameters

dm	Discrete manager

Returns

Error code

Definition at line 313 of file PCMGSetUpViaApproxOrders.cpp.

                                                 {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  if (!dm->data) {
    dm->data = new DMMGViaApproxOrdersCtx();
  } else {
    ((DMCtxImpl *)(dm->data))->incrementReference();
  }
  CHKERR DMSetOperators_MoFEM(dm);
 
  dm->ops->creatematrix = DMCreateMatrix_MGViaApproxOrders;
  dm->ops->createglobalvector = DMCreateGlobalVector_MGViaApproxOrders;
  dm->ops->coarsen = DMCoarsen_MGViaApproxOrders;
  dm->ops->createinterpolation = DMCreateInterpolation_MGViaApproxOrders;
  dm->ops->destroy = DMDestroy_MGViaApproxOrders;
 
  CHKERR DMKSPSetComputeOperators(dm, ksp_set_operators, NULL);
  PetscInfo1(dm, "Create DMMGViaApproxOrders reference = %d\n",
             ((DMCtxImpl *)(dm->data))->useCount());
  MoFEMFunctionReturn(0);
}

DMCreateGlobalVector_MGViaApproxOrders()

MoFEMErrorCode MoFEM::DMCreateGlobalVector_MGViaApproxOrders	(	DM	dm,
		Vec *	g
	)

Create global vector for DMGViaApproxOrders.

Parameters

dm	Distributed mesh data structure
g	returned pointer to vector

Returns

Error code

Definition at line 484 of file PCMGSetUpViaApproxOrders.cpp.

                                                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  int leveldown = dm->leveldown;
  GET_DM_FIELD(dm);
  if (dm_field->kspOperators.empty()) {
    CHKERR DMCreateGlobalVector_MoFEM(dm, g);
  } else {
#if PETSC_VERSION_GE(3, 5, 3)
    CHKERR MatCreateVecs(
        dm_field->kspOperators[dm_field->kspOperators.size() - 1 - leveldown],
        g, NULL);
#else
    CHKERR MatGetVecs(
        dm_field->kspOperators[dm_field->kspOperators.size() - 1 - leveldown],
        g, NULL);
#endif
    CHKERR VecSetDM(*g, dm);
  }
  PetscInfo1(dm, "Create global vector DMMGViaApproxOrders leveldown = %d\n",
             dm->leveldown);
  MoFEMFunctionReturn(0);
}

DMCreateInterpolation_MGViaApproxOrders()

MoFEMErrorCode MoFEM::DMCreateInterpolation_MGViaApproxOrders	(	DM	dm1,
		DM	dm2,
		Mat *	mat,
		Vec *	vec
	)

Create interpolation matrix between data managers dm1 and dm2.

Parameters

dm1	Distributed mesh data structure
dm2	Distributed mesh data structure
mat	Pointer to returned interpolation matrix
vec	Pointer to scaling vector here returned NULL

Returns

Error code

Definition at line 391 of file PCMGSetUpViaApproxOrders.cpp.

                                                                 {
  PetscValidHeaderSpecific(dm1, DM_CLASSID, 1);
  PetscValidHeaderSpecific(dm2, DM_CLASSID, 1);
  MoFEMFunctionBegin;
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)dm1, &comm);
 
  int m, n, M, N;
 
  DM dm_down = dm1;
  DM dm_up = dm2;
 
  int dm_down_leveldown = dm_down->leveldown;
  int dm_up_leveldown = dm_up->leveldown;
 
  PetscInfo2(dm1,
             "Create interpolation DMMGViaApproxOrders dm1_leveldown = %d "
             "dm2_leveldown = %d\n",
             dm_down_leveldown, dm_up_leveldown);
 
  IS is_down, is_up;
  {
    // Coarser mesh
    GET_DM_FIELD(dm_down);
    if (static_cast<int>(dm_field->coarseningIS.size()) < dm_down_leveldown) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
    }
    is_down = dm_field->coarseningIS[dm_field->coarseningIS.size() - 1 -
                                     dm_down_leveldown];
    CHKERR ISGetSize(is_down, &M);
    CHKERR ISGetLocalSize(is_down, &m);
  }
  {
    // Finer mesh
    GET_DM_FIELD(dm_up);
    if (static_cast<int>(dm_field->coarseningIS.size()) < dm_up_leveldown) {
      SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
    }
    is_up =
        dm_field
            ->coarseningIS[dm_field->coarseningIS.size() - 1 - dm_up_leveldown];
    CHKERR ISGetSize(is_up, &N);
    CHKERR ISGetLocalSize(is_up, &n);
  }
 
  // is_dow rows
  // is_up columns
 
  CHKERR MatCreate(comm, mat);
  CHKERR MatSetSizes(*mat, m, n, M, N);
  CHKERR MatSetType(*mat, MATMPIAIJ);
  CHKERR MatMPIAIJSetPreallocation(*mat, 1, PETSC_NULL, 0, PETSC_NULL);
 
  // get matrix layout
  PetscLayout rmap, cmap;
  CHKERR MatGetLayouts(*mat, &rmap, &cmap);
  int rstart, rend, cstart, cend;
  CHKERR PetscLayoutGetRange(rmap, &rstart, &rend);
  CHKERR PetscLayoutGetRange(cmap, &cstart, &cend);
 
  const int *row_indices_ptr, *col_indices_ptr;
  CHKERR ISGetIndices(is_down, &row_indices_ptr);
  CHKERR ISGetIndices(is_up, &col_indices_ptr);
 
  map<int, int> idx_map;
  for (int ii = 0; ii < m; ii++) {
    idx_map[row_indices_ptr[ii]] = rstart + ii;
  }
 
  CHKERR MatZeroEntries(*mat);
  // FIXME: Use MatCreateMPIAIJWithArrays and set array directly
  for (int jj = 0; jj < n; jj++) {
    map<int, int>::iterator mit = idx_map.find(col_indices_ptr[jj]);
    if (mit != idx_map.end()) {
      CHKERR MatSetValue(*mat, mit->second, cstart + jj, 1, INSERT_VALUES);
    }
  }
 
  CHKERR ISRestoreIndices(is_down, &row_indices_ptr);
  CHKERR ISRestoreIndices(is_up, &col_indices_ptr);
 
  CHKERR MatAssemblyBegin(*mat, MAT_FINAL_ASSEMBLY);
  CHKERR MatAssemblyEnd(*mat, MAT_FINAL_ASSEMBLY);
 
  if (vec != NULL) {
    *vec = PETSC_NULL;
  }
 
  MoFEMFunctionReturn(0);
}

DMDestroy_MGViaApproxOrders()

PetscErrorCode MoFEM::DMDestroy_MGViaApproxOrders

(

DM

dm

)

Destroy DM.

Parameters

dm

Returns

* PetscErrorCode

Definition at line 335 of file PCMGSetUpViaApproxOrders.cpp.

                                                  {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  GET_DM_FIELD(dm);
  MoFEMFunctionBeginHot;
  CHKERR dm_field->destroyCoarseningIS();
  CHKERR DMDestroy_MoFEM(dm);
  MoFEMFunctionReturnHot(0);
}

DMMGViaApproxOrdersSetAO()

MoFEMErrorCode MoFEM::DMMGViaApproxOrdersSetAO	(	DM	dm,
		AO	ao
	)

Set DM ordering.

AO will transform indices from coarseningIS ordering to ordering used to construct fine matrix.

Parameters

dm	[description]
ao	[description]

Returns

[description]

Definition at line 219 of file PCMGSetUpViaApproxOrders.cpp.

                                                      {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  GET_DM_FIELD(dm);
  dm_field->aO = SmartPetscObj<AO>(ao, true);
  MoFEMFunctionReturn(0);
}

DMMoFEMAddSubFieldCol() [1/3]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldCol	(	DM	dm,
		const char	field_name[],
		boost::shared_ptr< Range >	r_ptr
	)

Add field to sub dm problem on columns.

Parameters

dm
field_name
range	of entities

Returns

PetscErrorCode

Definition at line 300 of file DMMoFEM.cpp.

                                                                   {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (!dm->data) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "data structure for MoFEM not yet created");
  }
  if (!dm_field->isSubDM) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
  }
  dm_field->colSubFields.push_back(field_name);
  dm_field->mapTypeCol[field_name] = r_ptr;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMAddSubFieldCol() [2/3]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldCol	(	DM	dm,
		std::string	field_name
	)

Add field to sub dm problem on columns

Definition at line 296 of file DMMoFEM.cpp.

                                                                  {
  return DMMoFEMAddSubFieldCol(dm, field_name.c_str());
}

DMMoFEMAddSubFieldCol() [3/3]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldCol	(	DM	dm,
		std::string	field_name,
		boost::shared_ptr< Range >	r_ptr
	)

Add field to sub dm problem on columns.

Parameters

dm
field_name
range	of entities

Returns

PetscErrorCode

Definition at line 317 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMAddSubFieldCol(dm, field_name.c_str(), r_ptr);
}

DMMoFEMAddSubFieldRow() [1/2]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldRow	(	DM	dm,
		std::string	field_name
	)

Add field to sub dm problem on rows

Definition at line 254 of file DMMoFEM.cpp.

                                                                  {
  return DMMoFEMAddSubFieldRow(dm, field_name.c_str());
}

DMMoFEMAddSubFieldRow() [2/2]

PetscErrorCode MoFEM::DMMoFEMAddSubFieldRow	(	DM	dm,
		std::string	field_name,
		boost::shared_ptr< Range >	r_ptr
	)

Add field to sub dm problem on rows.

Parameters

dm
field_name
m

Returns

PetscErrorCode

Definition at line 275 of file DMMoFEM.cpp.

                                                                   {
  return DMMoFEMAddSubFieldRow(dm, field_name.c_str(), r_ptr);
}

DMMoFEMCreateHybridL2Mat()

MoFEMErrorCode MoFEM::DMMoFEMCreateHybridL2Mat	(	DM	dm,
		SmartPetscObj< Mat > &	mat
	)

Create matrix for hybridised system.

Parameters

dm
mat

Returns

MoFEMErrorCode

Definition at line 1582 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  auto matrix_mng = dm_field->mField_ptr->getInterface<MatrixManager>();
  CHKERR matrix_mng->createHybridL2MPIAIJ<PetscGlobalIdx_mi_tag>(
      dm_field->problemName, mat);
  MoFEMFunctionReturn(0);
}

DMMoFEMCreateNestSchurMat()

MoFEMErrorCode MoFEM::DMMoFEMCreateNestSchurMat	(	DM	dm,
		Mat *	mat
	)

Create nest schur matrix.

Parameters

dm
mat

Returns

MoFEMErrorCode

Definition at line 1572 of file DMMoFEM.cpp.

                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  auto mat_data = createSchurNestedMatrix(dm_field->nestedSchurDataPtr);
  *mat = mat_data.first;
  CHKERR PetscObjectReference((PetscObject)(*mat));
  MoFEMFunctionReturn(0);
}

DMMoFEMDuplicateDMCtx()

PetscErrorCode MoFEM::DMMoFEMDuplicateDMCtx	(	DM	dm,
		DM	dm_duplicate
	)

Duplicate internal data struture.

Parameters

dm
dm_duplicate

Returns

PetscErrorCode

Definition at line 180 of file DMMoFEM.cpp.

                                                             {
  MoFEMFunctionBegin;
 
  if (!dm->data)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data structure for MoFEM not yet created");
 
  if (static_cast<DMCtxImpl *>(dm_duplicate->data)->referenceNumber == 0)
    delete static_cast<DMCtxImpl *>(dm_duplicate->data);
 
  dm_duplicate->data = dm->data;
  ++(static_cast<DMCtxImpl *>(dm_duplicate->data)->referenceNumber);
 
  MoFEMFunctionReturn(0);
}

DMMoFEMGetBlocMatData()

MoFEMErrorCode MoFEM::DMMoFEMGetBlocMatData	(	DM	dm,
		boost::shared_ptr< BlockStructure > &	data
	)

Get data for block mat.

Parameters

dm

Returns

MoFEMErrorCode

Examples

test_broken_space.cpp.

Definition at line 1542 of file DMMoFEM.cpp.

                                                                            {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  data = dm_field->blocMatDataPtr;
  MoFEMFunctionReturn(0);
}

DMMoFEMGetDestroyProblem()

PetscErrorCode MoFEM::DMMoFEMGetDestroyProblem	(	DM	dm,
		PetscBool *	destroy_problem
	)

Get if problem will be destroyed with DM

Parameters

dm	the DM object
destroy	return if PETSC_TRUE problem is destroyed

Returns

error code

Definition at line 447 of file DMMoFEM.cpp.

                                                                           {
  MoFEMFunctionBeginHot;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  *destroy_problem = dm_field->destroyProblem;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMGetSubColIS()

PetscErrorCode MoFEM::DMMoFEMGetSubColIS	(	DM	dm,
		IS *	is
	)

get sub problem is

Parameters

dm	has to be created with DMMoFEMSetSquareProblem
is	return is on the row

Returns

error code

Returns IS with global indices of the DM used to create SubDM

Definition at line 349 of file DMMoFEM.cpp.

                                                 {
  MoFEMFunctionBegin;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (dm_field->isSubDM != PETSC_TRUE) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "This DM is not created as a SubDM");
  }
  if (dm_field->isProblemBuild != PETSC_TRUE) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Problem is not build");
  }
  boost::shared_ptr<Problem::SubProblemData> sub_data =
      dm_field->problemPtr->getSubData();
  CHKERR sub_data->getColIs(is);
  MoFEMFunctionReturn(0);
}

DMMoFEMGetSubRowIS()

PetscErrorCode MoFEM::DMMoFEMGetSubRowIS	(	DM	dm,
		IS *	is
	)

get sub problem is

Parameters

dm	has to be created with DMMoFEMSetSquareProblem
is	return is on the row

Returns

error code

Returns IS with global indices of the DM used to create SubDM

Examples

analytical_poisson_field_split.cpp.

Definition at line 331 of file DMMoFEM.cpp.

                                                 {
  MoFEMFunctionBegin;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (dm_field->isSubDM != PETSC_TRUE) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
            "This DM is not created as a SubDM");
  }
  if (dm_field->isProblemBuild != PETSC_TRUE) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Problem is not build");
  }
  boost::shared_ptr<Problem::SubProblemData> sub_data =
      dm_field->problemPtr->getSubData();
  CHKERR sub_data->getRowIs(is);
  MoFEMFunctionReturn(0);
}

DMMoFEMKSPSetComputeOperators()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMKSPSetComputeOperators ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 659 of file DMMoFEM.cpp.

                                                                               {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->kspCtx->getPreProcSetOperators().push_back(pre_only);
  }
  if (method) {
    dm_field->kspCtx->getSetOperators().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->kspCtx->getPostProcSetOperators().push_back(post_only);
  }
  CHKERR DMKSPSetComputeOperators(dm, KspMat, dm_field->kspCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMKSPSetComputeRHS()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMKSPSetComputeRHS ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 618 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->kspCtx->getPreProcComputeRhs().push_back(pre_only);
  }
  if (method) {
    dm_field->kspCtx->getComputeRhs().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->kspCtx->getPostProcComputeRhs().push_back(post_only);
  }
  CHKERR DMKSPSetComputeRHS(dm, KspRhs, dm_field->kspCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMSetBlocMatData()

MoFEMErrorCode MoFEM::DMMoFEMSetBlocMatData	(	DM	dm,
		boost::shared_ptr< BlockStructure >	data
	)

Set data for block mat.

Note

You can reset data by setting nullptr

Examples

schur_test_diag_mat.cpp.

Definition at line 1533 of file DMMoFEM.cpp.

                                                                           {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->blocMatDataPtr = data;
  MoFEMFunctionReturn(0);
}

DMMoFEMSetDestroyProblem()

PetscErrorCode MoFEM::DMMoFEMSetDestroyProblem	(	DM	dm,
		PetscBool	destroy_problem
	)

If this is set to PETSC_TRUE problem is deleted with DM

Parameters

dm	the DM object
destroy	if PETSC_TRUE problem is destroyed

Returns

error code

Examples

EshelbianPlasticity.cpp, free_surface.cpp, and level_set.cpp.

Definition at line 438 of file DMMoFEM.cpp.

                                                                          {
  MoFEMFunctionBeginHot;
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->destroyProblem = destroy_problem;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSetNestSchurData() [1/2]

template<>

MoFEMErrorCode MoFEM::DMMoFEMSetNestSchurData	(	DM	dm,
		boost::shared_ptr< NestSchurData >	data
	)

Examples

plastic.cpp, and test_broken_space.cpp.

Definition at line 1562 of file DMMoFEM.cpp.

                                                                            {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->nestedSchurDataPtr = data;
  dm_field->blocMatDataPtr = get<2>(*(data));
  MoFEMFunctionReturn(0);
}

DMMoFEMSetNestSchurData() [2/2]

template<typename T >

MoFEMErrorCode MoFEM::DMMoFEMSetNestSchurData	(	DM	dm,
		boost::shared_ptr< T >
	)

Set data for nest schur (see specialisation in Schur.hpp)

Note

You can reset data by setting nullptr

Template Parameters

T	= NestSchurData

Parameters

dm

Returns

MoFEMErrorCode

DMMoFEMSetVerbosity()

PetscErrorCode MoFEM::DMMoFEMSetVerbosity	(	DM	dm,
		const int	verb
	)

Set verbosity level.

Parameters

dm
verb	see VERBOSITY_LEVELS for list of the levels

Returns

PetscErrorCode

Definition at line 1525 of file DMMoFEM.cpp.

                                                          {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBeginHot;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  dm_field->verbosity = verb;
  MoFEMFunctionReturnHot(0);
}

DMMoFEMSNESSetFunction()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMSNESSetFunction ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 699 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->snesCtx->getPreProcComputeRhs().push_back(pre_only);
  }
  if (method) {
    dm_field->snesCtx->getComputeRhs().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->snesCtx->getPostProcComputeRhs().push_back(post_only);
  }
  CHKERR DMSNESSetFunction(dm, SnesRhs, dm_field->snesCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMSNESSetJacobian()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMSNESSetJacobian ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 740 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->snesCtx->getPreProcSetOperators().push_back(pre_only);
  }
  if (method) {
    dm_field->snesCtx->getSetOperators().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->snesCtx->getPostProcSetOperators().push_back(post_only);
  }
  CHKERR DMSNESSetJacobian(dm, SnesMat, dm_field->snesCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMSwapDMCtx()

PetscErrorCode MoFEM::DMMoFEMSwapDMCtx	(	DM	dm,
		DM	dm_swap
	)

Swap internal data struture.

Parameters

dm
dm_swap

Returns

PetscErrorCode

Definition at line 196 of file DMMoFEM.cpp.

                                                   {
  MoFEMFunctionBegin;
  if (!dm->data)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data structure for MoFEM not yet created on dm");
  if (!dm_swap->data)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "data structure for MoFEM not yet created on swap dm");
 
  auto *dm_field = static_cast<DMCtxImpl *>(dm->data);
  auto *dm_field_swap = static_cast<DMCtxImpl *>(dm_swap->data);
 
  auto tmp_field = dm_field;
  dm_field = dm_field_swap;
  dm_field_swap = tmp_field;
 
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetI2Function()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetI2Function ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 945 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->tsCtx->getPreProcessIFunction().push_back(pre_only);
  }
  if (method) {
    dm_field->tsCtx->getLoopsIFunction().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->tsCtx->getPostProcessIFunction().push_back(post_only);
  }
  CHKERR DMTSSetI2Function(dm, TsSetI2Function, dm_field->tsCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetI2Jacobian()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetI2Jacobian ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 988 of file DMMoFEM.cpp.

                                                                        {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->tsCtx->getPreProcessIJacobian().push_back(pre_only);
  }
  if (method) {
    dm_field->tsCtx->getLoopsIJacobian().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->tsCtx->getPostProcessIJacobian().push_back(post_only);
  }
  CHKERR DMTSSetI2Jacobian(dm, TsSetI2Jacobian, dm_field->tsCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetIFunction()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetIFunction ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 781 of file DMMoFEM.cpp.

                                                                       {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->tsCtx->getPreProcessIFunction().push_back(pre_only);
  }
  if (method) {
    dm_field->tsCtx->getLoopsIFunction().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->tsCtx->getPostProcessIFunction().push_back(post_only);
  }
  CHKERR DMTSSetIFunction(dm, TsSetIFunction, dm_field->tsCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetIJacobian()

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetIJacobian ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 824 of file DMMoFEM.cpp.

                                                                       {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only) {
    dm_field->tsCtx->getPreProcessIJacobian().push_back(pre_only);
  }
  if (method) {
    dm_field->tsCtx->getLoopsIJacobian().push_back(
        PairNameFEMethodPtr(fe_name, method));
  }
  if (post_only) {
    dm_field->tsCtx->getPostProcessIJacobian().push_back(post_only);
  }
  CHKERR DMTSSetIJacobian(dm, TsSetIJacobian, dm_field->tsCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetMonitor() [1/3]

PetscErrorCode MoFEM::DMMoFEMTSSetMonitor	(	DM	dm,
		TS	ts,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only
	)

Set Monitor To TS solver.

See PETSc documentaton here

Parameters

dm
ts	time solver
fe_name
method
pre_only
post_only

Returns

PetscErrorCod

Definition at line 1045 of file DMMoFEM.cpp.

                                                                {
  return DMMoFEMTSSetMonitor<const char *, MoFEM::FEMethod *,
                             MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, ts, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetMonitor() [2/3]

PetscErrorCode MoFEM::DMMoFEMTSSetMonitor	(	DM	dm,
		TS	ts,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only
	)

Set Monitor To TS solver.

See PETSc documentaton here

Parameters

dm
ts	time solver
fe_name
method
pre_only
post_only

Returns

PetscErrorCod

Examples

adolc_plasticity.cpp, dynamic_first_order_con_law.cpp, free_surface.cpp, heat_equation.cpp, level_set.cpp, photon_diffusion.cpp, plastic.cpp, reaction_diffusion.cpp, seepage.cpp, shallow_wave.cpp, thermo_elastic.cpp, and wave_equation.cpp.

Definition at line 1056 of file DMMoFEM.cpp.

                                                                 {
  return DMMoFEMTSSetMonitor<const std::string,
                             boost::shared_ptr<MoFEM::FEMethod>,
                             boost::shared_ptr<MoFEM::BasicMethod>,
                             boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, ts, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetMonitor() [3/3]

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetMonitor ( DM  dm, TS  ts, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 1029 of file DMMoFEM.cpp.

                                                                     {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only)
    dm_field->tsCtx->getPreProcessMonitor().push_back(pre_only);
  if (method)
    dm_field->tsCtx->getLoopsMonitor().push_back(
        PairNameFEMethodPtr(fe_name, method));
  if (post_only)
    dm_field->tsCtx->getPostProcessMonitor().push_back(post_only);
  CHKERR TSMonitorSet(ts, TsMonitorSet, dm_field->tsCtx.get(), PETSC_NULL);
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetRHSFunction() [1/3]

PetscErrorCode MoFEM::DMMoFEMTSSetRHSFunction	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only
	)

Definition at line 894 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMTSSetRHSFunction<const char *, MoFEM::FEMethod *,
                                 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetRHSFunction() [2/3]

PetscErrorCode MoFEM::DMMoFEMTSSetRHSFunction	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only
	)

set TS the right hand side function

See petsc documentation

Parameters

dm
fe_name
method
pre_only
post_only

Returns

PetscErrorCode

Examples

NonlinearElasticElementInterface.hpp, and reaction_diffusion.cpp.

Definition at line 882 of file DMMoFEM.cpp.

                                                                     {
  return DMMoFEMTSSetRHSFunction<const std::string,
                                 boost::shared_ptr<MoFEM::FEMethod>,
                                 boost::shared_ptr<MoFEM::BasicMethod>,
                                 boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetRHSFunction() [3/3]

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetRHSFunction ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 865 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only)
    dm_field->tsCtx->getPreProcessRHSFunction().push_back(pre_only);
  if (method)
    dm_field->tsCtx->getLoopsRHSFunction().push_back(
        PairNameFEMethodPtr(fe_name, method));
  if (post_only)
    dm_field->tsCtx->getPostProcessRHSFunction().push_back(post_only);
  CHKERR DMTSSetRHSFunction(dm, TsSetRHSFunction, dm_field->tsCtx.get());
  MoFEMFunctionReturn(0);
}

DMMoFEMTSSetRHSJacobian() [1/3]

PetscErrorCode MoFEM::DMMoFEMTSSetRHSJacobian	(	DM	dm,
		const char	fe_name[],
		MoFEM::FEMethod *	method,
		MoFEM::BasicMethod *	pre_only,
		MoFEM::BasicMethod *	post_only
	)

Definition at line 934 of file DMMoFEM.cpp.

                                                                    {
  return DMMoFEMTSSetRHSJacobian<const char *, MoFEM::FEMethod *,
                                 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetRHSJacobian() [2/3]

PetscErrorCode MoFEM::DMMoFEMTSSetRHSJacobian	(	DM	dm,
		const std::string	fe_name,
		boost::shared_ptr< MoFEM::FEMethod >	method,
		boost::shared_ptr< MoFEM::BasicMethod >	pre_only,
		boost::shared_ptr< MoFEM::BasicMethod >	post_only
	)

set TS the right hand side jacobian

See petsc documentation

Parameters

dm
fe_name
method
pre_only
post_only

Returns

PetscErrorCode

Examples

NonlinearElasticElementInterface.hpp.

Definition at line 922 of file DMMoFEM.cpp.

                                                                     {
  return DMMoFEMTSSetRHSJacobian<const std::string,
                                 boost::shared_ptr<MoFEM::FEMethod>,
                                 boost::shared_ptr<MoFEM::BasicMethod>,
                                 boost::shared_ptr<MoFEM::BasicMethod>>(
      dm, fe_name, method, pre_only, post_only);
  MoFEMFunctionReturnHot(0);
}

DMMoFEMTSSetRHSJacobian() [3/3]

template<class S , class T0 , class T1 , class T2 >

static PetscErrorCode MoFEM::DMMoFEMTSSetRHSJacobian ( DM  dm, S  fe_name, T0  method, T1  pre_only, T2  post_only  )

static

Definition at line 905 of file DMMoFEM.cpp.

                                                                         {
  PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
  MoFEMFunctionBegin;
  DMCtxImpl *dm_field = static_cast<DMCtxImpl *>(dm->data);
  if (pre_only)
    dm_field->tsCtx->getPreProcessRHSFunction().push_back(pre_only);
  if (method)
    dm_field->tsCtx->getLoopsRHSFunction().push_back(
        PairNameFEMethodPtr(fe_name, method));
  if (post_only)
    dm_field->tsCtx->getPostProcessRHSFunction().push_back(post_only);
  CHKERR DMTSSetRHSJacobian(dm, TsSetRHSJacobian, dm_field->tsCtx.get());
  MoFEMFunctionReturn(0);
}

ent_form_type_and_id()

auto MoFEM::ent_form_type_and_id ( const EntityType  type, const EntityID  id  )

inline

get entity handle from type and id

Definition at line 1906 of file Templates.hpp.

                                                                           {
  return (static_cast<EntityHandle>(type) << MB_ID_WIDTH) | id;
};

field_bit_from_bit_number()

auto MoFEM::field_bit_from_bit_number ( const int  bit_number )

inline

get field bit id from bit number

Definition at line 1930 of file Templates.hpp.

                                                            {
  return BitFieldId().set(bit_number - 1);
};

get_cache_data_dofs_view()

template<typename ENTSVIEW , typename DOFSVIEW , typename EXTRACTOR , typename INSERTER >

static MoFEMErrorCode MoFEM::get_cache_data_dofs_view ( ENTSVIEW &  ents_view, DOFSVIEW &  dofs_view, EXTRACTOR &&  extractor, INSERTER &&  inserter  )

inlinestatic

Definition at line 495 of file FEMultiIndices.cpp.

                                                                     {
  MoFEMFunctionBeginHot;
 
  auto hint = dofs_view->end();
  using ValType = typename std::remove_reference<decltype(**hint)>::type;
 
  for (auto &it : *ents_view) {
    if (auto e = it.lock()) {
 
      if (auto cache = extractor(e).lock())
        for (auto dit = cache->loHi[0]; dit != cache->loHi[1]; ++dit)
          hint = inserter(dofs_view, hint,
                          boost::reinterpret_pointer_cast<ValType>(*dit));
      else
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Cache not set");
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

get_event_options_imp() [1/2]

template<class T >

static auto MoFEM::get_event_options_imp ( T *const  ptr, int    ) -> decltype(ptr->getEventOptions())

static

Definition at line 151 of file Core.cpp.

                                        {
  return ptr->getEventptions();
};

get_event_options_imp() [2/2]

template<class T >

static auto MoFEM::get_event_options_imp ( T *const  ptr, long    ) -> MoFEMErrorCode

static

Definition at line 162 of file Core.cpp.

                                                                        {
  return 0;
};

get_id_for_max_type() [1/2]

template<EntityType TYPE>

EntityHandle MoFEM::get_id_for_max_type ( )

inline

Definition at line 13 of file RefEntsMultiIndices.hpp.

                                                                     {
  return (static_cast<EntityHandle>(TYPE) << MB_ID_WIDTH) |
         (~static_cast<EntityHandle>(MB_TYPE_MASK));
};

get_id_for_max_type() [2/2]

EntityHandle MoFEM::get_id_for_max_type ( const EntityType  type )

inline

Definition at line 22 of file RefEntsMultiIndices.hpp.

                                                               {
  return (static_cast<EntityHandle>(type) << MB_ID_WIDTH) |
         (~static_cast<EntityHandle>(MB_TYPE_MASK));
};

get_id_for_min_type() [1/2]

template<EntityType TYPE>

EntityHandle MoFEM::get_id_for_min_type ( )

inline

Definition at line 18 of file RefEntsMultiIndices.hpp.

                                                                     {
  return (static_cast<EntityHandle>(TYPE) << MB_ID_WIDTH);
};

get_id_for_min_type() [2/2]

EntityHandle MoFEM::get_id_for_min_type ( const EntityType  type )

inline

Definition at line 27 of file RefEntsMultiIndices.hpp.

                                                               {
  return (static_cast<EntityHandle>(type) << MB_ID_WIDTH);
};

get_sub_iface_options_imp() [1/2]

template<class T >

static auto MoFEM::get_sub_iface_options_imp ( T *const  ptr, int    ) -> decltype(ptr->getSubInterfaceOptions())

static

Definition at line 138 of file Core.cpp.

                                               {
  return ptr->getSubInterfaceOptions();
};

get_sub_iface_options_imp() [2/2]

template<class T >

static auto MoFEM::get_sub_iface_options_imp ( T *const  ptr, long    ) -> MoFEMErrorCode

static

Definition at line 146 of file Core.cpp.

                                                                            {
  return 0;
};

get_tag_ptr()

void* MoFEM::get_tag_ptr ( moab::Interface &  moab, Tag  th, EntityHandle  ent, int *  tag_size  )

inline

Get the tag ptr object.

Parameters

moab
th
ent
tag_size

Returns

void*

Definition at line 40 of file RefEntsMultiIndices.hpp.

                                        {
  void *ret_val;
  rval = moab.tag_get_by_ptr(th, &ent, 1, (const void **)&ret_val, tag_size);
  if (rval != MB_SUCCESS) {
    if (tag_size)
      *tag_size = 0;
    return NULL;
  } else {
    return ret_val;
  }
}

get_temp_meshset_ptr()

auto MoFEM::get_temp_meshset_ptr ( moab::Interface &  moab )

inline

Create smart pointer to temporary meshset.

Examples

child_and_parent.cpp, EshelbianPlasticity.cpp, free_surface.cpp, hanging_node_approx.cpp, level_set.cpp, seepage.cpp, split_sideset.cpp, and thermo_elastic.cpp.

Definition at line 1886 of file Templates.hpp.

                                                      {
  return boost::make_shared<TempMeshset>(moab);
};

get_value()

template<class TYPE >

static MoFEMErrorCode MoFEM::get_value ( MatrixDouble &  pts_x, MatrixDouble &  pts_t, TYPE *  ctx  )

static

Definition at line 25 of file JacobiPolynomial.cpp.

                                           {
  MoFEMFunctionBeginHot;
  ctx->baseFunPtr->resize(pts_x.size2(), ctx->P + 1, false);
  ctx->baseDiffFunPtr->resize(pts_x.size2(), ctx->dIm * (ctx->P + 1), false);
  if (pts_x.size1() != pts_t.size1() || pts_x.size2() != pts_t.size2()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Inconsistent size of arguments");
  }
  double *l = NULL;
  double *diff_l = NULL;
  for (unsigned int gg = 0; gg < pts_x.size2(); gg++) {
    if (ctx->baseFunPtr)
      l = &((*ctx->baseFunPtr)(gg, 0));
    if (ctx->baseDiffFunPtr)
      diff_l = &((*ctx->baseDiffFunPtr)(gg, 0));
    ierr = (ctx->basePolynomialsType1)(ctx->P, ctx->aLpha, pts_x(0, gg),
                                       pts_t(0, gg), ctx->diffX, ctx->diffT, l,
                                       diff_l, ctx->dIm);
    CHKERRG(ierr);
  }
  MoFEMFunctionReturnHot(0);
}

getCommFromPetscObject()

MPI_Comm MoFEM::getCommFromPetscObject ( PetscObject  obj )

inline

Get the Comm From Petsc Object object.

Parameters

obj

Returns

MPI_Comm

Definition at line 160 of file PetscSmartObj.hpp.

                                                        {
  MPI_Comm comm;
  CHK_THROW_MESSAGE(PetscObjectGetComm(obj, &comm),
                    "Failed to get comm from PETSc object");
  return comm;
};

getDMKspCtx()

auto MoFEM::getDMKspCtx ( DM  dm )

inline

Get KSP context data structure used by DM.

Examples

level_set.cpp, and test_broken_space.cpp.

Definition at line 1113 of file DMMoFEM.hpp.

                               {
  boost::shared_ptr<MoFEM::KspCtx> ksp_ctx;
  ierr = DMMoFEMGetKspCtx(dm, ksp_ctx);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return ksp_ctx;
};

getDMSnesCtx()

auto MoFEM::getDMSnesCtx ( DM  dm )

inline

Get SNES context data structure used by DM.

Examples

adolc_plasticity.cpp, free_surface.cpp, plastic.cpp, seepage.cpp, and thermo_elastic.cpp.

Definition at line 1127 of file DMMoFEM.hpp.

                                {
  boost::shared_ptr<MoFEM::SnesCtx> snes_ctx;
  ierr = DMMoFEMGetSnesCtx(dm, snes_ctx);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return snes_ctx;
};

getDMSubData()

auto MoFEM::getDMSubData ( DM  dm )

inline

Get sub problem data structure.

Parameters

dm

Returns

auto

Examples

plastic.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 1157 of file DMMoFEM.hpp.

                                {
  auto prb_ptr = getProblemPtr(dm);
  return prb_ptr->getSubData();
};

getDMTsCtx()

auto MoFEM::getDMTsCtx ( DM  dm )

inline

Get TS context data structure used by DM.

Examples

adolc_plasticity.cpp, free_surface.cpp, heat_equation.cpp, plastic.cpp, and seepage.cpp.

Definition at line 1141 of file DMMoFEM.hpp.

                              {
  boost::shared_ptr<MoFEM::TsCtx> ts_ctx;
  ierr = DMMoFEMGetTsCtx(dm, ts_ctx);
  CHKERRABORT(getCommFromPetscObject(reinterpret_cast<PetscObject>(dm)), ierr);
  return ts_ctx;
};

getFTensor0FromVec()

template<int S = 1, class T , class A >

static auto MoFEM::getFTensor0FromVec ( ublas::vector< T, A > &  data )

inlinestatic

Get tensor rank 0 (scalar) form data vector.

Example how to use it.

VectorDouble vec;
vec.resize(nb_gauss_pts,false);
vec.clear();
auto t0 = getFTensor0FromData(data);
for(int gg = 0;gg!=nb_gauss_pts;gg++) {
 
  ++t0;
}

Examples

child_and_parent.cpp, ContactOps.hpp, elasticity.cpp, ElasticityMixedFormulation.hpp, EshelbianOperators.cpp, free_surface.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, higher_derivatives.cpp, HookeElement.cpp, mixed_poisson.cpp, NavierStokesElement.cpp, photon_diffusion.cpp, PlasticOpsGeneric.hpp, poisson_2d_dis_galerkin.cpp, PoissonOperators.hpp, reaction_diffusion.cpp, Remodeling.cpp, scalar_check_approximation.cpp, SeepageOps.hpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, ThermoElasticOps.hpp, and UnsaturatedFlow.hpp.

Definition at line 135 of file Templates.hpp.

                                                               {
  return GetFTensor0FromVecImpl<S, T, A>::get(data);
}

getFTensor1FromArray() [1/2]

template<int DIM, int S>

auto MoFEM::getFTensor1FromArray ( VectorDouble &  data )

inline

Get FTensor1 from array.

Todo:

Generalise for different arrays and data types

Template Parameters

DIM

Parameters

data

Returns

FTensor::Tensor1<FTensor::PackPtr<double *, S>, DIM>

Definition at line 1175 of file Templates.hpp.

                                                                               {
  return GetFTensor1FromArray<DIM, S>::get(data);
}

getFTensor1FromArray() [2/2]

template<int DIM, int S = 0>

auto MoFEM::getFTensor1FromArray ( VectorDouble3 &  data )

inline

Get FTensor1 from array.

Todo:

Generalise for different arrays and data types

Template Parameters

DIM

Parameters

data

Returns

FTensor::Tensor1<FTensor::PackPtr<double *, S>, DIM>

getFTensor1FromArray< 3, 0 >()

template<>

auto MoFEM::getFTensor1FromArray< 3, 0 > ( VectorDouble3 &  data )

inline

Definition at line 1183 of file Templates.hpp.

                                                                        {
  return GetFTensor1FromArray<3, 0>::get(data);
}

getFTensor1FromArrayDiag() [1/2]

template<int DIM, int S>

FTensor::Tensor1<FTensor::PackPtr<double *, S>, DIM> MoFEM::getFTensor1FromArrayDiag ( MatrixDouble &  data, const size_t  rr  )

inline

Get FTensor1 from array.

Todo:

Generalise for diffrent arrays and data types

Template Parameters

DIM

Parameters

data
rr

Returns

FTensor::Tensor1<FTensor::PackPtr<double *, DIM>, DIM>

Definition at line 1233 of file Templates.hpp.

                                                              {
  static_assert(DIM != DIM, "not implemented");
  return FTensor::Tensor1<FTensor::PackPtr<double *, S>, DIM>();
}

getFTensor1FromArrayDiag() [2/2]

template<>

FTensor::Tensor1< FTensor::PackPtr< double *, 3 >, 3 > MoFEM::getFTensor1FromArrayDiag ( MatrixDouble &  data, const size_t  rr  )

inline

Definition at line 1240 of file Templates.hpp.

                                                              {
  return FTensor::Tensor1<FTensor::PackPtr<double *, 2>, 2>{&data(rr + 0, 0),
                                                            &data(rr + 1, 1)};
}

getFTensor1FromMat() [1/4]

template<int Tensor_Dim, int S = 1>

auto MoFEM::getFTensor1FromMat ( MatrixDouble &  data )

inline

Get tensor rank 1 (vector) form data matrix (specialization)

Definition at line 246 of file Templates.hpp.

                                                   {
  return GetFTensor1FromMatImpl<Tensor_Dim, S, double, ublas::row_major,
                                DoubleAllocator>::get(data);
}

getFTensor1FromMat() [2/4]

template<int DIM, int S>

FTensor::Tensor1<FTensor::PackPtr<double *, S>, DIM> MoFEM::getFTensor1FromMat ( MatrixDouble &  data, const size_t  rr  )

inline

Definition at line 1193 of file Templates.hpp.

                                                        {
  return FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 2>{&data(rr + 0, 0),
                                                            &data(rr + 1, 0)};
}

getFTensor1FromMat() [3/4]

template<>

FTensor::Tensor1< FTensor::PackPtr< double *, 1 >, 9 > MoFEM::getFTensor1FromMat ( MatrixDouble &  data, const size_t  rr  )

inline

Definition at line 1193 of file Templates.hpp.

                                                        {
  return FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 2>{&data(rr + 0, 0),
                                                            &data(rr + 1, 0)};
}

getFTensor1FromMat() [4/4]

template<int Tensor_Dim, int S = 1, class T , class L , class A >

FTensor::Tensor1<FTensor::PackPtr<T *, S>, Tensor_Dim> MoFEM::getFTensor1FromMat ( ublas::matrix< T, L, A > &  data )

inline

Get tensor rank 1 (vector) form data matrix.

Definition at line 238 of file Templates.hpp.

                                               {
  static_assert(!std::is_same<T, T>::value, "not implemented");
}

getFTensor1FromPtr() [1/3]

template<int DIM, int S = DIM>

FTensor::Tensor1<FTensor::PackPtr<adouble *, S>, DIM> MoFEM::getFTensor1FromPtr ( adouble *  ptr )

inline

Definition at line 845 of file Templates.hpp.

                                 {
  return GetFTensor1FromPtrImpl<DIM, S, adouble>::get(ptr);
};

getFTensor1FromPtr() [2/3]

template<int DIM, int S = DIM>

FTensor::Tensor1<FTensor::PackPtr<double *, S>, DIM> MoFEM::getFTensor1FromPtr ( double *  ptr )

inline

Make Tensor1 from pointer.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, 3 * DIM>, 3, DIM>

Definition at line 838 of file Templates.hpp.

                                {
  return GetFTensor1FromPtrImpl<DIM, S, double>::get(ptr);
};

getFTensor1FromPtr() [3/3]

template<int DIM, int S = DIM>

FTensor::Tensor1<FTensor::PackPtr<std::complex<double> *, S>, DIM> MoFEM::getFTensor1FromPtr ( std::complex< double > *  ptr )

inline

Definition at line 852 of file Templates.hpp.

                                            {
  return GetFTensor1FromPtrImpl<DIM, S, std::complex<double>>::get(ptr);
};

getFTensor2FromArray() [1/3]

template<int DIM1, int DIM2, int S>

auto MoFEM::getFTensor2FromArray ( MatrixADouble &  data, const size_t  rr  )

inline

Definition at line 1351 of file Templates.hpp.

                                                                       {
  return GetFTensor2FromArrayImpl<DIM1, DIM2, S, adouble, ublas::row_major,
                                  VecAllocator<adouble>>::get(data, rr);
}

getFTensor2FromArray() [2/3]

template<int DIM1, int DIM2>

FTensor::Tensor2<double *, DIM1, DIM2> MoFEM::getFTensor2FromArray ( MatrixDouble &  data, const size_t  rr, const size_t  cc, const int  ss  )

inline

Definition at line 1327 of file Templates.hpp.

                                   {
  return GetFTensor2FromArrayRawPtrImpl<DIM1, DIM2, double, ublas::row_major,
                                        VecAllocator<double>>::get(data, rr, cc,
                                                                   ss);
}

getFTensor2FromArray() [3/3]

template<int DIM1, int DIM2, int S>

FTensor::Tensor2<FTensor::PackPtr<double *, S>, DIM1, DIM2> MoFEM::getFTensor2FromArray ( MatrixDouble &  data, const size_t  rr, const size_t  cc = 0  )

inline

Definition at line 1320 of file Templates.hpp.

                                                                               {
  return GetFTensor2FromArrayImpl<DIM1, DIM2, S, double, ublas::row_major,
                                  VecAllocator<double>>::get(data, rr, cc);
}

getFTensor2FromArray2by2()

template<int S, typename T , typename L , typename A >

auto MoFEM::getFTensor2FromArray2by2 ( ublas::matrix< T, L, A > &  data, const FTensor::Number< S > &  , const size_t  rr, const size_t  cc = 0  )

inline

Definition at line 1335 of file Templates.hpp.

                                                                           {
  return GetFTensor2FromArrayImpl<2, 2, S, T, L, A>::get(data, rr, cc);
}

getFTensor2FromArray3by3()

template<int S, typename T , typename L , typename A >

auto MoFEM::getFTensor2FromArray3by3 ( ublas::matrix< T, L, A > &  data, const FTensor::Number< S > &  , const size_t  rr, const size_t  cc = 0  )

inline

Definition at line 1342 of file Templates.hpp.

                                                                           {
  return GetFTensor2FromArrayImpl<3, 3, S, T, L, A>::get(data, rr, cc);
}

getFTensor2FromMat()

template<int Tensor_Dim1, int Tensor_Dim2>

FTensor::Tensor2<FTensor::PackPtr<double *, 1>, Tensor_Dim1, Tensor_Dim2> MoFEM::getFTensor2FromMat ( MatrixDouble &  data )

inline

Get tensor rank 2 (matrix) form data matrix.

Definition at line 278 of file Templates.hpp.

                                       {
  return GetFTensor2FromMatImpl<Tensor_Dim1, Tensor_Dim2, 1, double,
                                ublas::row_major, DoubleAllocator>::get(data);
}

getFTensor2FromPtr() [1/2]

template<int DIM1, int DIM2, int S = DIM1 * DIM2>

auto MoFEM::getFTensor2FromPtr ( double *  ptr )

inline

Make Tensor2 from pointer.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, S>, DIM1, DIM2>

Definition at line 925 of file Templates.hpp.

                                            {
  return GetFTensor2FromPtr<DIM1, DIM2, S, double>::get(ptr);
};

getFTensor2FromPtr() [2/2]

template<int DIM1, int DIM2, int S = DIM1 * DIM2>

auto MoFEM::getFTensor2FromPtr ( std::complex< double > *  ptr )

inline

Make Tensor2 from pointer.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, S>, DIM1, DIM2>

Definition at line 937 of file Templates.hpp.

                                                        {
  return GetFTensor2FromPtr<DIM1, DIM2, S, std::complex<double>>::get(ptr);
};

getFTensor2FromVec() [1/2]

template<int Tensor_Dim1, int Tensor_Dim2>

FTensor::Tensor2<FTensor::PackPtr<double *, 1>, Tensor_Dim1, Tensor_Dim2> MoFEM::getFTensor2FromVec ( VectorDouble &  data )

inline

Template specialization for getFTensor2FromMat

Definition at line 292 of file Templates.hpp.

                                       {
  return FTensor::Tensor2<FTensor::PackPtr<double *, 1>, 1, 1>(&*data.begin());
}

getFTensor2FromVec() [2/2]

template<>

FTensor::Tensor2<FTensor::PackPtr<double *, 1>, 1, 1> MoFEM::getFTensor2FromVec ( VectorDouble &  data )

inline

Template specialization for getFTensor2FromMat

Definition at line 292 of file Templates.hpp.

                                       {
  return FTensor::Tensor2<FTensor::PackPtr<double *, 1>, 1, 1>(&*data.begin());
}

getFTensor2HVecFromPtr()

template<int DIM1, int DIM2>

FTensor::Tensor2<FTensor::PackPtr<double *, DIM1 * DIM2>, DIM1, DIM2> MoFEM::getFTensor2HVecFromPtr ( double *  ptr )

inline

Make Tensor2 for HVec base from pointer.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, DIM1 * DIM2>, DIM1, DIM2>

Definition at line 950 of file Templates.hpp.

                                    {
  static_assert(DIM1 == DIM1 || DIM2 != DIM2,
                "Such getFTensor2HVecFromPtr is not implemented");
};

getFTensor2HVecFromPtr< 3, 2 >()

template<>

FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2> MoFEM::getFTensor2HVecFromPtr< 3, 2 > ( double *  ptr )

inline

Definition at line 957 of file Templates.hpp.

                                                                     {
  return FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
      ptr + HVEC0_0, ptr + HVEC0_1,
 
      ptr + HVEC1_0, ptr + HVEC1_1,
 
      ptr + HVEC2_0, ptr + HVEC2_1);
};

getFTensor2HVecFromPtr< 3, 3 >()

template<>

FTensor::Tensor2<FTensor::PackPtr<double *, 9>, 3, 3> MoFEM::getFTensor2HVecFromPtr< 3, 3 > ( double *  ptr )

inline

Definition at line 968 of file Templates.hpp.

                                                                     {
  return FTensor::Tensor2<FTensor::PackPtr<double *, 9>, 3, 3>(
      ptr + HVEC0_0, ptr + HVEC0_1, ptr + HVEC0_2,
 
      ptr + HVEC1_0, ptr + HVEC1_1, ptr + HVEC1_2,
 
      ptr + HVEC2_0, ptr + HVEC2_1, ptr + HVEC2_2);
};

getFTensor2SymmetricFromMat() [1/2]

template<int Tensor_Dim, int S = 1>

static auto MoFEM::getFTensor2SymmetricFromMat ( MatrixDouble &  data )

inlinestatic

Definition at line 339 of file Templates.hpp.

                                                                   {
  return getFTensor2SymmetricFromMat<Tensor_Dim, S, double, ublas::row_major,
                                     DoubleAllocator>(data);
}

getFTensor2SymmetricFromMat() [2/2]

template<int Tensor_Dim, int S, class T , class L , class A >

static auto MoFEM::getFTensor2SymmetricFromMat ( ublas::matrix< T, L, A > &  data )

inlinestatic

Get symmetric tensor rank 2 (matrix) form data matrix.

Definition at line 334 of file Templates.hpp.

                                                                           {
  return GetFTensor2SymmetricFromMatImpl<Tensor_Dim, S, T, L, A>::get(data);
}

getFTensor2SymmetricFromPtr() [1/2]

template<int DIM>

FTensor::Tensor2_symmetric< FTensor::PackPtr<adouble *, (DIM * (DIM + 1)) / 2>, DIM> MoFEM::getFTensor2SymmetricFromPtr ( adouble *  ptr )

inline

Make symmetric Tensor2 from pointer.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, DIM1 * DIM2>, DIM1, DIM2>

Definition at line 1055 of file Templates.hpp.

                                          {
  static_assert(DIM, "Such getFTensor2SymmetricFromPtr is not implemented");
}

getFTensor2SymmetricFromPtr() [2/2]

template<int DIM>

FTensor::Tensor2_symmetric< FTensor::PackPtr<double *, (DIM * (DIM + 1)) / 2>, DIM> MoFEM::getFTensor2SymmetricFromPtr ( double *  ptr )

inline

Make symmetric Tensor2 from pointer.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, DIM1 * DIM2>, DIM1, DIM2>

Definition at line 1021 of file Templates.hpp.

                                         {
  static_assert(DIM, "Such getFTensor2SymmetricFromPtr is not implemented");
}

getFTensor2SymmetricFromPtr< 2 >() [1/2]

template<>

FTensor::Tensor2_symmetric<FTensor::PackPtr<adouble *, 3>, 2> MoFEM::getFTensor2SymmetricFromPtr< 2 > ( adouble *  ptr )

inline

Definition at line 1072 of file Templates.hpp.

                                             {
  return FTensor::Tensor2_symmetric<FTensor::PackPtr<adouble *, 3>, 2>(
      ptr + 0, ptr + 1, ptr + 2);
};

getFTensor2SymmetricFromPtr< 2 >() [2/2]

template<>

FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 3>, 2> MoFEM::getFTensor2SymmetricFromPtr< 2 > ( double *  ptr )

inline

Definition at line 1038 of file Templates.hpp.

                                            {
  return FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 3>, 2>(
      &ptr[0], &ptr[1], &ptr[2]);
};

getFTensor2SymmetricFromPtr< 3 >() [1/2]

template<>

FTensor::Tensor2_symmetric<FTensor::PackPtr<adouble *, 6>, 3> MoFEM::getFTensor2SymmetricFromPtr< 3 > ( adouble *  ptr )

inline

Definition at line 1061 of file Templates.hpp.

                                             {
  return FTensor::Tensor2_symmetric<FTensor::PackPtr<adouble *, 6>, 3>(
      ptr + 0, ptr + 1, ptr + 2,
 
      ptr + 3, ptr + 4,
 
      ptr + 5);
};

getFTensor2SymmetricFromPtr< 3 >() [2/2]

template<>

FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 6>, 3> MoFEM::getFTensor2SymmetricFromPtr< 3 > ( double *  ptr )

inline

Definition at line 1027 of file Templates.hpp.

                                            {
  return FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 6>, 3>(
      ptr + 0, ptr + 1, ptr + 2,
 
      ptr + 3, ptr + 4,
 
      ptr + 5);
};

getFTensor2SymmetricLowerFromPtr()

template<int DIM>

FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, DIM * DIM>, DIM> MoFEM::getFTensor2SymmetricLowerFromPtr ( double *  ptr )

inline

Make symmetric Tensor2 from pointer, taking lower triangle of matrix.

Template Parameters

DIM

Parameters

ptr

Returns

FTensor::Tensor2<FTensor::PackPtr<double *, DIM1 * DIM2>, DIM1, DIM2>

Definition at line 1088 of file Templates.hpp.

                                              {
  static_assert(DIM,
                "Such getFTensor2SymmetricLowerFromPtr is not implemented");
}

getFTensor2SymmetricLowerFromPtr< 2 >()

template<>

FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 4>, 2> MoFEM::getFTensor2SymmetricLowerFromPtr< 2 > ( double *  ptr )

inline

Examples

plate.cpp.

Definition at line 1106 of file Templates.hpp.

                                                 {
  return FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 4>, 2>(
      ptr + 0, ptr + 1, ptr + 3);
};

getFTensor2SymmetricLowerFromPtr< 3 >()

template<>

FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 9>, 3> MoFEM::getFTensor2SymmetricLowerFromPtr< 3 > ( double *  ptr )

inline

Definition at line 1095 of file Templates.hpp.

                                                 {
  return FTensor::Tensor2_symmetric<FTensor::PackPtr<double *, 9>, 3>(
      ptr + HVEC0_0, ptr + HVEC0_1, ptr + HVEC0_2,
 
      ptr + HVEC1_0, ptr + HVEC1_1,
 
      ptr + HVEC2_2);
};

getFTensor3DgFromMat() [1/2]

template<int Tensor_Dim01, int Tensor_Dim2, int S = 1>

static auto MoFEM::getFTensor3DgFromMat ( MatrixDouble &  data )

inlinestatic

Definition at line 526 of file Templates.hpp.

                                                            {
  return GetFTensor3DgFromMatImpl<Tensor_Dim01, Tensor_Dim2, S, double,
                                  ublas::row_major, DoubleAllocator>::get(data);
}

getFTensor3DgFromMat() [2/2]

template<int Tensor_Dim01, int Tensor_Dim2, int S = 1, class T , class L , class A >

static FTensor::Dg<FTensor::PackPtr<T *, 1>, Tensor_Dim01, Tensor_Dim2> MoFEM::getFTensor3DgFromMat ( ublas::matrix< T, L, A > &  data )

inlinestatic

Get symmetric tensor rank 3 on the first two indices from form data matrix.

Template Parameters

Tensor_Dim01	dimension of first two indicies
Tensor_Dim2	dimension of last index
T	the type of object stored
L	the storage organization
A	the type of Storage array

Parameters

data	data container

Returns

FTensor::Dg<FTensor::PackPtr<T *, 1>, Tensor_Dim01, TensorDim23>

Definition at line 520 of file Templates.hpp.

                                                 {
  static_assert(!std::is_same<T, T>::value,
                "Such getFTensor3DgFromMat specialisation is not implemented");
}

getFTensor3FromMat() [1/2]

template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int S = 1>

static auto MoFEM::getFTensor3FromMat ( MatrixDouble &  data )

inlinestatic

Definition at line 782 of file Templates.hpp.

                                                          {
  return GetFTensor3FromMatImpl<Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, S,
                                double, ublas::row_major,
                                DoubleAllocator>::get(data);
}

getFTensor3FromMat() [2/2]

template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int S = 1, class T , class L , class A >

static FTensor::Tensor3<FTensor::PackPtr<T *, 1>, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2> MoFEM::getFTensor3FromMat ( ublas::matrix< T, L, A > &  data )

inlinestatic

Get tensor rank 3 (non symmetries) form data matrix.

Template Parameters

Tensor_Dim0	dimension of first index
Tensor_Dim1	dimension of second index
Tensor_Dim2	dimension of third index
S	shift size
T	the type of object stored
L	the storage organization
A	the type of Storage array

Parameters

data	data container

Returns

FTensor::Tensor3<FTensor::PackPtr<T *, 1>, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2>

Definition at line 776 of file Templates.hpp.

                                               {
  static_assert(!std::is_same<T, T>::value,
                "Such getFTensor3FromMat specialisation is not implemented");
}

getFTensor3FromPtr()

template<int DIM1, int DIM2, int DIM3>

FTensor::Tensor3<FTensor::PackPtr<double *, DIM1 * DIM2 * DIM3>, DIM1, DIM2, DIM3> MoFEM::getFTensor3FromPtr ( double *  ptr )

inline

Definition at line 988 of file Templates.hpp.

                                {
  static_assert(DIM1 == DIM1 || DIM2 != DIM2 || DIM3 != DIM3,
                "Such getFTensor3FromPtr is not implemented");
};

getFTensor3FromPtr< 3, 2, 2 >()

template<>

FTensor::Tensor3<FTensor::PackPtr<double *, 12>, 3, 2, 2> MoFEM::getFTensor3FromPtr< 3, 2, 2 > ( double *  ptr )

inline

Definition at line 995 of file Templates.hpp.

                                         {
  return FTensor::Tensor3<FTensor::PackPtr<double *, 12>, 3, 2, 2>(
      ptr + 0, ptr + 1, ptr + 2, ptr + 3, ptr + 4, ptr + 5, ptr + 6, ptr + 7,
      ptr + 8, ptr + 9, ptr + 10, ptr + 11);
};

getFTensor3FromPtr< 3, 3, 3 >()

template<>

FTensor::Tensor3<FTensor::PackPtr<double *, 27>, 3, 3, 3> MoFEM::getFTensor3FromPtr< 3, 3, 3 > ( double *  ptr )

inline

Definition at line 1003 of file Templates.hpp.

                                         {
  return FTensor::Tensor3<FTensor::PackPtr<double *, 27>, 3, 3, 3>(
      ptr + 0, ptr + 1, ptr + 2, ptr + 3, ptr + 4, ptr + 5, ptr + 6, ptr + 7,
      ptr + 8, ptr + 9, ptr + 10, ptr + 11, ptr + 12, ptr + 13, ptr + 14,
      ptr + 15, ptr + 16, ptr + 17, ptr + 18, ptr + 19, ptr + 20, ptr + 21,
      ptr + 22, ptr + 23, ptr + 24, ptr + 25, ptr + 26);
};

getFTensor4DdgFromMat() [1/2]

template<int Tensor_Dim01, int Tensor_Dim23, int S = 1>

static auto MoFEM::getFTensor4DdgFromMat ( MatrixDouble &  data )

inlinestatic

Definition at line 424 of file Templates.hpp.

                                                             {
  return GetFTensor4DdgFromMatImpl<Tensor_Dim01, Tensor_Dim23, S, double,
                                   ublas::row_major,
                                   DoubleAllocator>::get(data);
}

getFTensor4DdgFromMat() [2/2]

template<int Tensor_Dim01, int Tensor_Dim23, int S = 1, class T , class L , class A >

static FTensor::Ddg<FTensor::PackPtr<T *, 1>, Tensor_Dim01, Tensor_Dim23> MoFEM::getFTensor4DdgFromMat ( ublas::matrix< T, L, A > &  data )

inlinestatic

Get symmetric tensor rank 4 on first two and last indices from form data matrix.

Template Parameters

Tensor_Dim01	dimension of first two indicies
Tensor_Dim23	dimension of second two indicies
Memory	shift
T	the type of object stored
L	the storage organization
A	the type of Storage array

Parameters

data	data container

Returns

FTensor::Ddg<FTensor::PackPtr<T *, 1>, Tensor_Dim01, TensorDim23>

Definition at line 418 of file Templates.hpp.

                                                  {
  static_assert(!std::is_same<T, T>::value,
                "Such getFTensor4DdgFromMat specialisation is not implemented");
}

getFTensor4DdgFromPtr()

template<int Tensor_Dim01, int Tensor_Dim23, int S = 1, class T = double>

static auto MoFEM::getFTensor4DdgFromPtr ( T *  ptr )

inlinestatic

Definition at line 447 of file Templates.hpp.

                                                 {
  return GetFTensor4DdgFromPtrImpl<Tensor_Dim01, Tensor_Dim23, S, T>::get(ptr);
}

getFTensor4FromMat() [1/2]

template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3, int S = 1>

static auto MoFEM::getFTensor4FromMat ( MatrixDouble &  data )

inlinestatic

Definition at line 627 of file Templates.hpp.

                                                          {
  return GetFTensor4FromMatImpl<Tensor_Dim0, Tensor_Dim1, Tensor_Dim2,
                                Tensor_Dim3, S, double, ublas::row_major,
                                DoubleAllocator>::get(data);
}

getFTensor4FromMat() [2/2]

template<int Tensor_Dim0, int Tensor_Dim1, int Tensor_Dim2, int Tensor_Dim3, int S = 1, class T , class L , class A >

static FTensor::Tensor4<FTensor::PackPtr<T *, 1>, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3> MoFEM::getFTensor4FromMat ( ublas::matrix< T, L, A > &  data )

inlinestatic

Get tensor rank 4 (non symmetric) form data matrix.

Template Parameters

Tensor_Dim0	dimension of frirst index
Tensor_Dim1	dimension of second index
Tensor_Dim2	dimension of third index
Tensor_Dim3	dimension of fourth index
T	the type of object stored
L	the storage organization
A	the type of Storage array

Parameters

data	data container

Returns

FTensor::Tensor4<FTensor::PackPtr<T *, 1>, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3>

Definition at line 620 of file Templates.hpp.

                                               {
  static_assert(!std::is_same<T, T>::value,
                "Such getFTensor4FromMat specialisation is not implemented");
}

getInterfacePtr()

auto MoFEM::getInterfacePtr ( DM  dm )

inline

Get the Interface Ptr object.

Parameters

dm

Returns

auto

Definition at line 1033 of file DMMoFEM.hpp.

                                   {
  MoFEM::Interface *m_field_ptr;
  CHK_THROW_MESSAGE(DMoFEMGetInterfacePtr(dm, &m_field_ptr),
                    "Can not get interface ptr from DM");
  return m_field_ptr;
};

getLocalCoordinatesOnReferenceThreeNodeTriImpl()

template<typename T1 , typename T2 >

MoFEMErrorCode MoFEM::getLocalCoordinatesOnReferenceThreeNodeTriImpl	(	const T1 *	elem_coords,
		const T2 *	global_coords,
		const int	nb_nodes,
		typename FTensor::promote< T1, T2 >::V *	local_coords
	)

Definition at line 141 of file Tools.cpp.

                                                    {
 
  FTensor::Index<'i', 3> i3;
  FTensor::Index<'j', 3> j3;
  FTensor::Index<'K', 2> K2;
  FTensor::Index<'L', 2> L2;
  MoFEMFunctionBeginHot;
 
  FTensor::Tensor1<const double, 3> t_n = {Tools::shapeFunMBTRIAt00[0],
                                           Tools::shapeFunMBTRIAt00[1],
                                           Tools::shapeFunMBTRIAt00[2]};
  auto t_diff = getFTensor2FromPtr<3, 2>(
      const_cast<double *>(Tools::diffShapeFunMBTRI.data()));
  auto t_elem_coords = getFTensor2FromPtr<3, 3>(const_cast<T1 *>(elem_coords));
 
  // Build matrix and get coordinates of zero point
  FTensor::Tensor2<T1, 2, 3> t_a;
  t_a(K2, i3) = t_diff(j3, K2) * t_elem_coords(j3, i3);
  FTensor::Tensor2_symmetric<T1, 2> t_b, t_inv_b;
  t_b(K2, L2) = t_a(K2, j3) ^ t_a(L2, j3);
  // Solve problem
  const auto inv_det = 1. / (t_b(0, 0) * t_b(1, 1) - t_b(0, 1) * t_b(1, 0));
  t_inv_b(0, 0) = t_b(1, 1) * inv_det;
  t_inv_b(0, 1) = -t_b(0, 1) * inv_det;
  t_inv_b(1, 1) = t_b(0, 0) * inv_det;
 
  // Coords at corner
  FTensor::Tensor1<T1, 3> t_coords_at_0;
  t_coords_at_0(i3) = t_n(j3) * t_elem_coords(j3, i3);
 
  auto t_global_coords = getFTensor1FromPtr<3>(const_cast<T2 *>(global_coords));
  auto t_local_coords = getFTensor1FromPtr<2>(local_coords);
 
  // Calculate right hand side
  for (int ii = 0; ii != nb_nodes; ++ii) {
    t_local_coords(L2) =
        t_inv_b(L2, K2) *
        (t_a(K2, j3) * (t_global_coords(j3) - t_coords_at_0(j3)));
    ++t_local_coords;
    ++t_global_coords;
  }
 
  MoFEMFunctionReturnHot(0);
}

getMatrixAdaptor()

template<typename T1 >

auto MoFEM::getMatrixAdaptor ( T1  ptr, const size_t  n, const size_t  m  )

inline

Get Matrix adaptor.

double *a;
CHKERR VecGetArray(v,&a);
 
for(int n = 0; n != nodes; ++n) {
 
  auto F = getMatrixAdaptor(&a[3*3*n], 3, 3);
  MatrixDouble C = prod(F, trans(F));
 
}
 
CHKERR VecRetsoreArray(v,&a);

Examples

field_evaluator.cpp.

Definition at line 57 of file Templates.hpp.

                                                                     {
  typedef typename std::remove_pointer<T1>::type T;
  return MatrixShallowArrayAdaptor<T>(
      n, m, ublas::shallow_array_adaptor<T>(n * m, ptr));
};

getMaxOrder()

template<typename ENTMULTIINDEX >

static int MoFEM::getMaxOrder ( const ENTMULTIINDEX &  multi_index )

inlinestatic

Definition at line 110 of file ForcesAndSourcesCore.cpp.

                                                                {
  int max_order = 0;
  for (auto ent_field_weak_ptr : multi_index)
    if (auto e = ent_field_weak_ptr.lock()) {
      const int order = e->getMaxOrder();
      max_order = (max_order < order) ? order : max_order;
    }
  return max_order;
}

getNestSchurData()

DEPRECATED boost::shared_ptr<NestSchurData> MoFEM::getNestSchurData ( std::pair< SmartPetscObj< DM >, SmartPetscObj< DM >>  dms, boost::shared_ptr< BlockStructure >  block_mat_data, std::vector< std::string >  fields_name, std::vector< boost::shared_ptr< Range >>  field_ents, bool  add_preconditioner_block = false  )

inline

Deprecated:

do not use, use createSchurNestedMatrixStruture instead

Definition at line 355 of file Schur.hpp.

  {
  return createSchurNestedMatrixStruture(dms, block_mat_data, fields_name,
                                         field_ents, add_preconditioner_block);
}

getPetscObject()

template<typename T >

PetscObject MoFEM::getPetscObject ( T  obj )

inline

Examples

free_surface.cpp.

Definition at line 9 of file PetscSmartObj.hpp.

                                                               {
  return reinterpret_cast<PetscObject>(obj);
}

getProblemPtr()

auto MoFEM::getProblemPtr ( DM  dm )

inline

get problem pointer from DM

Examples

free_surface.cpp, and level_set.cpp.

Definition at line 1044 of file DMMoFEM.hpp.

                                 {
  const MoFEM::Problem *problem_ptr;
  CHK_THROW_MESSAGE(DMMoFEMGetProblemPtr(dm, &problem_ptr),
                    "Get cot get problem ptr from DM");
  return problem_ptr;
};

getVectorAdaptor()

template<typename T1 >

auto MoFEM::getVectorAdaptor ( T1  ptr, const size_t  n  )

inline

Get Vector adaptor.

double *a;
CHKERR VecGetArray(v,&a);
 
for(int n = 0; n != nodes; ++n) {
 
  auto a = getVectorAdaptor(&a[3*n], 3);
  double dot = inner_prod(a, a);
 
}
 
CHKERR VecRetsoreArray(v,&a);

Examples

ADOLCPlasticity.hpp, and bernstein_bezier_generate_base.cpp.

Definition at line 31 of file Templates.hpp.

                                                                            {
  typedef typename std::remove_pointer<T1>::type T;
  return VectorShallowArrayAdaptor<T>(n,
                                      ublas::shallow_array_adaptor<T>(n, ptr));
};

Hcurl_Ainsworth_BubbleFaceFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_AINSWORTH_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 545 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  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_AINSWORTH_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];
      CHKERR base_polynomials(p[ff], ksi_0i, &t_diff_ksi0i(0), psi_l_0i,
                              diff_psi_l_0i, 3);
 
      const double ksi_0j = N[node_shift + n2] - N[node_shift + n0];
      CHKERR base_polynomials(p[ff], ksi_0j, &t_diff_ksi0j(0), psi_l_0j,
                              diff_psi_l_0j, 3);
 
      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_AINSWORTH_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);
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_BubbleFaceFunctions_MBTET_ON_FACE()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_AINSWORTH_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 663 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  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_AINSWORTH_FACE_HCURL(p) == 0)
    MoFEMFunctionReturnHot(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<FTensor::PackPtr<double *, 6>, 3, 2> t_diff_phi_f(
      &diff_phi_f[HVEC0_0], &diff_phi_f[HVEC0_1], &diff_phi_f[HVEC1_0],
      &diff_phi_f[HVEC1_1], &diff_phi_f[HVEC2_0], &diff_phi_f[HVEC2_1]);
 
  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];
    CHKERR base_polynomials(p, ksi_0i, diff_ksi_0i, psi_l_0i, diff_psi_l_0i, 2);
 
    const double ksi_0j = N[node_shift + node2] - N[node_shift + node0];
    CHKERR base_polynomials(p, ksi_0j, diff_ksi_0j, psi_l_0j, diff_psi_l_0j, 2);
 
    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_AINSWORTH_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);
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_EdgeBasedFaceFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_AINSWORTH_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 363 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
  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_AINSWORTH_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];
        CHKERR base_polynomials(p[ff], ksi_0i, &t_edge_diff_ksi(0), psi_l,
                                diff_psi_l, 3);
 
        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;
        }
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_EdgeBasedFaceFunctions_MBTET_ON_FACE()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_AINSWORTH_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 458 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  const int nb_base_fun_on_face = NBFACETRI_AINSWORTH_EDGE_HCURL(p);
  if (nb_base_fun_on_face == 0)
    MoFEMFunctionReturnHot(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][HVEC0], &phi_f_e[0][HVEC1],
                                    &phi_f_e[0][HVEC2], 3),
      FTensor::Tensor1<double *, 3>(&phi_f_e[1][HVEC0], &phi_f_e[1][HVEC1],
                                    &phi_f_e[1][HVEC2], 3),
      FTensor::Tensor1<double *, 3>(&phi_f_e[2][HVEC0], &phi_f_e[2][HVEC1],
                                    &phi_f_e[2][HVEC2], 3),
  };
  FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>
      t_diff_face_edge_base[3] = {
          FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
              &diff_phi_f_e[0][HVEC0_0], &diff_phi_f_e[0][HVEC0_1],
              &diff_phi_f_e[0][HVEC1_0], &diff_phi_f_e[0][HVEC1_1],
              &diff_phi_f_e[0][HVEC2_0], &diff_phi_f_e[0][HVEC2_1]),
          FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
              &diff_phi_f_e[1][HVEC0_0], &diff_phi_f_e[1][HVEC0_1],
              &diff_phi_f_e[1][HVEC1_0], &diff_phi_f_e[1][HVEC1_1],
              &diff_phi_f_e[1][HVEC2_0], &diff_phi_f_e[1][HVEC2_1]),
          FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
              &diff_phi_f_e[2][HVEC0_0], &diff_phi_f_e[2][HVEC0_1],
              &diff_phi_f_e[2][HVEC1_0], &diff_phi_f_e[2][HVEC1_1],
              &diff_phi_f_e[2][HVEC2_0], &diff_phi_f_e[2][HVEC2_1])};
 
  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;
      CHKERR base_polynomials(p, ksi_0i, diff_ksi0i, psi_l, diff_psi_l, 2);
 
      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;
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_EdgeBaseFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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 [3].

On each tetrahedral's edge we have P+1 functions. See NBEDGE_AINSWORTH_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 16 of file Hcurl.cpp.

                                                       {
  MoFEMFunctionBeginHot;
 
  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_AINSWORTH_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];
        CHKERR base_polynomials(p[ee], ksi_0i, &edge_diff_ksi[ee][0], psi_l,
                                diff_psi_l, 3);
 
        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]);
        }
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_EdgeBaseFunctions_MBTET_ON_EDGE()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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 [3].

On each edge we have P+1 functions. See NBEDGE_AINSWORTH_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 175 of file Hcurl.cpp.

                                                       {
  MoFEMFunctionBegin;
 
  if (NBEDGE_AINSWORTH_HCURL(p) == 0)
    MoFEMFunctionReturnHot(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<FTensor::PackPtr<double *, 3>, 3> t_edge_n(
      &edge_n[0], &edge_n[1], &edge_n[2]);
  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];
      CHKERR base_polynomials(p, ksi_0i, NULL, psi_l, NULL, 3);
 
      for (int ll = 2; ll != NBEDGE_AINSWORTH_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;
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}

Hcurl_Ainsworth_EdgeBaseFunctions_MBTET_ON_FACE()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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 [3].

On each face's edge we have P+1 functions. See NBEDGE_AINSWORTH_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 237 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  // 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_AINSWORTH_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<FTensor::PackPtr<double *, 6>, 3, 2> t_diff_edge_n[3] = {
      FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
          &diff_edge_n[0][HVEC0_0], &diff_edge_n[0][HVEC0_1],
          &diff_edge_n[0][HVEC1_0], &diff_edge_n[0][HVEC1_1],
          &diff_edge_n[0][HVEC2_0], &diff_edge_n[0][HVEC2_1]),
      FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
          &diff_edge_n[1][HVEC0_0], &diff_edge_n[1][HVEC0_1],
          &diff_edge_n[1][HVEC1_0], &diff_edge_n[1][HVEC1_1],
          &diff_edge_n[1][HVEC2_0], &diff_edge_n[1][HVEC2_1]),
      FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
          &diff_edge_n[2][HVEC0_0], &diff_edge_n[2][HVEC0_1],
          &diff_edge_n[2][HVEC1_0], &diff_edge_n[2][HVEC1_1],
          &diff_edge_n[2][HVEC2_0], &diff_edge_n[2][HVEC2_1])};
 
  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];
        CHKERR
        base_polynomials(p[ee], ksi_0i, diff_ksi_0i, psi_l, diff_psi_l, 2);
 
        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;
        }
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_FaceFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_Ainsworth_EdgeBasedFaceFunctions_MBTET) and Bubble-Face functions (Hcurl_Ainsworth_BubbleFaceFunctions_MBTET).

See NBVOLUMETET_AINSWORTH_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 1052 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  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_AINSWORTH_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_AINSWORTH_EDGE_HCURL(p[ff]) * nb_integration_pts);
        diff_base_face_edge_functions[ff].resize(
            3, 9 * NBFACETRI_AINSWORTH_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);
        }
      }
    }
    CHKERR Hcurl_Ainsworth_EdgeBasedFaceFunctions_MBTET(
        face_nodes, p, N, diffN, phi_f_e, diff_phi_f_e, nb_integration_pts,
        base_polynomials);
 
    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_AINSWORTH_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();
      }
    }
    CHKERR Hcurl_Ainsworth_BubbleFaceFunctions_MBTET(
        face_nodes, p, N, diffN, phi_f_f, diff_phi_f_f, nb_integration_pts,
        base_polynomials);
 
    FTensor::Index<'i', 3> i;
    FTensor::Index<'j', 3> j;
 
    for (int ff = 0; ff != 4; ff++) {
 
      if (NBFACETRI_AINSWORTH_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_AINSWORTH_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_AINSWORTH_EDGE_HCURL(oo - 1);
                     ll != NBFACETRI_AINSWORTH_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_AINSWORTH_EDGE_HCURL(oo) << endl;
                }
              }
            }
            // Face-face base
            if (oo > 2) {
              for (int ll = NBFACETRI_AINSWORTH_FACE_HCURL(oo - 1);
                   ll != NBFACETRI_AINSWORTH_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_AINSWORTH_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_AINSWORTH_EDGE_HCURL(oo - 1);
                     ll != NBFACETRI_AINSWORTH_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_AINSWORTH_EDGE_HCURL(oo) << endl;
                }
              }
            }
          }
          // check consistency
          const int nb_base_fun_on_face = NBFACETRI_AINSWORTH_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());
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_FaceFunctions_MBTET_ON_FACE()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_Ainsworth_EdgeBasedFaceFunctions_MBTET) and Bubble-Face functions (Hcurl_Ainsworth_BubbleFaceFunctions_MBTET).

See NBVOLUMETET_AINSWORTH_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 1249 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  if (NBFACETRI_AINSWORTH_EDGE_HCURL(p) == 0)
    MoFEMFunctionReturnHot(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_AINSWORTH_EDGE_HCURL(p) *
                                         nb_integration_pts);
  diff_base_face_edge_functions.resize(
      3, 2 * 3 * NBFACETRI_AINSWORTH_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);
  }
  CHKERR Hcurl_Ainsworth_EdgeBasedFaceFunctions_MBTET_ON_FACE(
      faces_nodes, p, N, diffN, phi_f_e, diff_phi_f_e, nb_integration_pts,
      base_polynomials);
 
  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_AINSWORTH_FACE_HCURL(p) *
                                    nb_integration_pts);
  diff_base_face_bubble_functions.resize(
      2 * 3 * NBFACETRI_AINSWORTH_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();
  CHKERR Hcurl_Ainsworth_BubbleFaceFunctions_MBTET_ON_FACE(
      faces_nodes, p, N, diffN, phi_f_f, diff_phi_f_f, nb_integration_pts,
      base_polynomials);
 
  // 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][HVEC0], &phi_f_e[0][HVEC1],
                                    &phi_f_e[0][HVEC2], 3),
      FTensor::Tensor1<double *, 3>(&phi_f_e[1][HVEC0], &phi_f_e[1][HVEC1],
                                    &phi_f_e[1][HVEC2], 3),
      FTensor::Tensor1<double *, 3>(&phi_f_e[2][HVEC0], &phi_f_e[2][HVEC1],
                                    &phi_f_e[2][HVEC2], 3)};
  FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>
      t_diff_face_edge_base[] = {
          FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
              &diff_phi_f_e[0][HVEC0_0], &diff_phi_f_e[0][HVEC0_1],
              &diff_phi_f_e[0][HVEC1_0], &diff_phi_f_e[0][HVEC1_1],
              &diff_phi_f_e[0][HVEC2_0], &diff_phi_f_e[0][HVEC2_1]),
          FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
              &diff_phi_f_e[1][HVEC0_0], &diff_phi_f_e[1][HVEC0_1],
              &diff_phi_f_e[1][HVEC1_0], &diff_phi_f_e[1][HVEC1_1],
              &diff_phi_f_e[1][HVEC2_0], &diff_phi_f_e[1][HVEC2_1]),
          FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2>(
              &diff_phi_f_e[2][HVEC0_0], &diff_phi_f_e[2][HVEC0_1],
              &diff_phi_f_e[2][HVEC1_0], &diff_phi_f_e[2][HVEC1_1],
              &diff_phi_f_e[2][HVEC2_0], &diff_phi_f_e[2][HVEC2_1])};
 
  FTensor::Tensor1<double *, 3> t_face_base(&phi_f[0], &phi_f[1], &phi_f[2], 3);
  FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2> t_diff_face_base(
      &diff_phi_f[HVEC0_0], &diff_phi_f[HVEC0_1], &diff_phi_f[HVEC1_0],
      &diff_phi_f[HVEC1_1], &diff_phi_f[HVEC2_0], &diff_phi_f[HVEC2_1]);
 
  if (NBFACETRI_AINSWORTH_FACE_HCURL(p) > 0) {
    FTensor::Tensor1<double *, 3> t_face_face_base(
        &phi_f_f[HVEC0], &phi_f_f[HVEC1], &phi_f_f[HVEC2], 3);
    FTensor::Tensor2<FTensor::PackPtr<double *, 6>, 3, 2> t_diff_face_face_base(
        &diff_phi_f_f[HVEC0_0], &diff_phi_f_f[HVEC0_1], &diff_phi_f_f[HVEC1_0],
        &diff_phi_f_f[HVEC1_1], &diff_phi_f_f[HVEC2_0], &diff_phi_f_f[HVEC2_1]);
    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_AINSWORTH_EDGE_HCURL(oo - 1);
                 ll != NBFACETRI_AINSWORTH_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_AINSWORTH_FACE_HCURL(oo - 1);
               ll != NBFACETRI_AINSWORTH_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_AINSWORTH_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_AINSWORTH_EDGE_HCURL(oo - 1);
                 ll != NBFACETRI_AINSWORTH_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_AINSWORTH_EDGE_HCURL(oo) << endl;
            }
          }
        }
      }
      // check consistency
      const int nb_base_fun_on_face = NBFACETRI_AINSWORTH_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);
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_FaceInteriorFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_AINSWORTH_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 775 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  if (NBVOLUMETET_AINSWORTH_FACE_HCURL(p) == 0)
    MoFEMFunctionReturnHot(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]];
      CHKERR base_polynomials(p, ksi_0i, &t_diff_ksi0i(0), psi_l_0i[ff],
                              diff_psi_l_0i[ff], 3);
 
      const double ksi_0j = N[node_shift + faces_nodes[3 * ff + 2]] -
                            N[node_shift + faces_nodes[3 * ff + 0]];
      CHKERR base_polynomials(p, ksi_0j, &t_diff_ksi0j(0), psi_l_0j[ff],
                              diff_psi_l_0j[ff], 3);
    }
 
    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_AINSWORTH_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);
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_VolumeFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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 1403 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  VectorDouble base_face_inetrior_functions(
      3 * NBVOLUMETET_AINSWORTH_FACE_HCURL(p) * nb_integration_pts);
  VectorDouble diff_base_face_inetrior_functions(
      9 * NBVOLUMETET_AINSWORTH_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};
  CHKERR Hcurl_Ainsworth_FaceInteriorFunctions_MBTET(
      faces_nodes, p, N, diffN, phi_v_f, diff_phi_v_f, nb_integration_pts,
      base_polynomials);
 
  VectorDouble base_interior_functions(3 * NBVOLUMETET_AINSWORTH_TET_HCURL(p) *
                                       nb_integration_pts);
  VectorDouble diff_base_interior_functions(
      9 * NBVOLUMETET_AINSWORTH_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();
  CHKERR Hcurl_Ainsworth_VolumeInteriorFunctions_MBTET(
      p, N, diffN, phi_v_v, diff_phi_v_v, nb_integration_pts, base_polynomials);
 
  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_AINSWORTH_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_AINSWORTH_FACE_HCURL(oo - 1);
             ll != NBVOLUMETET_AINSWORTH_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_AINSWORTH_TET_HCURL(oo - 1);
             ll != NBVOLUMETET_AINSWORTH_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_AINSWORTH_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_AINSWORTH_FACE_HCURL(oo - 1);
             ll != NBVOLUMETET_AINSWORTH_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_AINSWORTH_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);
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hcurl_Ainsworth_VolumeInteriorFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Ainsworth_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_AINSWORTH_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 909 of file Hcurl.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  if (NBVOLUMETET_AINSWORTH_TET_HCURL(p) == 0)
    MoFEMFunctionReturnHot(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];
    CHKERR base_polynomials(p, ksi_0i, diff_ksi0i, psi_l_0i, diff_psi_l_0i, 3);
 
    const double ksi_0j = N[n2] - N[n0];
    CHKERR base_polynomials(p, ksi_0j, diff_ksi0j, psi_l_0j, diff_psi_l_0j, 3);
 
    const double ksi_0k = N[n3] - N[n0];
    CHKERR base_polynomials(p, ksi_0k, diff_ksi0k, psi_l_0k, diff_psi_l_0k, 3);
 
    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_AINSWORTH_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);
    }
  }
  MoFEMFunctionReturnHot(0);
}

Hcurl_Demkowicz_EdgeBaseFunctions_MBEDGE()

MoFEMErrorCode MoFEM::Hcurl_Demkowicz_EdgeBaseFunctions_MBEDGE	(	int	sense,
		int	p,
		double *	n,
		double *	diff_n,
		double *	phi,
		double *	diff_phi,
		int	nb_integration_pts
	)

Edge based H-curl base functions on edge.

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

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
diff_n	derivatives of shape functions
phi	base functions on edges
diff_phi	derivatives of edge shape functions
nb_integration_pts	number of integration points

Returns

error code

Definition at line 2144 of file Hcurl.cpp.

                            {
  MoFEMFunctionBegin;
 
  FTensor::Tensor1<double, 3> t_grad_n[2];
  for (int nn = 0; nn != 2; ++nn)
    t_grad_n[nn] = FTensor::Tensor1<double, 3>(diff_n[nn], 0., 0.);
 
  HcurlEdgeBase h_curl_base_on_edge;
 
  FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_phi(
      &phi[HVEC0], &phi[HVEC1], &phi[HVEC2]);
 
  if (diff_phi != NULL)
    SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY,
            "Not implemented derivatives for edge for Hcurl Demkowicz base");
 
  int n0_idx = 0;
  int n1_idx = 1;
  if (sense == -1) {
    int n_tmp = n0_idx;
    n0_idx = n1_idx;
    n1_idx = n_tmp;
  }
 
  CHKERR h_curl_base_on_edge.calculate<1, false>(
      p, nb_integration_pts, n0_idx, n1_idx, n, t_grad_n, t_phi, nullptr);
 
  MoFEMFunctionReturn(0);
}

Hcurl_Demkowicz_EdgeBaseFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Demkowicz_EdgeBaseFunctions_MBTET	(	int *	sense,
		int *	p,
		double *	n,
		double *	diff_n,
		double *	phi[],
		double *	diff_phi[],
		int	nb_integration_pts
	)

Edge based H-curl base functions on tetrahedral.

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

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
diff_n	derivatives of shape functions
phi	base functions on edges
diff_phi	derivatives of edge shape functions
nb_integration_pts	number of integration points

Returns

error code

Definition at line 2068 of file Hcurl.cpp.

                                                {
 
  constexpr int e_nodes[6][2] = {{0, 1}, {1, 2}, {2, 0},
                                 {0, 3}, {1, 3}, {2, 3}};
 
  MoFEMFunctionBegin;
 
  FTensor::Tensor1<double, 3> t_grad_n[4];
  for (int nn = 0; nn != 4; ++nn)
    t_grad_n[nn] = FTensor::Tensor1<double, 3>(
        diff_n[3 * nn + 0], diff_n[3 * nn + 1], diff_n[3 * nn + 2]);
 
  HcurlEdgeBase h_curl_base_on_edge;
 
  for (int ee = 0; ee != 6; ++ee) {
 
    auto t_phi = getFTensor1FromPtr<3>(phi[ee]);
    auto t_diff_phi = getFTensor2HVecFromPtr<3, 3>(diff_phi[ee]);
 
    int n0_idx = e_nodes[ee][0];
    int n1_idx = e_nodes[ee][1];
    if (sense[ee] == -1) {
      int n_tmp = n0_idx;
      n0_idx = n1_idx;
      n1_idx = n_tmp;
    }
 
    CHKERR h_curl_base_on_edge.calculate<3, true>(p[ee], nb_integration_pts,
                                                  n0_idx, n1_idx, n, t_grad_n,
                                                  t_phi, &t_diff_phi);
  }
 
  MoFEMFunctionReturn(0);
}

Hcurl_Demkowicz_EdgeBaseFunctions_MBTRI()

MoFEMErrorCode MoFEM::Hcurl_Demkowicz_EdgeBaseFunctions_MBTRI	(	int *	sense,
		int *	p,
		double *	n,
		double *	diff_n,
		double *	phi[],
		double *	diff_phi[],
		int	nb_integration_pts
	)

Edge based H-curl base functions on teriangle.

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

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
diff_n	derivatives of shape functions
phi	base functions on edges
diff_phi	derivatives of edge shape functions
nb_integration_pts	number of integration points

Returns

error code

Definition at line 2105 of file Hcurl.cpp.

                                                {
 
  constexpr int e_nodes[3][2] = {{0, 1}, {1, 2}, {2, 0}};
 
  MoFEMFunctionBegin;
 
  FTensor::Tensor1<double, 3> t_grad_n[3];
  for (int nn = 0; nn != 3; ++nn)
    t_grad_n[nn] =
        FTensor::Tensor1<double, 3>(diff_n[2 * nn + 0], diff_n[2 * nn + 1], 0.);
 
  HcurlEdgeBase h_curl_base_on_edge;
 
  for (int ee = 0; ee != 3; ++ee) {
 
    if (p[ee]) {
 
      auto t_phi = getFTensor1FromPtr<3>(phi[ee]);
      auto t_diff_phi = getFTensor2HVecFromPtr<3, 2>(diff_phi[ee]);
 
      int n0_idx = e_nodes[ee][0];
      int n1_idx = e_nodes[ee][1];
      if (sense[ee] == -1) {
        int n_tmp = n0_idx;
        n0_idx = n1_idx;
        n1_idx = n_tmp;
      }
 
      CHKERR h_curl_base_on_edge.calculate<2, true>(p[ee], nb_integration_pts,
                                                    n0_idx, n1_idx, n, t_grad_n,
                                                    t_phi, &t_diff_phi);
    }
  }
 
  MoFEMFunctionReturn(0);
}

Hcurl_Demkowicz_FaceBaseFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Demkowicz_FaceBaseFunctions_MBTET	(	int *	faces_nodes,
		int *	p,
		double *	n,
		double *	diff_n,
		double *	phi[],
		double *	diff_phi[],
		int	nb_integration_pts
	)

Face base interior function.

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
n	nodal shape functions
diff_n	derivatives of nodal shape functions
phi	calculated shape functions
diff_phi	derivatives of shape functions
nb_integration_pts	number of shape functions

Returns

error code

Definition at line 2395 of file Hcurl.cpp.

                                                {
  MoFEMFunctionBegin;
 
  FTensor::Tensor1<double, 3> t_grad_n[4];
  for (int nn = 0; nn != 4; ++nn) {
    t_grad_n[nn] = FTensor::Tensor1<double, 3>(
        diff_n[3 * nn + 0], diff_n[3 * nn + 1], diff_n[3 * nn + 2]);
  };
 
  HcurlFaceBase h_curl_face_base;
 
  for (int ff = 0; ff != 4; ++ff) {
 
    if (p[ff] > 1) {
 
      auto t_phi = getFTensor1FromPtr<3>(phi[ff]);
      auto t_diff_phi = getFTensor2HVecFromPtr<3, 3>(diff_phi[ff]);
 
      // f0, f1 - family I and family II
      const int n0f0_idx = faces_nodes[3 * ff + 0];
      const int n1f0_idx = faces_nodes[3 * ff + 1];
      const int n2f0_idx = faces_nodes[3 * ff + 2];
      // family II
      const int n0f1_idx = faces_nodes[3 * ff + 1];
      const int n1f1_idx = faces_nodes[3 * ff + 2];
      const int n2f1_idx = faces_nodes[3 * ff + 0];
 
      CHKERR h_curl_face_base.calculateTwoFamily<3>(
          p[ff], nb_integration_pts, n0f0_idx, n1f0_idx, n2f0_idx, n0f1_idx,
          n1f1_idx, n2f1_idx, n, t_grad_n, t_phi, t_diff_phi);
    }
  }
 
  MoFEMFunctionReturn(0);
}

Hcurl_Demkowicz_FaceBaseFunctions_MBTRI()

MoFEMErrorCode MoFEM::Hcurl_Demkowicz_FaceBaseFunctions_MBTRI	(	int *	faces_nodes,
		int	p,
		double *	n,
		double *	diff_n,
		double *	phi,
		double *	diff_phi,
		int	nb_integration_pts
	)

Face base interior function.

Parameters

face_nodes	array [4*3] of local indices of face nodes
p	approximation order
n	nodal shape functions
diff_n	derivatives of nodal shape functions
phi	calculated shape functions
diff_phi	derivatives of shape functions
nb_integration_pts	number of shape functions

Returns

error code

Definition at line 2433 of file Hcurl.cpp.

                                              {
  MoFEMFunctionBegin;
 
  FTensor::Tensor1<double, 3> t_grad_n[3];
  for (int nn = 0; nn != 3; ++nn) {
    t_grad_n[nn] =
        FTensor::Tensor1<double, 3>(diff_n[2 * nn + 0], diff_n[2 * nn + 1], 0.);
  };
 
  HcurlFaceBase h_curl_face_base;
 
  if (p > 1) {
 
    auto t_phi = getFTensor1FromPtr<3>(phi);
    auto t_diff_phi = getFTensor2HVecFromPtr<3, 2>(diff_phi);
 
    // f0, f1 - family I and family II
    const int n0f0_idx = faces_nodes[0];
    const int n1f0_idx = faces_nodes[1];
    const int n2f0_idx = faces_nodes[2];
    // family II
    const int n0f1_idx = faces_nodes[1];
    const int n1f1_idx = faces_nodes[2];
    const int n2f1_idx = faces_nodes[0];
 
    CHKERR h_curl_face_base.calculateTwoFamily<2>(
        p, nb_integration_pts, n0f0_idx, n1f0_idx, n2f0_idx, n0f1_idx, n1f1_idx,
        n2f1_idx, n, t_grad_n, t_phi, t_diff_phi);
  }
 
  MoFEMFunctionReturn(0);
}

Hcurl_Demkowicz_VolumeBaseFunctions_MBTET()

MoFEMErrorCode MoFEM::Hcurl_Demkowicz_VolumeBaseFunctions_MBTET	(	int	p,
		double *	n,
		double *	diff_n,
		double *	phi,
		double *	diff_phi,
		int	nb_integration_pts
	)

Volume base interior function.

Parameters

p	approximation order
n	nodal shape functions
diff_n	derivatives of nodal shape functions
phi	calculated shape functions
diff_phi	derivatives of shape functions
nb_integration_pts	number of shape functions

Returns

error code

Definition at line 2468 of file Hcurl.cpp.

                            {
 
  constexpr int family[3][4] = {{0, 1, 2, 3}, {1, 2, 3, 0}, {2, 3, 0, 1}};
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
 
  MoFEMFunctionBegin;
 
  if (p > 2) {
 
    auto t_phi = getFTensor1FromPtr<3>(phi);
    auto t_diff_phi = getFTensor2HVecFromPtr<3, 3>(diff_phi);
 
    FTensor::Tensor1<double, 3> t_grad_n[4];
    for (int nn = 0; nn != 4; ++nn) {
      t_grad_n[nn] = FTensor::Tensor1<double, 3>(
          diff_n[3 * nn + 0], diff_n[3 * nn + 1], diff_n[3 * nn + 2]);
    };
 
    int nb_face_functions = (NBFACETRI_DEMKOWICZ_HCURL(p - 1)) / 2;
    MatrixDouble phi_ij(3, 3 * nb_face_functions * nb_integration_pts);
    MatrixDouble diff_phi_ij(3, 9 * nb_face_functions * nb_integration_pts);
    MatrixDouble fi_k(3, p + 1);
    MatrixDouble diff_fi_k(3, 3 * p + 3);
    HcurlFaceBase h_curl_face_base;
 
    // calate face base for each family
    for (int ff = 0; ff != 3; ++ff) {
      double *phi_ij_ptr = &phi_ij(ff, 0);
      double *diff_phi_ij_ptr = &diff_phi_ij(ff, 0);
 
      auto t_phi_ij = getFTensor1FromPtr<3>(phi_ij_ptr);
      auto t_diff_phi_ij = getFTensor2HVecFromPtr<3, 3>(diff_phi_ij_ptr);
 
      const int n0_idx = family[ff][0];
      const int n1_idx = family[ff][1];
      const int n2_idx = family[ff][2];
 
      CHKERR h_curl_face_base.calculateOneFamily<3>(
          p - 1, nb_integration_pts, n0_idx, n1_idx, n2_idx, n, t_grad_n,
          t_phi_ij, t_diff_phi_ij);
    }
 
    FTensor::Tensor1<double, 3> &t_grad_n3f0 = t_grad_n[family[0][3]];
    FTensor::Tensor1<double, 3> &t_grad_n3f1 = t_grad_n[family[1][3]];
    FTensor::Tensor1<double, 3> &t_grad_n3f2 = t_grad_n[family[2][3]];
 
    FTensor::Tensor1<double, 3> t_sum_f0;
    t_sum_f0(i) = -t_grad_n3f0(i);
    FTensor::Tensor1<double, 3> t_sum_f1;
    t_sum_f1(i) = -t_grad_n3f1(i);
    FTensor::Tensor1<double, 3> t_sum_f2;
    t_sum_f2(i) = -t_grad_n3f2(i);
 
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
 
      int shift_n = 4 * gg;
 
      double n3f0 = n[shift_n + family[0][3]];
      double n3f1 = n[shift_n + family[1][3]];
      double n3f2 = n[shift_n + family[2][3]];
 
      int kk = 0;
      for (int oo = 3; oo <= p; ++oo) {
 
        int phi_shift = 3 * nb_face_functions * gg;
        int diff_phi_shift = 9 * nb_face_functions * gg;
 
        auto t_phi_face_f0 = getFTensor1FromPtr<3>(&phi_ij(0, phi_shift));
        auto t_diff_phi_face_f0 =
            getFTensor2HVecFromPtr<3, 3>(&diff_phi_ij(0, diff_phi_shift));
        auto t_phi_face_f1 = getFTensor1FromPtr<3>(&phi_ij(1, phi_shift));
        auto t_diff_phi_face_f1 =
            getFTensor2HVecFromPtr<3, 3>(&diff_phi_ij(1, diff_phi_shift));
        auto t_phi_face_f2 = getFTensor1FromPtr<3>(&phi_ij(2, phi_shift));
        auto t_diff_phi_face_f2 =
            getFTensor2HVecFromPtr<3, 3>(&diff_phi_ij(2, diff_phi_shift));
 
        int ij = 0;
        for (int oo_ij = 2; oo_ij != oo; ++oo_ij) {
          int k = oo - oo_ij;
 
          CHKERR IntegratedJacobi_polynomials(k, 2 * oo_ij, n3f0, 1 - n3f0,
                                              &t_grad_n3f0(0), &t_sum_f0(0),
                                              &fi_k(0, 0), &diff_fi_k(0, 0), 3);
          CHKERR IntegratedJacobi_polynomials(k, 2 * oo_ij, n3f1, 1 - n3f1,
                                              &t_grad_n3f1(0), &t_sum_f1(0),
                                              &fi_k(1, 0), &diff_fi_k(1, 0), 3);
          CHKERR IntegratedJacobi_polynomials(k, 2 * oo_ij, n3f2, 1 - n3f2,
                                              &t_grad_n3f2(0), &t_sum_f2(0),
                                              &fi_k(2, 0), &diff_fi_k(2, 0), 3);
 
          FTensor::Tensor1<double, 3> t_diff_fi_k_f0(
              diff_fi_k(0, 0 + k - 1), diff_fi_k(0, k + k - 1),
              diff_fi_k(0, 2 * k + k - 1));
          FTensor::Tensor1<double, 3> t_diff_fi_k_f1(
              diff_fi_k(1, 0 + k - 1), diff_fi_k(1, k + k - 1),
              diff_fi_k(1, 2 * k + k - 1));
          FTensor::Tensor1<double, 3> t_diff_fi_k_f2(
              diff_fi_k(2, 0 + k - 1), diff_fi_k(2, k + k - 1),
              diff_fi_k(2, 2 * k + k - 1));
 
          for (; ij != NBFACETRI_DEMKOWICZ_HCURL(oo_ij) / 2; ++ij) {
            t_phi(i) = fi_k(0, k - 1) * t_phi_face_f0(i);
            t_diff_phi(i, j) = t_diff_fi_k_f0(j) * t_phi_face_f0(i) +
                               fi_k(0, k - 1) * t_diff_phi_face_f0(i, j);
            ++t_phi;
            ++t_diff_phi;
            ++t_phi_face_f0;
            ++t_diff_phi_face_f0;
            ++kk;
 
            t_phi(i) = fi_k(1, k - 1) * t_phi_face_f1(i);
            t_diff_phi(i, j) = t_diff_fi_k_f1(j) * t_phi_face_f1(i) +
                               fi_k(1, k - 1) * t_diff_phi_face_f1(i, j);
            ++t_phi;
            ++t_diff_phi;
            ++t_phi_face_f1;
            ++t_diff_phi_face_f1;
            ++kk;
 
            t_phi(i) = fi_k(2, k - 1) * t_phi_face_f2(i);
            t_diff_phi(i, j) = t_diff_fi_k_f2(j) * t_phi_face_f2(i) +
                               fi_k(2, k - 1) * t_diff_phi_face_f2(i, j);
            ++t_phi;
            ++t_diff_phi;
            ++t_phi_face_f2;
            ++t_diff_phi_face_f2;
            ++kk;
          }
        }
      }
      if (kk != NBVOLUMETET_DEMKOWICZ_HCURL(p))
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Wrong number of base functions");
    }
  }
 
  MoFEMFunctionReturn(0);
}

Hdiv_Ainsworth_EdgeBasedVolumeShapeFunctions_MBTET()

MoFEMErrorCode 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 307 of file Hdiv.cpp.

                                                       {
 
  constexpr int edges_nodes[6][2] = {{0, 1}, {1, 2}, {2, 0},
                                     {0, 3}, {1, 3}, {2, 3}};
 
  MoFEMFunctionBeginHot;
  if (p < 2)
    MoFEMFunctionReturnHot(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(3, i);
  FTENSOR_INDEX(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);
    auto t_phi_v_e = getFTensor1FromPtr<3>(phi_v_e[ee]);
    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;
      base_polynomials(p, ksi0i, NULL, psi_l, NULL, 3);
      auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
      for (int l = 0; l <= p - 2; l++) {
        t_phi_v_e(i) = (beta_e * t_psi_l) * t_tou_e(i);
        ++t_phi_v_e;
        ++t_psi_l;
      }
    }
  }
 
  if (diff_phi_v_e) {
    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);
      auto t_diff_phi_v_e = getFTensor2HVecFromPtr<3, 3>(diff_phi_v_e[ee]);
      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;
        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;
        base_polynomials(p, ksi0i, &t_diff_ksi0i(0), psi_l, diff_psi_l, 3);
        auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
        auto t_diff_psi_l = FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>(
            diff_psi_l, &diff_psi_l[p + 1], &diff_psi_l[2 * p + 2]);
        for (int l = 0; l <= p - 2; l++) {
          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;
        }
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET()

MoFEMErrorCode 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 24 of file Hdiv.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
#ifdef NDEBUG
  if (!diff_phi_f_e)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "expected to return derivatives");
#endif
 
  for (int ff = 0; ff < 4; ff++) {
    CHKERR 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);
  }
 
  MoFEMFunctionReturnHot(0);
}

Hdiv_Ainsworth_EdgeFaceShapeFunctions_MBTET_ON_FACE()

MoFEMErrorCode 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 47 of file Hdiv.cpp.

                                                       {
 
  constexpr int face_edges_nodes[3][2] = {{0, 1}, {1, 2}, {2, 0}};
  constexpr int face_opposite_edges_node[] = {2, 0, 1};
  FTENSOR_INDEX(3, i);
  FTENSOR_INDEX(3, j);
  FTENSOR_INDEX(3, k);
 
  MoFEMFunctionBeginHot;
  if (p < 1)
    MoFEMFunctionReturnHot(0);
 
  FTensor::Tensor1<double, 3> t_edge_cross[3];
  FTensor::Tensor1<double, 3> t_node_diff_ksi[4];
  FTensor::Tensor1<double, 3> t_diff_ksi[3];
  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]);
    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_ksi[ee](i) = t_node_diff_ksi[n1](i) - t_node_diff_ksi[n0](i);
      t_edge_cross[ee](i) = levi_civita(i, j, k) * t_node_diff_ksi[n0](j) *
                            t_node_diff_ksi[n1](k);
    }
  } 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];
 
  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_opposite_edges_node[ee]];
    auto t_psi_f_e = getFTensor1FromPtr<3>(phi_f_e[ee]);
    for (int ii = 0; ii != nb * gdim; ii += nb) {
      const double n0 = N[ii + i0];
      const double n1 = N[ii + i1];
      const double lambda = N[ii + iO];
      const double ksi = n1 - n0;
      base_polynomials(p, ksi, NULL, psi_l, NULL, 3);
      auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
      int jj = 0;
      for (int l = 0; l <= p - 1; l++) {
        t_psi_f_e(i) = (lambda * t_psi_l) * t_edge_cross[ee](i);
        ++t_psi_f_e;
        ++t_psi_l;
        ++jj;
      }
#ifdef NDEBUG
      if (jj != NBFACETRI_AINSWORTH_EDGE_HDIV(p)) {
        SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "wrong order %d != %d", jj, NBFACETRI_AINSWORTH_EDGE_HDIV(p));
      }
#endif
    }
  }
 
  if (diff_phi_f_e) {
    double diff_psi_l[3 * (p + 1)];
    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_opposite_edges_node[ee]];
      auto t_diff_phi_f_e = getFTensor2HVecFromPtr<3, 3>(diff_phi_f_e[ee]);
      for (int ii = 0; ii != nb * gdim; ii += nb) {
        const double n0 = N[ii + i0];
        const double n1 = N[ii + i1];
        const double lambda = N[ii + iO];
        const double ksi = n1 - n0;
        base_polynomials(p, ksi, &t_diff_ksi[ee](0), psi_l, diff_psi_l, 3);
        auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
        auto t_diff_psi_l = FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>{
            &diff_psi_l[0], &diff_psi_l[p + 1], &diff_psi_l[2 * p + 2]};
        for (int l = 0; l <= p - 1; l++) {
          t_diff_phi_f_e(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;
          ++t_psi_l;
        }
      }
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hdiv_Ainsworth_FaceBasedVolumeShapeFunctions_MBTET()

MoFEMErrorCode 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 401 of file Hdiv.cpp.

                                                       {
 
  constexpr int faces_nodes[4][3] = {
      {0, 1, 3}, {1, 2, 3}, {0, 3, 2}, {0, 2, 1}};
 
  MoFEMFunctionBeginHot;
  if (p < 3)
    MoFEMFunctionReturnHot(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(3, i);
  FTENSOR_INDEX(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];
    auto t_phi_v_f = getFTensor1FromPtr<3>(phi_v_f[ff]);
    auto t_diff_phi_v_f = getFTensor2HVecFromPtr<3, 3>(diff_phi_v_f[ff]);
    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;
      base_polynomials(p, ksi0i, &t_diff_ksi0i[ff](0), psi_l, diff_psi_l, 3);
      base_polynomials(p, ksi0j, &t_diff_ksi0j[ff](0), psi_m, diff_psi_m, 3);
      FTensor::Tensor1<double, 3> t_diff_a;
      int jj = 0;
      for (int oo = 0; oo <= p - 3; oo++) {
        auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
        auto t_diff_psi_l = FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>(
            diff_psi_l, &diff_psi_l[p + 1], &diff_psi_l[2 * p + 2]);
        for (int l = 0; l <= oo; l++) {
          int m = oo - l;
          if (m >= 0) {
            auto t_diff_psi_m = FTensor::Tensor1<double, 3>{
                diff_psi_m[m], diff_psi_m[p + 1 + m],
                diff_psi_m[2 * p + 2 + m]};
            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_AINSWORTH_FACE_HDIV(p)) {
        SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "wrong order %d != %d", jj,
                 NBVOLUMETET_AINSWORTH_FACE_HDIV(p));
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

Hdiv_Ainsworth_FaceBubbleShapeFunctions()

MoFEMErrorCode 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 151 of file Hdiv.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
#ifdef NDEBUG
  if (!diff_phi_f)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "expected to return derivatives");
#endif
 
  for (int ff = 0; ff < 4; ff++) {
    CHKERR Hdiv_Ainsworth_FaceBubbleShapeFunctions_ON_FACE(
        &faces_nodes[3 * ff], p[ff], N, diffN, phi_f[ff], diff_phi_f[ff], gdim,
        4, base_polynomials);
  }
  MoFEMFunctionReturnHot(0);
}

Hdiv_Ainsworth_FaceBubbleShapeFunctions_ON_FACE()

MoFEMErrorCode 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 174 of file Hdiv.cpp.

                                                       {
  FTENSOR_INDEX(3, i);
  FTENSOR_INDEX(3, j);
  FTENSOR_INDEX(3, k);
 
  MoFEMFunctionBeginHot;
  if (p < 3)
    MoFEMFunctionReturnHot(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(i) = levi_civita(i, j, k) * t_node_diff_ksi[vert_i](j) *
                 t_node_diff_ksi[vert_j](k);
  } 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)];
  auto t_psi_f = getFTensor1FromPtr<3>(phi_f);
 
  for (int ii = 0; ii < gdim; ii++) {
 
    const 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;
    base_polynomials(p, ksi0i, NULL, psi_l, NULL, 3);
    base_polynomials(p, ksi0j, NULL, psi_m, NULL, 3);
 
    int jj = 0;
    int oo = 0;
    for (; oo <= p - 3; oo++) {
      auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
      for (int l = 0; l <= oo; l++) {
        int m = oo - l;
        if (m >= 0) {
          t_psi_f(i) = (beta_0ij * t_psi_l * psi_m[m]) * t_cross(i);
          ++t_psi_f;
        }
        ++t_psi_l;
        ++jj;
      }
    }
#ifdef NDEBUG
    if (jj != NBFACETRI_AINSWORTH_FACE_HDIV(p)) {
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "wrong order %d != %d", jj, NBFACETRI_AINSWORTH_FACE_HDIV(p));
    }
#endif
  }
 
  if (diff_phi_f) {
    auto t_diff_phi_f = getFTensor2HVecFromPtr<3, 3>(diff_phi_f);
 
    for (int ii = 0; ii < gdim; ii++) {
 
      const 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;
      FTensor::Tensor1<double, 3> t_diff_beta_0ij;
      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);
      base_polynomials(p, ksi0i, &t_diff_ksi0i(0), psi_l, diff_psi_l, 3);
      base_polynomials(p, ksi0j, &t_diff_ksi0j(0), psi_m, diff_psi_m, 3);
 
      int jj = 0;
      int oo = 0;
      for (; oo <= p - 3; oo++) {
        auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
        auto t_diff_psi_l = FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>{
            &diff_psi_l[0], &diff_psi_l[p + 1], &diff_psi_l[2 * p + 2]};
        for (int l = 0; l <= oo; l++) {
          int m = oo - l;
          if (m >= 0) {
            auto t_diff_psi_m =
                FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>{
                    &diff_psi_m[m], &diff_psi_m[p + 1 + m],
                    &diff_psi_m[2 * p + 2 + m]};
            t_diff_phi_f(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;
          }
          ++t_psi_l;
          ++t_diff_psi_l;
          ++jj;
        }
      }
#ifndef NDEBUG
      if (jj != NBFACETRI_AINSWORTH_FACE_HDIV(p)) {
        SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "wrong order %d != %d", jj, NBFACETRI_AINSWORTH_FACE_HDIV(p));
      }
#endif
    }
  }
  MoFEMFunctionReturnHot(0);
}

Hdiv_Ainsworth_VolumeBubbleShapeFunctions_MBTET()

MoFEMErrorCode 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 507 of file Hdiv.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
  if (p < 4)
    MoFEMFunctionReturnHot(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)];
 
  auto t_phi_v = getFTensor1FromPtr<3>(phi_v);
  auto t_diff_phi_v = getFTensor2HVecFromPtr<3, 3>(diff_phi_v);
 
  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);
    base_polynomials(p, ksi0i, &t_diff_ksi0i(0), psi_l, diff_psi_l, 3);
    base_polynomials(p, ksi0j, &t_diff_ksi0j(0), psi_m, diff_psi_m, 3);
    base_polynomials(p, ksi0k, &t_diff_ksi0k(0), psi_n, diff_psi_n, 3);
 
    FTensor::Tensor1<double, 3> t_diff_a;
 
    int jj = 0;
    for (int oo = 0; oo <= p - 4; oo++) {
      auto t_psi_l = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_l);
      auto t_diff_psi_l = FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>(
          diff_psi_l, &diff_psi_l[p + 1], &diff_psi_l[2 * p + 2]);
      for (int l = 0; l <= oo; l++) {
        auto t_psi_m = FTensor::Tensor0<FTensor::PackPtr<double *, 1>>(psi_m);
        auto t_diff_psi_m = FTensor::Tensor1<FTensor::PackPtr<double *, 1>, 3>(
            diff_psi_m, &diff_psi_m[p + 1], &diff_psi_m[2 * p + 2]);
        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));
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hdiv_Demkowicz_Face_MBTET_ON_FACE()

MoFEMErrorCode 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
	)

\brirf HDiv base finuctions on triangle by Demkowicz [29]

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

Examples

forces_and_sources_testing_users_base.cpp.

Definition at line 634 of file Hdiv.cpp.

                                                                               {
  const int face_edges_nodes[3][2] = {{0, 1}, {1, 2}, {2, 0}};
  const int face_opposite_edges_node[] = {2, 0, 1};
 
  MoFEMFunctionBeginHot;
 
  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(0., 0., 0., 0., 0., 0., 0., 0.,
                                              0.);
  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_opposite_edges_node[0]],
                   faces_nodes[face_opposite_edges_node[1]],
                   faces_nodes[face_opposite_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[HVEC0], &phi_f[HVEC1],
                                      &phi_f[HVEC2], 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[HVEC0_0], &diff_phi_f[HVEC0_1], &diff_phi_f[HVEC0_2],
            &diff_phi_f[HVEC1_0], &diff_phi_f[HVEC1_1], &diff_phi_f[HVEC1_2],
            &diff_phi_f[HVEC2_0], &diff_phi_f[HVEC2_1], &diff_phi_f[HVEC2_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);
    CHKERRG(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);
      CHKERRG(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));
    }
  }
 
  MoFEMFunctionReturnHot(0);
}

Hdiv_Demkowicz_Interior_MBTET()

MoFEMErrorCode 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
	)

\brirf HDiv base finuctions in tetrahedral interior by Demkowicz [29]

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

Examples

forces_and_sources_testing_users_base.cpp.

Definition at line 780 of file Hdiv.cpp.

                                                                        {
 
  const int opposite_face_node[4] = {2, 0, 1, 3};
  // list of zero node faces
  const int znf[] = {0, 2, 3};
  MoFEMFunctionBegin;
 
  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_m_node_diff_ksi[4];
  for (int ff = 0; ff != 4; ++ff) {
    t_m_node_diff_ksi[ff](i) = -t_node_diff_ksi[ff](i);
  }
 
  FTensor::Tensor1<double *, 3> t_phi_v(&phi_v[HVEC0], &phi_v[HVEC1],
                                        &phi_v[HVEC2], 3);
  FTensor::Tensor2<double *, 3, 3> t_diff_phi_v(
      &diff_phi_v[HVEC0_0], &diff_phi_v[HVEC0_1], &diff_phi_v[HVEC0_2],
      &diff_phi_v[HVEC1_0], &diff_phi_v[HVEC1_1], &diff_phi_v[HVEC1_2],
      &diff_phi_v[HVEC2_0], &diff_phi_v[HVEC2_1], &diff_phi_v[HVEC2_2], 9);
 
  MatrixDouble fk(3, p + 1), diff_fk(3, 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 = opposite_face_node[fff];
      const double nO = N[shift + iO];
      for (int pp = 1; pp <= p; pp++) {
        CHKERR IntegratedJacobi_polynomials(
            pp, 2 * pp + 2, nO, 1 - nO, &t_node_diff_ksi[iO](0),
            &t_m_node_diff_ksi[iO](0), &fk(ff, 0), &diff_fk(ff, 0), 3);
      }
    }
 
    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 that 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] + HVEC0],
                                            &phi_f[znf[0]][sp[0] + HVEC1],
                                            &phi_f[znf[0]][sp[0] + HVEC2], 3),
              FTensor::Tensor1<double *, 3>(&phi_f[znf[1]][sp[1] + HVEC0],
                                            &phi_f[znf[1]][sp[1] + HVEC1],
                                            &phi_f[znf[1]][sp[1] + HVEC2], 3),
              FTensor::Tensor1<double *, 3>(&phi_f[znf[2]][sp[2] + HVEC0],
                                            &phi_f[znf[2]][sp[2] + HVEC1],
                                            &phi_f[znf[2]][sp[2] + HVEC2], 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] + HVEC0_0],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC0_1],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC0_2],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC1_0],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC1_1],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC1_2],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC2_0],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC2_1],
                  &diff_phi_f[znf[0]][sdp[0] + HVEC2_2], 9),
              FTensor::Tensor2<double *, 3, 3>(
                  &diff_phi_f[znf[1]][sdp[1] + HVEC0_0],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC0_1],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC0_2],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC1_0],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC1_1],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC1_2],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC2_0],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC2_1],
                  &diff_phi_f[znf[1]][sdp[1] + HVEC2_2], 9),
              FTensor::Tensor2<double *, 3, 3>(
                  &diff_phi_f[znf[2]][sdp[2] + HVEC0_0],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC0_1],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC0_2],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC1_0],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC1_1],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC1_2],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC2_0],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC2_1],
                  &diff_phi_f[znf[2]][sdp[2] + HVEC2_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 + k - 1),
                                                    diff_fk(ff, 1 * p + k - 1),
                                                    diff_fk(ff, 2 * p + k - 1));
              t_phi_v(i) = fk(ff, k - 1) * t_phi_f[ff](i);
              t_diff_phi_v(i, j) = t_diff_fk(j) * t_phi_f[ff](i) +
                                   fk(ff, k - 1) * 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));
    }
  }
 
  MoFEMFunctionReturn(0);
}

id_from_handle()

auto MoFEM::id_from_handle ( const EntityHandle  h )

inline

Definition at line 1890 of file Templates.hpp.

                                                 {
  return static_cast<EntityID>(h & MB_ID_MASK);
};

insertOrdered()

template<typename Extractor , typename Iterator >

moab::Range::iterator MoFEM::insertOrdered	(	Range &	r,
		Extractor	,
		Iterator	begin_iter,
		Iterator	end_iter
	)

Insert ordered mofem multi-index into range.

Note

Inserted range has to be ordered.

auto hi_rit = refEntsPtr->upper_bound(start);
auto hi_rit = refEntsPtr->upper_bound(end);
Range to_erase;
insertOrdered(to_erase, RefEntExtractor(), rit, hi_rit);

Template Parameters

Iterator

Parameters

r
begin_iter
end_iter

Returns

moab::Range::iterator

Definition at line 1817 of file Templates.hpp.

                                                       {
  moab::Range::iterator hint = r.begin();
  while (begin_iter != end_iter) {
    size_t j = 0;
    auto bi = Extractor::extract(begin_iter);
    Iterator pj = begin_iter;
    while (pj != end_iter && (bi + j) == Extractor::extract(pj)) {
      ++pj;
      ++j;
    }
    hint = r.insert(hint, bi, bi + (j - 1));
    begin_iter = pj;
  }
  return hint;
};

invertTensor() [1/2]

template<typename T1 , typename T2 , typename T3 , int DIM>

static MoFEMErrorCode MoFEM::invertTensor ( FTensor::Tensor2< T1, DIM, DIM > &  t, T2 &  det, FTensor::Tensor2< T3, DIM, DIM > &  inv_t  )

inlinestatic

Examples

ContactOps.hpp.

Definition at line 1771 of file Templates.hpp.

                                                  {
  return InvertTensorImpl<FTensor::Tensor2<T1, DIM, DIM>, T2,
                          FTensor::Tensor2<T3, DIM, DIM>, DIM>::invert(t, det,
                                                                       inv_t);
}

invertTensor() [2/2]

template<typename T1 , typename T2 , typename T3 , int DIM>

static MoFEMErrorCode MoFEM::invertTensor ( FTensor::Tensor2_symmetric< T1, DIM > &  t, T2 &  det, FTensor::Tensor2_symmetric< T3, DIM > &  inv_t  )

inlinestatic

Definition at line 1780 of file Templates.hpp.

                                                       {
  return InvertTensorImpl<FTensor::Tensor2_symmetric<T1, DIM>, T2,
                          FTensor::Tensor2_symmetric<T3, DIM>,
                          DIM>::invert(t, det, inv_t);
}

invertTensor2by2()

template<class T1 , class T2 , class T3 >

MoFEMErrorCode MoFEM::invertTensor2by2 ( T1 &  t, T2 &  det, T3 &  inv_t  )

inline

Calculate matrix inverse 2 by 2.

Definition at line 1649 of file Templates.hpp.

                                                                  {
  MoFEMFunctionBeginHot;
  const auto inv_det = 1. / det;
  inv_t(0, 0) = t(1, 1) * inv_det;
  inv_t(0, 1) = -t(0, 1) * inv_det;
  inv_t(1, 0) = -t(1, 0) * inv_det;
  inv_t(1, 1) = t(0, 0) * inv_det;
  MoFEMFunctionReturnHot(0);
}

invertTensor3by3() [1/2]

template<class T1 , class T2 , class T3 >

MoFEMErrorCode MoFEM::invertTensor3by3 ( T1 &  t, T2 &  det, T3 &  inv_t  )

inline

Calculate matrix inverse 3 by 3.

Definition at line 1629 of file Templates.hpp.

                                                                  {
  MoFEMFunctionBeginHot;
  const auto inv_det = 1. / det;
  inv_t(0, 0) = (t(1, 1) * t(2, 2) - t(1, 2) * t(2, 1)) * inv_det;
  inv_t(0, 1) = (t(0, 2) * t(2, 1) - t(0, 1) * t(2, 2)) * inv_det;
  inv_t(0, 2) = (t(0, 1) * t(1, 2) - t(0, 2) * t(1, 1)) * inv_det;
  inv_t(1, 0) = (t(1, 2) * t(2, 0) - t(1, 0) * t(2, 2)) * inv_det;
  inv_t(1, 1) = (t(0, 0) * t(2, 2) - t(0, 2) * t(2, 0)) * inv_det;
  inv_t(1, 2) = (t(0, 2) * t(1, 0) - t(0, 0) * t(1, 2)) * inv_det;
  inv_t(2, 0) = (t(1, 0) * t(2, 1) - t(1, 1) * t(2, 0)) * inv_det;
  inv_t(2, 1) = (t(0, 1) * t(2, 0) - t(0, 0) * t(2, 1)) * inv_det;
  inv_t(2, 2) = (t(0, 0) * t(1, 1) - t(0, 1) * t(1, 0)) * inv_det;
  MoFEMFunctionReturnHot(0);
}

invertTensor3by3() [2/2]

template<int Tensor_Dim, class T , class L , class A >

MoFEMErrorCode MoFEM::invertTensor3by3 ( ublas::matrix< T, L, A > &  jac_data, ublas::vector< T, A > &  det_data, ublas::matrix< T, L, A > &  inv_jac_data  )

inline

Calculate inverse of tensor rank 2 at integration points.

Examples

HookeElement.cpp, HookeElement.hpp, HookeInternalStressElement.hpp, lorentz_force.cpp, NeoHookean.hpp, and Remodeling.cpp.

Definition at line 1588 of file Templates.hpp.

                                                                           {
  MoFEMFunctionBeginHot;
  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
          "Specialization for this template not yet implemented");
  MoFEMFunctionReturnHot(0);
}

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

template<>

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

inline

Definition at line 149 of file DataOperators.cpp.

                                {
  MoFEMFunctionBegin;
  auto A = getFTensor2FromMat<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);
  auto det = getFTensor0FromVec(det_data);
  auto I = getFTensor2FromMat<3, 3>(inv_jac_data);
  for (int gg = 0; gg != nb_gauss_pts; ++gg) {
    CHKERR determinantTensor3by3(A, det);
    CHKERR invertTensor3by3(A, det, I);
    ++A;
    ++det;
    ++I;
  }
  MoFEMFunctionReturn(0);
}

isAllGather()

auto MoFEM::isAllGather ( IS  is )

inline

IS All gather.

Parameters

is

Returns

auto

Definition at line 300 of file PetscSmartObj.hpp.

                                {
  IS isout;
  CHK_THROW_MESSAGE(ISAllGather(is, &isout), "Failed to create ISAllGather");
  return SmartPetscObj<IS>(isout);
}

isDifference()

auto MoFEM::isDifference ( IS  is1, IS  is2  )

inline

Get ISDifference.

ISDifference.

Parameters

is1	first index, to have items removed from it
is2	index values to be removed

Returns

is1 - is2

Definition at line 377 of file PetscSmartObj.hpp.

                                         {
  IS is_raw;
  CHK_THROW_MESSAGE(ISDifference(is1, is2, &is_raw), "create difference");
  return SmartPetscObj<IS>(is_raw);
}

isDuplicate()

auto MoFEM::isDuplicate ( IS  is )

inline

Definition at line 396 of file PetscSmartObj.hpp.

                               {
  IS is_raw;
  CHK_THROW_MESSAGE(ISDuplicate(is, &is_raw), "duplicate IS");
  return SmartPetscObj<IS>(is_raw);
}

ksp_set_operators()

static MoFEMErrorCode MoFEM::ksp_set_operators ( KSP  ksp, Mat  A, Mat  B, void *  ctx  )

static

Definition at line 308 of file PCMGSetUpViaApproxOrders.cpp.

                                                                          {
  MoFEMFunctionBeginHot;
  MoFEMFunctionReturnHot(0);
}

KspMat()

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

Run over elements in the list.

Parameters

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

Returns

error code

Definition at line 86 of file KspCtx.cpp.

                                                        {
  // PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
  MoFEMFunctionBegin;
  KspCtx *ksp_ctx = static_cast<KspCtx *>(ctx);
  PetscLogEventBegin(ksp_ctx->MOFEM_EVENT_KspMat, 0, 0, 0, 0);
 
  ksp_ctx->matAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ksp_ctx->mField.cache_problem_entities(ksp_ctx->problemName,
                                                cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ksp = ksp;
    fe.ksp_A = A;
    fe.ksp_B = B;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  auto ent_data_cache = boost::make_shared<std::vector<EntityCacheDofs>>();
  auto ent_row_cache =
      boost::make_shared<std::vector<EntityCacheNumeredDofs>>();
  auto ent_col_cache =
      boost::make_shared<std::vector<EntityCacheNumeredDofs>>();
 
  // pre-procsess
  for (auto &bit : ksp_ctx->preProcess_Mat) {
    bit->matAssembleSwitch = boost::move(ksp_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ksp_ctx->mField.problem_basic_method_preProcess(ksp_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ksp_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  // operators
  for (auto &lit : ksp_ctx->loops_to_do_Mat) {
    lit.second->matAssembleSwitch = boost::move(ksp_ctx->matAssembleSwitch);
    set(*lit.second);
    CHKERR ksp_ctx->mField.loop_finite_elements(ksp_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ksp_ctx->bH, cache_ptr);
    unset(*lit.second);
    ksp_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }
 
  // post-process
  for (auto &bit : ksp_ctx->postProcess_Mat) {
    bit->matAssembleSwitch = boost::move(ksp_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ksp_ctx->mField.problem_basic_method_postProcess(
        ksp_ctx->problemName, *bit);
    unset(*bit);
    ksp_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  if (ksp_ctx->matAssembleSwitch) {
    CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
    CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
  }
  PetscLogEventEnd(ksp_ctx->MOFEM_EVENT_KspMat, 0, 0, 0, 0);
  MoFEMFunctionReturn(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 21 of file KspCtx.cpp.

                                                 {
  // PetscValidHeaderSpecific(ksp,KSP_CLASSID,1);
  MoFEMFunctionBegin;
  KspCtx *ksp_ctx = static_cast<KspCtx *>(ctx);
  PetscLogEventBegin(ksp_ctx->MOFEM_EVENT_KspRhs, 0, 0, 0, 0);
 
  ksp_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
 
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ksp_ctx->mField.cache_problem_entities(ksp_ctx->problemName,
                                                cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ksp = ksp;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx = PetscData::CtxSetF;
    fe.ksp_f = f;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // pre-process
  for (auto &bit : ksp_ctx->preProcess_Rhs) {
    bit->vecAssembleSwitch = boost::move(ksp_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ksp_ctx->mField.problem_basic_method_preProcess(ksp_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ksp_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  // operators
  for (auto &lit : ksp_ctx->loops_to_do_Rhs) {
    lit.second->vecAssembleSwitch = boost::move(ksp_ctx->vecAssembleSwitch);
    set(*lit.second);
    CHKERR ksp_ctx->mField.loop_finite_elements(ksp_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ksp_ctx->bH, cache_ptr);
    unset(*lit.second);
    ksp_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  // post-process
  for (auto &bit : ksp_ctx->postProcess_Rhs) {
    bit->vecAssembleSwitch = boost::move(ksp_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ksp_ctx->mField.problem_basic_method_postProcess(
        ksp_ctx->problemName, *bit);
    unset(*bit);
    ksp_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*ksp_ctx->vecAssembleSwitch) {
    CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
  }
  PetscLogEventEnd(ksp_ctx->MOFEM_EVENT_KspRhs, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

make_array()

template<typename Dest = void, typename... Arg>

constexpr auto MoFEM::make_array ( Arg &&...  arg )

constexpr

Create Array.

See: See stack overflow

Template Parameters

Dest
Arg

Parameters

arg

Returns

constexpr auto

Examples

level_set.cpp.

Definition at line 1990 of file Templates.hpp.

                                        {
  if constexpr (std::is_same<void, Dest>::value)
    return std::array<std::common_type_t<std::decay_t<Arg>...>, sizeof...(Arg)>{
        {std::forward<Arg>(arg)...}};
  else
    return std::array<Dest, sizeof...(Arg)>{{std::forward<Arg>(arg)...}};
}

mat_zero()

static PetscErrorCode MoFEM::mat_zero ( Mat  m )

static

Definition at line 1350 of file Schur.cpp.

                                      {
  MoFEMFunctionBegin;
  BlockStructure *ctx;
  CHKERR MatShellGetContext(m, (void **)&ctx);
  if (ctx->dataBlocksPtr)
    std::fill(ctx->dataBlocksPtr->begin(), ctx->dataBlocksPtr->end(), 0.);
  if (ctx->preconditionerBlocksPtr)
    std::fill(ctx->preconditionerBlocksPtr->begin(),
              ctx->preconditionerBlocksPtr->end(), 0.);
  MoFEMFunctionReturn(0);
}

matCreateVecs()

auto MoFEM::matCreateVecs ( Mat  mat )

inline

Definition at line 390 of file PetscSmartObj.hpp.

                                   {
  Vec x, y;
  CHK_THROW_MESSAGE(MatCreateVecs(mat, &x, &y), "create vecs");
  return std::make_pair(SmartPetscObj<Vec>(x), SmartPetscObj<Vec>(y));
}

matDuplicate()

SmartPetscObj<Mat> MoFEM::matDuplicate ( Mat  mat, MatDuplicateOption  op  )

inline

Examples

eigen_elastic.cpp, and elasticity.cpp.

Definition at line 234 of file PetscSmartObj.hpp.

                                                                       {
  Mat duplicate;
  CHK_THROW_MESSAGE(MatDuplicate(mat, op, &duplicate),
                    "Failed to duplicate Mat");
  return SmartPetscObj<Mat>(duplicate);
};

MatSetValues() [1/2]

template<typename T = EntityStorage>

MoFEMErrorCode MoFEM::MatSetValues ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const double *  ptr, InsertMode  iora  )

inline

Assemble PETSc matrix.

Function extract indices from entity data and assemble vector

See PETSc documentation

Parameters

M
row_data
col_data
ptr
iora

Returns

MoFEMErrorCode

Examples

analytical_poisson_field_split.cpp, ElasticityMixedFormulation.hpp, HookeElement.cpp, HookeElement.hpp, level_set.cpp, MagneticElement.hpp, NavierStokesElement.cpp, plate.cpp, PoissonDiscontinousGalerkin.hpp, PoissonOperators.hpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, Remodeling.cpp, simple_elasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 1644 of file EntitiesFieldData.hpp.

                                                                       {
  static_assert(!std::is_same<T, T>::value,
                "MatSetValues value for this data storage is not implemented");
  return MOFEM_NOT_IMPLEMENTED;
}

MatSetValues() [2/2]

template<typename T = EntityStorage>

MoFEMErrorCode MoFEM::MatSetValues ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const MatrixDouble &  mat, InsertMode  iora  )

inline

Assemble PETSc matrix.

Function extract indices from entity data and assemble vector

See PETSc documentation

Parameters

M
row_data
col_data
mat
iora

Returns

MoFEMErrorCode

Definition at line 1670 of file EntitiesFieldData.hpp.

                                                                             {
  return MatSetValues<T>(M, row_data, col_data, &*mat.data().begin(), iora);
}

MatSetValues< AssemblyTypeSelector< BLOCK_MAT > >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< AssemblyTypeSelector< BLOCK_MAT > > ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const MatrixDouble &  mat, InsertMode  iora  )

inline

Definition at line 238 of file Schur.hpp.

                     {
  return MatSetValues<BlockStructure>(M, row_data, col_data, mat, iora);
}

MatSetValues< AssemblyTypeSelector< BLOCK_PRECONDITIONER_SCHUR > >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< AssemblyTypeSelector< BLOCK_PRECONDITIONER_SCHUR > > ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const MatrixDouble &  mat, InsertMode  iora  )

inline

Definition at line 311 of file Schur.hpp.

                     {
  return MatSetValues<SchurElemMatsPreconditionedBlock>(M, row_data, col_data,
                                                        mat, iora);
}

MatSetValues< AssemblyTypeSelector< BLOCK_SCHUR > >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< AssemblyTypeSelector< BLOCK_SCHUR > > ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const MatrixDouble &  mat, InsertMode  iora  )

inline

Definition at line 279 of file Schur.hpp.

                     {
  return MatSetValues<SchurElemMatsBlock>(M, row_data, col_data, mat, iora);
}

MatSetValues< AssemblyTypeSelector< PETSC > >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< AssemblyTypeSelector< PETSC > > ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const double *  ptr, InsertMode  iora  )

inline

Definition at line 117 of file FormsIntegrators.hpp.

                     {
  return MatSetValues<EssentialBcStorage>(M, row_data, col_data, ptr, iora);
}

MatSetValues< AssemblyTypeSelector< SCHUR > >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< AssemblyTypeSelector< SCHUR > >	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 2283 of file Schur.cpp.

                     {
  return MatSetValues<SchurElemMats>(M, row_data, col_data, mat, iora);
}

MatSetValues< BlockStructure >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< BlockStructure >	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 2293 of file Schur.cpp.

                                                                       {
  return shell_block_mat_asmb_wrap(M, row_data, col_data, mat, iora);
}

MatSetValues< EntityStorage >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< EntityStorage > ( Mat  M, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const double *  ptr, InsertMode  iora  )

inline

Definition at line 1679 of file EntitiesFieldData.hpp.

                                                                {
  return MatSetValues(
      M, row_data.getIndices().size(), &*row_data.getIndices().begin(),
      col_data.getIndices().size(), &*col_data.getIndices().begin(), ptr, iora);
}

MatSetValues< EssentialBcStorage >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< EssentialBcStorage >	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const double *	ptr,
		InsertMode	iora
	)

Set values to matrix in operator.

See MoFEM::VecSetValues<EssentialBcStorage> for explanation.

Parameters

M
row_data
col_data
ptr
iora

Returns

MoFEMErrorCode

Parameters

M
row_data
col_data
ptr
iora

Returns

MoFEMErrorCode

Definition at line 112 of file FormsIntegrators.cpp.

                     {
 
  if(!M)
    SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
            "Pointer to PETSc matrix is null");
 
  if (!row_data.getFieldEntities().empty()) {
    if (auto e_ptr = row_data.getFieldEntities()[0]) {
      if (auto stored_data_ptr =
              e_ptr->getSharedStoragePtr<EssentialBcStorage>()) {
        return ::MatSetValues(M, stored_data_ptr->entityIndices.size(),
                              &*stored_data_ptr->entityIndices.begin(),
                              col_data.getIndices().size(),
                              &*col_data.getIndices().begin(), ptr, iora);
      }
    }
  }
  return ::MatSetValues(
      M, row_data.getIndices().size(), &*row_data.getIndices().begin(),
      col_data.getIndices().size(), &*col_data.getIndices().begin(), ptr, iora);
}

MatSetValues< SchurElemMats >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< SchurElemMats >	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 2249 of file Schur.cpp.

                                                                      {
  return SchurElemMats::MatSetValues(M, row_data, col_data, mat, iora);
}

MatSetValues< SchurElemMatsBlock >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< SchurElemMatsBlock >	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 2325 of file Schur.cpp.

                                                                           {
  return SchurElemMatsBlock::MatSetValues(M, row_data, col_data, mat, iora);
}

MatSetValues< SchurElemMatsPreconditionedBlock >()

template<>

MoFEMErrorCode MoFEM::MatSetValues< SchurElemMatsPreconditionedBlock >	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 2356 of file Schur.cpp.

                     {
  return SchurElemMatsPreconditionedBlock::MatSetValues(M, row_data, col_data,
                                                        mat, iora);
}

min_non_abs()

static auto MoFEM::min_non_abs ( const double  a, const double  b  )

static

Definition at line 16 of file NodeMerger.cpp.

                                                        {
  return std::min(a, b);
};

moab2med_element_type()

static std::vector<med_geometrie_element> MoFEM::moab2med_element_type ( const EntityType  type )

static

Definition at line 213 of file MedInterface.cpp.

                                             {
 
  std::vector<med_geometrie_element> types;
 
  switch (type) {
  case MBEDGE:
    types.push_back(MED_SEG2);
    types.push_back(MED_SEG3);
    break;
  case MBTRI:
    types.push_back(MED_TRIA3);
    types.push_back(MED_TRIA6);
    break;
  case MBQUAD:
    types.push_back(MED_QUAD4);
    break;
  case MBTET:
    types.push_back(MED_TETRA4);
    types.push_back(MED_TETRA10);
    break;
  case MBHEX:
    types.push_back(MED_HEXA8);
    break;
  case MBPRISM:
    types.push_back(MED_PENTA6);
    break;
  case MBPYRAMID:
    types.push_back(MED_PYRA5);
    break;
  case MBVERTEX:
    // Not Currently Used
    //types.push_back(MED_POINT1);
    break;
  default:
    break;
  }
 
  return types;
}

MoFEMSNESMonitorFields()

MoFEMErrorCode MoFEM::MoFEMSNESMonitorFields	(	SNES	snes,
		PetscInt	its,
		PetscReal	fgnorm,
		SnesCtx *	snes_ctx
	)

Sens monitor printing residual field by field.

Examples

adolc_plasticity.cpp, free_surface.cpp, plastic.cpp, seepage.cpp, and thermo_elastic.cpp.

Definition at line 232 of file SnesCtx.cpp.

                                                         {
  MoFEMFunctionBegin;
  auto &m_field =  snes_ctx->mField;
  auto problem_ptr = m_field.get_problem(snes_ctx->problemName);
  auto fields_ptr = m_field.get_fields();
  auto dofs = problem_ptr->numeredRowDofsPtr;
 
  std::vector<double> lnorms(fields_ptr->size(), 0),
      norms(fields_ptr->size(), 0);
 
  Vec res;
  CHKERR SNESGetFunction(snes, &res, NULL, NULL);
 
  const double *r;
  CHKERR VecGetArrayRead(res, &r);
  {
    int f = 0;
    for (auto fi : *fields_ptr) {
      const auto lo_uid = FieldEntity::getLoBitNumberUId(fi->bitNumber);
      const auto hi_uid = FieldEntity::getHiBitNumberUId(fi->bitNumber);
      const auto hi = dofs->get<Unique_mi_tag>().upper_bound(hi_uid);
      for (auto lo = dofs->get<Unique_mi_tag>().lower_bound(lo_uid); lo != hi;
           ++lo) {
        const DofIdx loc_idx = (*lo)->getPetscLocalDofIdx();
        if (loc_idx >= 0 && loc_idx < problem_ptr->nbLocDofsRow) {
          lnorms[f] += PetscRealPart(PetscSqr(r[loc_idx]));
        }
      }
      ++f;
    }
  }
  CHKERR VecRestoreArrayRead(res, &r);
 
  MPIU_Allreduce(&*lnorms.begin(), &*norms.begin(), lnorms.size(), MPIU_REAL,
                 MPIU_SUM, PetscObjectComm((PetscObject)snes));
 
  std::stringstream s;
  int tl;
  CHKERR PetscObjectGetTabLevel((PetscObject)snes, &tl);
  for (auto t = 0; t != tl; ++t)
    s << "  ";
  s << its << " Function norm " << boost::format("%14.12e") % (double)fgnorm
    << " [";
  {
    int f = 0;
    for (auto fi : *fields_ptr) {
      if (f > 0)
        s << ", ";
      s << boost::format("%14.12e") % (double)PetscSqrtReal(norms[f]);
      ++f;
    }
    s << "]";
  }
 
  MOFEM_LOG("SNES_WORLD", Sev::inform) << s.str();
 
  MoFEMFunctionReturn(0);
}

mult()

static PetscErrorCode MoFEM::mult ( Mat  mat, Vec  x, Vec  y  )

static

Definition at line 1199 of file Schur.cpp.

                                                  {
  BlockStructure *ctx;
  CHKERR MatShellGetContext(mat, (void **)&ctx);
  return mult_schur_block_shell(
      mat, x, y, INSERT_VALUES,
 
      [](DiagBlockIndex::BlockIndex::nth_index<0>::type::iterator it) {
        return it->getMatShift();
      },
 
      ctx->dataBlocksPtr, true);
}

mult_add()

static PetscErrorCode MoFEM::mult_add ( Mat  mat, Vec  x, Vec  y  )

static

Definition at line 1211 of file Schur.cpp.

                                                      {
  BlockStructure *ctx;
  CHKERR MatShellGetContext(mat, (void **)&ctx);
  return mult_schur_block_shell(
      mat, x, y, ADD_VALUES,
 
      [](DiagBlockIndex::BlockIndex::nth_index<0>::type::iterator it) {
        return it->getMatShift();
      },
 
      ctx->dataBlocksPtr, true);
}

mult_schur_block_shell()

static MoFEMErrorCode MoFEM::mult_schur_block_shell ( Mat  mat, Vec  x, Vec  y, InsertMode  iora, boost::function< int(DiagBlockIndex::BlockIndex::nth_index< 0 >::type::iterator)>  shift_extractor, boost::shared_ptr< std::vector< double >>  data_blocks_ptr, bool  multiply_by_preconditioner  )

static

Definition at line 1415 of file Schur.cpp.

                                     {
  MoFEMFunctionBegin;
  BlockStructure *ctx;
  CHKERR MatShellGetContext(mat, (void **)&ctx);
 
  PetscLogEventBegin(SchurEvents::MOFEM_EVENT_BlockStructureMult, 0, 0, 0, 0);
 
  int x_loc_size;
  CHKERR VecGetLocalSize(x, &x_loc_size);
  int y_loc_size;
  CHKERR VecGetLocalSize(y, &y_loc_size);
 
  Vec ghost_x = ctx->ghostX;
  Vec ghost_y = ctx->ghostY;
 
  CHKERR VecCopy(x, ghost_x);
 
  double *y_array;
  Vec loc_ghost_y;
  CHKERR VecGhostGetLocalForm(ghost_y, &loc_ghost_y);
  int nb_y;
  CHKERR VecGetLocalSize(loc_ghost_y, &nb_y);
  CHKERR VecGetArray(loc_ghost_y, &y_array);
  for (auto i = 0; i != nb_y; ++i)
    y_array[i] = 0.;
  CHKERR VecRestoreArray(loc_ghost_y, &y_array);
  CHKERR VecGhostRestoreLocalForm(ghost_y, &loc_ghost_y);
 
  auto mult = [&](int low_x, int hi_x, int low_y, int hi_y) {
    MoFEMFunctionBegin;
 
    double *x_array;
    Vec loc_ghost_x;
    CHKERR VecGhostGetLocalForm(ghost_x, &loc_ghost_x);
    CHKERR VecGetArray(loc_ghost_x, &x_array);
 
    double *y_array;
    Vec loc_ghost_y;
    CHKERR VecGhostGetLocalForm(ghost_y, &loc_ghost_y);
    int nb_y;
    CHKERR VecGetLocalSize(loc_ghost_y, &nb_y);
    CHKERR VecGetArray(loc_ghost_y, &y_array);
 
    double *block_ptr = &*data_blocks_ptr->begin();
    auto it = ctx->blockIndex.get<0>().begin();
    auto hi = ctx->blockIndex.get<0>().end();
 
    while (it != hi) {
      if (it->getLocRow() < low_y || it->getLocRow() >= hi_y ||
          it->getLocCol() < low_x || it->getLocCol() >= hi_x) {
        ++it;
        continue;
      }
 
      auto nb_rows = it->getNbRows();
      auto nb_cols = it->getNbCols();
      auto x_ptr = &x_array[it->getLocCol()];
      auto y_ptr = &y_array[it->getLocRow()];
      auto ptr = &block_ptr[shift_extractor(it)];
 
      if (std::min(nb_rows, nb_cols) > max_gemv_size) {
        cblas_dgemv(CblasRowMajor, CblasNoTrans, nb_rows, nb_cols, 1.0, ptr,
                    nb_cols, x_ptr, 1, 1.0, y_ptr, 1);
      } else {
        for (auto r = 0; r != nb_rows; ++r) {
          for (auto c = 0; c != nb_cols; ++c) {
            y_ptr[r] += ptr[r * nb_cols + c] * x_ptr[c];
          }
        }
      }
      ++it;
    }
 
    if (multiply_by_preconditioner && ctx->multiplyByPreconditioner) {
 
      if (!ctx->preconditionerBlocksPtr)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "No parentBlockStructurePtr");
 
      auto preconditioner_ptr = &*ctx->preconditionerBlocksPtr->begin();
 
      auto it = ctx->blockIndex.get<0>().begin();
      auto hi = ctx->blockIndex.get<0>().end();
 
      while (it != hi) {
        if (it->getLocRow() < low_y || it->getLocRow() >= hi_y ||
            it->getLocCol() < low_x || it->getLocCol() >= hi_x) {
          ++it;
          continue;
        }
 
        if (it->getMatShift() != -1) {
          auto nb_rows = it->getNbRows();
          auto nb_cols = it->getNbCols();
          auto x_ptr = &x_array[it->getLocCol()];
          auto y_ptr = &y_array[it->getLocRow()];
          auto ptr = &preconditioner_ptr[it->getMatShift()];
          if (std::min(nb_rows, nb_cols) > max_gemv_size) {
            cblas_dgemv(CblasRowMajor, CblasNoTrans, nb_rows, nb_cols, 1.0, ptr,
                        nb_cols, x_ptr, 1, 1.0, y_ptr, 1);
          } else {
            for (auto r = 0; r != nb_rows; ++r) {
              for (auto c = 0; c != nb_cols; ++c) {
                y_ptr[r] += ptr[r * nb_cols + c] * x_ptr[c];
              }
            }
          }
        }
 
        ++it;
      }
    }
 
    CHKERR VecRestoreArray(loc_ghost_x, &x_array);
    CHKERR VecRestoreArray(loc_ghost_y, &y_array);
    CHKERR VecGhostRestoreLocalForm(ghost_x, &loc_ghost_x);
    CHKERR VecGhostRestoreLocalForm(ghost_y, &loc_ghost_y);
    MoFEMFunctionReturn(0);
  };
 
  constexpr auto max_int = std::numeric_limits<int>::max();
  CHKERR VecGhostUpdateBegin(ghost_x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR mult(0, x_loc_size, 0, max_int);
  CHKERR VecGhostUpdateEnd(ghost_x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR mult(x_loc_size, max_int, 0, max_int);
 
  CHKERR VecGhostUpdateBegin(ghost_y, ADD_VALUES, SCATTER_REVERSE);
  CHKERR VecGhostUpdateEnd(ghost_y, ADD_VALUES, SCATTER_REVERSE);
 
  switch (iora) {
  case INSERT_VALUES:
    CHKERR VecCopy(ghost_y, y);
    break;
  case ADD_VALUES:
    CHKERR VecAXPY(y, 1., ghost_y);
    break;
  default:
    CHK_MOAB_THROW(MOFEM_NOT_IMPLEMENTED, "Wrong InsertMode");
  }
 
#ifndef NDEBUG
 
  auto print_norm = [&](auto msg, auto y) {
    MoFEMFunctionBegin;
    PetscReal norm;
    CHKERR VecNorm(y, NORM_2, &norm);
    int nb_loc_y;
    CHKERR VecGetLocalSize(y, &nb_loc_y);
    int nb_y;
    CHKERR VecGetSize(y, &nb_y);
    MOFEM_LOG("WORLD", Sev::noisy)
        << msg << " " << nb_y << " " << nb_loc_y << " norm " << norm;
    MoFEMFunctionReturn(0);
  };
 
  switch (iora) {
  case INSERT_VALUES:
    print_norm("mult_schur_block_shell insert x", x);
    print_norm("mult_schur_block_shell insert y", y);
    break;
  case ADD_VALUES:
    print_norm("mult_schur_block_shell add x", x);
    print_norm("mult_schur_block_shell add y", y);
    break;
  default:
    CHK_MOAB_THROW(MOFEM_NOT_IMPLEMENTED, "Wrong InsertMode");
  }
 
#endif // NDEBUG
 
  // PetscLogFlops(xxx)
  PetscLogEventEnd(SchurEvents::MOFEM_EVENT_BlockStructureMult, 0, 0, 0, 0);
 
  MoFEMFunctionReturn(0);
}

operator<<() [1/40]

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

Definition at line 103 of file BCData.cpp.

                                                                         {
  os << "\n";
  os << "A c c e l e r a t i o n \n \n";
  if (e.data.flag1 == 1)
    os << "Acceleration magnitude (X-Translation): " << e.data.value1 << "\n";
  else
    os << "Acceleration magnitude (X-Translation): N/A"
       << "\n";
  if (e.data.flag2 == 1)
    os << "Acceleration magnitude (Y-Translation): " << e.data.value2 << "\n";
  else
    os << "Acceleration magnitude (Y-Translation): N/A"
       << "\n";
  if (e.data.flag3 == 1)
    os << "Acceleration magnitude (Z-Translation): " << e.data.value3 << "\n";
  else
    os << "Acceleration magnitude (Z-Translation): N/A"
       << "\n";
  if (e.data.flag4 == 1)
    os << "Acceleration magnitude (X-Rotation): " << e.data.value4 << "\n";
  else
    os << "Acceleration magnitude (X-Rotation): N/A"
       << "\n";
  if (e.data.flag5 == 1)
    os << "Acceleration magnitude (Y-Rotation): " << e.data.value5 << "\n";
  else
    os << "Acceleration magnitude (Y-Rotation): N/A"
       << "\n";
  if (e.data.flag6 == 1)
    os << "Acceleration magnitude (Z-Rotation): " << e.data.value6 << "\n \n";
  else
    os << "Acceleration magnitude (Z-Rotation): N/A"
       << "\n \n";
  return os;
}

operator<<() [2/40]

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

Definition at line 87 of file MaterialBlocks.cpp.

                                                                  {
  os << std::endl << "Block Body Forces" << std::endl;
  os << "-------------------" << std::endl;
  os << "density  = " << e.data.density << std::endl;
  os << "acceleration_x = " << e.data.acceleration_x << std::endl;
  os << "acceleration_y = " << e.data.acceleration_y << std::endl;
  os << "acceleration_z = " << e.data.acceleration_z << std::endl;
  os << "User attribute 4 = " << e.data.User4 << std::endl;
  os << "User attribute 5 = " << e.data.User5 << std::endl;
  os << "User attribute 6 = " << e.data.User6 << std::endl;
  os << "User attribute 7 = " << e.data.User7 << std::endl;
  os << "User attribute 8 = " << e.data.User8 << std::endl << std::endl;
  return os;
}

operator<<() [3/40]

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

Definition at line 8 of file MaterialBlocks.cpp.

                                                                    {
  os << std::endl << "Blcok attributes" << std::endl;
  os << "-------------------" << std::endl;
  os << "User attribute 1 = " << e.data.User1 << std::endl;
  os << "User attribute 2 = " << e.data.User2 << std::endl;
  os << "User attribute 3 = " << e.data.User3 << std::endl;
  os << "User attribute 4 = " << e.data.User4 << std::endl;
  os << "User attribute 5 = " << e.data.User5 << std::endl;
  os << "User attribute 6 = " << e.data.User6 << std::endl;
  os << "User attribute 7 = " << e.data.User7 << std::endl;
  os << "User attribute 8 = " << e.data.User7 << std::endl;
  os << "User attribute 9 = " << e.data.User7 << std::endl;
  os << "User attribute 10 = " << e.data.User10 << std::endl << std::endl;
  return os;
}

operator<<() [4/40]

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

Definition at line 199 of file BCData.cpp.

                                                                {
  os << "\n";
  os << "CFD BC \n \n";
  return os;
}

operator<<() [5/40]

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

Definition at line 360 of file BCMultiIndices.cpp.

                                                               {
  // get name of cubit meshset
  std::ostringstream ss;
  unsigned jj = 0;
  while (1 << jj != LASTSET_BC) {
    const CubitBCType jj_bc_type = 1 << jj;
    if ((e.cubitBcType & jj_bc_type).any()) {
      string bc_type_name;
      ss << " " << string(CubitBCNames[jj + 1]);
    }
    ++jj;
  }
 
  // push data to stream
  os << "meshset " << e.meshset << " type" << ss.str();
  if (e.msId != nullptr)
    os << " msId " << *(e.msId);
  if (e.tagName != nullptr) {
    os << " name " << e.getName();
  }
  if (e.tagBlockHeaderData != nullptr) {
    os << " block header: ";
    os << " blockCol = " << e.tagBlockHeaderData[0];
    os << " blockMat = " << e.tagBlockHeaderData[1];
    os << " blockDimension = " << e.tagBlockHeaderData[2];
  }
  return os;
}

operator<<() [6/40]

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

Definition at line 10 of file BCData.cpp.

                                                                         {
  os << "\n";
  os << "D i s p l a c e m e n t \n \n";
  os << "Flag for X-Translation (0/1): " << (int)e.data.flag1 << "\n";
  os << "Flag for Y-Translation (0/1): " << (int)e.data.flag2 << "\n";
  os << "Flag for Z-Translation (0/1): " << (int)e.data.flag3 << "\n";
  os << "Flag for X-Rotation (0/1): " << (int)e.data.flag4 << "\n";
  os << "Flag for Y-Rotation (0/1): " << (int)e.data.flag5 << "\n";
  os << "Flag for Z-Rotation (0/1): " << (int)e.data.flag6 << "\n \n";
 
  if (e.data.flag1 == 1)
    os << "Displacement magnitude (X-Translation): " << e.data.value1 << "\n";
  else
    os << "Displacement magnitude (X-Translation): N/A"
       << "\n";
  if (e.data.flag2 == 1)
    os << "Displacement magnitude (Y-Translation): " << e.data.value2 << "\n";
  else
    os << "Displacement magnitude (Y-Translation): N/A"
       << "\n";
  if (e.data.flag3 == 1)
    os << "Displacement magnitude (Z-Translation): " << e.data.value3 << "\n";
  else
    os << "Displacement magnitude (Z-Translation): N/A"
       << "\n";
  if (e.data.flag4 == 1)
    os << "Displacement magnitude (X-Rotation): " << e.data.value4 << "\n";
  else
    os << "Displacement magnitude (X-Rotation): N/A"
       << "\n";
  if (e.data.flag5 == 1)
    os << "Displacement magnitude (Y-Rotation): " << e.data.value5 << "\n";
  else
    os << "Displacement magnitude (Y-Rotation): N/A"
       << "\n";
  if (e.data.flag6 == 1)
    os << "Displacement magnitude (Z-Rotation): " << e.data.value6 << "\n \n";
  else
    os << "Displacement magnitude (Z-Rotation): N/A"
       << "\n \n";
  return os;
}

operator<<() [7/40]

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

Definition at line 39 of file DofsMultiIndices.cpp.

                                                           {
  os << "dof_uid " << e.getLocalUniqueId() << " dof_order " << e.getDofOrder()
     << " dof_rank " << e.getDofCoeffIdx() << " dof " << e.getEntDofIdx()
     << " active " << (e.dof < 0 ? false : true) << " "
     << *e.getFieldEntityPtr();
  return os;
}

operator<<() [8/40]

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

Definition at line 424 of file FEMultiIndices.cpp.

                                                                  {
  os << *e.getFiniteElementPtr() << std::endl;
  os << *e.sPtr;
  return os;
}

operator<<() [9/40]

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

Definition at line 270 of file EntitiesFieldData.cpp.

                                                                   {
  for (EntityType t = MBVERTEX; t != MBMAXTYPE; ++t) {
    for (unsigned int nn = 0; nn < e.dataOnEntities[t].size(); nn++) {
      os << "dataOnEntities[" << moab::CN::EntityTypeName(t) << "][" << nn
         << "]" << std::endl
         << e.dataOnEntities[t][nn] << std::endl;
    }
  }
  return os;
}

operator<<() [10/40]

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

Definition at line 240 of file EntitiesFieldData.cpp.

                                                            {
  os << "sEnse: " << e.getSense() << std::endl
     << "oRder: " << e.getOrder() << std::endl
     << "global indices: " << e.getIndices() << std::endl
     << "local indices: " << e.getLocalIndices() << std::endl;
  // FIXME: precision should not be set here
  os << "fieldData: " << std::fixed << std::setprecision(2) << e.getFieldData()
     << std::endl;
  MatrixDouble base = const_cast<EntitiesFieldData::EntData &>(e).getN();
  MatrixDouble diff_base =
      const_cast<EntitiesFieldData::EntData &>(e).getDiffN();
  const double eps = 1e-6;
  for (unsigned int ii = 0; ii != base.size1(); ii++) {
    for (unsigned int jj = 0; jj != base.size2(); jj++) {
      if (fabs(base(ii, jj)) < eps)
        base(ii, jj) = 0;
    }
  }
  for (unsigned int ii = 0; ii != diff_base.size1(); ii++) {
    for (unsigned int jj = 0; jj != diff_base.size2(); jj++) {
      if (fabs(diff_base(ii, jj)) < eps)
        diff_base(ii, jj) = 0;
    }
  }
  os << "N: " << std::fixed << base << std::endl
     << "diffN: " << std::fixed << diff_base;
  return os;
}

operator<<() [11/40]

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

Definition at line 84 of file DofsMultiIndices.cpp.

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

operator<<() [12/40]

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

Definition at line 93 of file DofsMultiIndices.cpp.

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

operator<<() [13/40]

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

Definition at line 551 of file FieldMultiIndices.cpp.

                                                       {
  os << e.getNameRef() << " field_id " << e.getId().to_ulong() << " space "
     << e.getSpaceName() << " field continuity " << e.getContinuityName()
     << " approximation base " << e.getApproxBaseName() << " nb coefficients "
     << e.getNbOfCoeffs() << " meshset " << e.meshSet;
  return os;
}

operator<<() [14/40]

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

Definition at line 54 of file FieldEntsMultiIndices.cpp.

                                                             {
  os << "ent_global_uid " << e.getLocalUniqueId() << " entity " << e.getEnt()
     << " type " << e.getEntTypeName() << " pstatus "
     << std::bitset<8>(e.getPStatus()) << " owner handle " << e.getOwnerEnt()
     << " owner proc " << e.getOwnerProc() << " order " << e.getMaxOrder()
     << " " << *e.getFieldRawPtr();
  return os;
}

operator<<() [15/40]

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

Definition at line 566 of file FieldMultiIndices.cpp.

                                                                           {
  os << "byWhat " << std::bitset<3>(e.byWhat) << " " << *e.entFieldPtr
     << std::endl
     << *e.entFePtr->getFiniteElementPtr();
  return os;
}

operator<<() [16/40]

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

Definition at line 323 of file SeriesMultiIndices.cpp.

                                                             {
  os << "name " << e.getName() << " meshset " << e.getMeshset();
  return os;
}

operator<<() [17/40]

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

Definition at line 328 of file SeriesMultiIndices.cpp.

                                                                 {
  os << *(e.get_FieldSeries_ptr()) << " step number " << e.step_number
     << " time " << e.get_time();
  return os;
}

operator<<() [18/40]

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

Definition at line 362 of file FEMultiIndices.cpp.

                                                               {
  os << e.getNameRef() << " fe_id " << e.getId().to_ulong() << " f_id_row "
     << e.getBitFieldIdRow() << " f_id_col " << e.getBitFieldIdCol()
     << " BitFEId_data " << e.getBitFieldIdData();
  return os;
}

operator<<() [19/40]

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

Definition at line 53 of file BCData.cpp.

                                                                  {
  os << "\n";
  os << "F o r c e \n \n";
  os << "Force magnitude: " << e.data.value1 << "\n";
  os << "Moment magnitude: " << e.data.value2 << "\n";
  os << "Force direction vector (X-component): " << e.data.value3 << "\n";
  os << "Force direction vector (Y-component): " << e.data.value4 << "\n";
  os << "Force direction vector (Z-component): " << e.data.value5 << "\n";
  os << "Moment direction vector (X-component): " << e.data.value6 << "\n";
  os << "Moment direction vector (Y-component): " << e.data.value7 << "\n";
  os << "Moment direction vector (Z-component): " << e.data.value8 << "\n \n";
  return os;
}

operator<<() [20/40]

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

Definition at line 178 of file BCData.cpp.

                                                                     {
  os << "\n";
  os << "H e a t  F l u x \n \n";
  if (e.data.flag1 == 1)
    os << "Heat flux value: " << e.data.value1 << "\n";
  else
    os << "Heat flux is applied on thin shells"
       << "\n";
  if (e.data.flag2 == 1)
    os << "Heat flux value (thin shell top): " << e.data.value2 << "\n";
  else
    os << "Heat flux value (thin shell top): N/A"
       << "\n";
  if (e.data.flag3 == 1)
    os << "Heat flux value (thin shell bottom): " << e.data.value3 << "\n \n";
  else
    os << "Heat flux value (thin shell bottom): N/A"
       << "\n \n";
  return os;
}

operator<<() [21/40]

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

Definition at line 24 of file MaterialBlocks.cpp.

                                                             {
  os << std::endl << "Material Properties" << std::endl;
  os << "-------------------" << std::endl;
  os << "Young's modulus  = " << e.data.Young << std::endl;
  os << "Poisson's ratio  = " << e.data.Poisson << std::endl;
  os << "Thermal expansion = " << e.data.ThermalExpansion << std::endl;
  os << "User attribute 1 = " << e.data.User1 << std::endl;
  os << "User attribute 2 = " << e.data.User2 << std::endl;
  os << "User attribute 3 = " << e.data.User3 << std::endl;
  os << "User attribute 4 = " << e.data.User4 << std::endl;
  os << "User attribute 5 = " << e.data.User5 << std::endl;
  os << "User attribute 6 = " << e.data.User6 << std::endl;
  os << "User attribute 7 = " << e.data.User7 << std::endl << std::endl;
  return os;
}

operator<<() [22/40]

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

Definition at line 40 of file MaterialBlocks.cpp.

                                                                  {
  os << std::endl << "Material Properties" << std::endl;
  os << "-------------------" << std::endl;
  os << "Young's modulus  = " << e.data.Young << std::endl;
  os << "Poisson's ratio  = " << e.data.Poisson << std::endl;
  os << "k1 = " << e.data.k1 << std::endl;
  os << "k2 = " << e.data.k2 << std::endl;
  os << "a0_x = " << e.data.a0x << std::endl;
  os << "a0_y = " << e.data.a0y << std::endl;
  os << "a0_z = " << e.data.a0z << std::endl;
  os << "a1_x = " << e.data.a1x << std::endl;
  os << "a1_y = " << e.data.a1y << std::endl;
  os << "a1_Z = " << e.data.a1z << std::endl << std::endl;
  return os;
}

operator<<() [23/40]

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

Definition at line 102 of file MaterialBlocks.cpp.

                                                                      {
  os << std::endl << "Material Properties" << std::endl;
  os << "-------------------" << std::endl;
  os << "Young's modulus in xy plane (Ep)     = " << e.data.Youngp << std::endl;
  os << "Young's modulus in z-direction (Ez)  = " << e.data.Youngz << std::endl;
  os << "Poisson's ratio in xy plane (vp)     = " << e.data.Poissonp
     << std::endl;
  os << "Poisson's ratio in z-direction (vpz) = " << e.data.Poissonpz
     << std::endl;
  os << "Shear modulus in z-direction (Gzp)   = " << e.data.Shearzp << std::endl
     << std::endl;
  return os;
}

operator<<() [24/40]

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

Definition at line 116 of file MaterialBlocks.cpp.

                                                            {
  os << std::endl << "Material Properties" << std::endl;
  os << "-------------------" << std::endl;
  os << "Elastic module = " << e.data.alpha << std::endl << std::endl;
  os << "Damage coupling    = " << e.data.beta << std::endl << std::endl;
  os << "Strengh        = " << e.data.ft << std::endl << std::endl;
  os << "Fracture energy    = " << e.data.Gf << std::endl << std::endl;
 
  return os;
}

operator<<() [25/40]

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

Definition at line 72 of file MaterialBlocks.cpp.

                                                              {
  os << std::endl << "Material Properties" << std::endl;
  os << "-------------------" << std::endl;
  os << "Diffusivity  = " << e.data.Diffusivity << std::endl;
  os << "Viscosity = " << e.data.Viscosity << std::endl;
  os << "Permeability = " << e.data.Permeability << std::endl;
  os << "User attribute 3 = " << e.data.User3 << std::endl;
  os << "User attribute 4 = " << e.data.User4 << std::endl;
  os << "User attribute 5 = " << e.data.User5 << std::endl;
  os << "User attribute 6 = " << e.data.User6 << std::endl;
  os << "User attribute 7 = " << e.data.User7 << std::endl;
  os << "User attribute 8 = " << e.data.User8 << std::endl << std::endl;
  return os;
}

operator<<() [26/40]

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

Definition at line 57 of file MaterialBlocks.cpp.

                                                             {
  os << std::endl << "Material Properties" << std::endl;
  os << "-------------------" << std::endl;
  os << "Conductivity  = " << e.data.Conductivity << std::endl;
  os << "User attribute 1 = " << e.data.HeatCapacity << std::endl;
  os << "User attribute 2 = " << e.data.User2 << std::endl;
  os << "User attribute 3 = " << e.data.User3 << std::endl;
  os << "User attribute 4 = " << e.data.User4 << std::endl;
  os << "User attribute 5 = " << e.data.User5 << std::endl;
  os << "User attribute 6 = " << e.data.User6 << std::endl;
  os << "User attribute 7 = " << e.data.User7 << std::endl;
  os << "User attribute 8 = " << e.data.User8 << std::endl << std::endl;
  return os;
}

operator<<() [27/40]

std::ostream & MoFEM::operator<<	(	std::ostream &	os,
		const MedInterface::FieldData &	field_data
	)

Definition at line 1258 of file MedInterface.cpp.

                                                                  {
  os << "field name: " << field_data.fieldName;
  os << " mesh name: " << field_data.meshName;
  os << " local mesh: " << ((field_data.localMesh) ? "true" : "false");
  os << std::endl;
  // os << " field type: ";
  // switch (field_data.fieldType) {
  //   case MED_FLOAT64: os << "MED_FLOAT64"; break;
  //   case MED_INT32: os << "MED_INT32"; break;
  //   case MED_INT64: os << "MED_INT64"; break;
  //   case MED_INT: os << "MED_INT"; break;
  // };
  os << " componentNames:";
  for (unsigned int ff = 0; ff != field_data.componentNames.size(); ff++) {
    os << " " << field_data.componentNames[ff];
  }
  os << std::endl;
  os << " componentUnits:";
  for (unsigned int ff = 0; ff != field_data.componentUnits.size(); ff++) {
    os << " " << field_data.componentUnits[ff];
  }
  os << std::endl;
  os << " dtUnit: " << field_data.dtUnit << endl;
  os << " number of steps: " << field_data.ncSteps;
  return os;
}

operator<<() [28/40]

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

Definition at line 77 of file DofsMultiIndices.cpp.

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

operator<<() [29/40]

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

Definition at line 487 of file FEMultiIndices.cpp.

                                                                         {
  os << "part " << e.part << " " << *(e.getEntFiniteElement());
  return os;
}

operator<<() [30/40]

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

Definition at line 170 of file BCData.cpp.

                                                                     {
  os << "\n";
  os << "P r e s s u r e \n \n";
  os << "Pressure flag2: " << (int)e.data.flag2 << "\n";
  os << "Pressure value: " << e.data.value1 << "\n \n";
  return os;
}

operator<<() [31/40]

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

Definition at line 37 of file ProblemsMultiIndices.cpp.

                                                         {
  os << "Problem id " << e.getId() << " name " << e.getName() << endl;
  os << "FiniteElement id " << e.getBitFEId() << endl;
  os << "BitRefLevel " << e.getBitRefLevel() << endl;
  os << "BitRefLevelMask " << e.getBitRefLevelMask();
  return os;
}

operator<<() [32/40]

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

Definition at line 18 of file RefElementMultiIndices.cpp.

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

operator<<() [33/40]

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

Definition at line 452 of file RefElementMultiIndices.cpp.

                                                                 {
  os << *e.sPtr;
  return os;
}

operator<<() [34/40]

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

Definition at line 488 of file RefElementMultiIndices.cpp.

                                                                   {
  os << *e.sPtr;
  return os;
}

operator<<() [35/40]

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

Definition at line 408 of file RefElementMultiIndices.cpp.

                                                                {
  os << *e.sPtr;
  return os;
}

operator<<() [36/40]

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

Definition at line 332 of file RefElementMultiIndices.cpp.

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

operator<<() [37/40]

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

Definition at line 46 of file RefEntsMultiIndices.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 << " ent type " << e.getEntTypeName();
  os << " ent parent type " << e.getParentEntType();
  return os;
}

operator<<() [38/40]

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

Definition at line 139 of file BCData.cpp.

                                                                        {
  os << "\n";
  os << "T e m p e r a t u r e \n \n";
  if (e.data.flag1 == 1)
    os << "Temperature: " << e.data.value1 << "\n";
  else
    os << "Temperature (default case): N/A"
       << "\n";
  if (e.data.flag2 == 1)
    os << "Temperature (thin shell middle): " << e.data.value2 << "\n";
  else
    os << "Temperature (thin shell middle): N/A"
       << "\n";
  if (e.data.flag3 == 1)
    os << "Temperature (thin shell gradient): " << e.data.value3 << "\n";
  else
    os << "Temperature (thin shell gradient): N/A"
       << "\n";
  if (e.data.flag4 == 1)
    os << "Temperature (thin shell top): " << e.data.value4 << "\n";
  else
    os << "Temperature (thin shell top): N/A"
       << "\n";
  if (e.data.flag5 == 1)
    os << "Temperature (thin shell bottom): " << e.data.value5 << "\n \n";
  else
    os << "Temperature (thin shell bottom): N/A"
       << "\n \n";
  return os;
}

operator<<() [39/40]

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

Definition at line 67 of file BCData.cpp.

                                                                     {
  os << "\n";
  os << "V e l o c i t y \n \n";
  if (e.data.flag1 == 1)
    os << "Velocity magnitude (X-Translation): " << e.data.value1 << "\n";
  else
    os << "Velocity magnitude (X-Translation): N/A"
       << "\n";
  if (e.data.flag2 == 1)
    os << "Velocity magnitude (Y-Translation): " << e.data.value2 << "\n";
  else
    os << "Velocity magnitude (Y-Translation): N/A"
       << "\n";
  if (e.data.flag3 == 1)
    os << "Velocity magnitude (Z-Translation): " << e.data.value3 << "\n";
  else
    os << "Velocity magnitude (Z-Translation): N/A"
       << "\n";
  if (e.data.flag4 == 1)
    os << "Velocity magnitude (X-Rotation): " << e.data.value4 << "\n";
  else
    os << "Velocity magnitude (X-Rotation): N/A"
       << "\n";
  if (e.data.flag5 == 1)
    os << "Velocity magnitude (Y-Rotation): " << e.data.value5 << "\n";
  else
    os << "Velocity magnitude (Y-Rotation): N/A"
       << "\n";
  if (e.data.flag6 == 1)
    os << "Velocity magnitude (Z-Rotation): " << e.data.value6 << "\n \n";
  else
    os << "Velocity magnitude (Z-Rotation): N/A"
       << "\n \n";
  return os;
}

operator<<() [40/40]

std::ostream & MoFEM::operator<<	(	std::ostream &	strm,
		const LogManager::SeverityLevel &	level
	)

Definition at line 26 of file LogManager.cpp.

                                                               {
 
  strm << "<" << LogManager::severityStrings[level] << "> ";
 
  return strm;
}

PCMGSetUpViaApproxOrders()

MoFEMErrorCode MoFEM::PCMGSetUpViaApproxOrders	(	PC	pc,
		boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx >	ctx,
		int	verb = 0
	)

Function build MG structure.

Parameters

pc	MG pre-conditioner http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/PC/PCMG.html
ctx	MoFEM data structure for MG
verb	verbosity level

Returns

error code

Examples

elasticity.cpp, and test_broken_space.cpp.

Definition at line 634 of file PCMGSetUpViaApproxOrders.cpp.

                                                                       {
 
  PetscValidHeaderSpecific(pc, PC_CLASSID, 1);
  MoFEMFunctionBegin;
 
  auto core_log = logging::core::get();
  core_log->add_sink(LogManager::createSink(LogManager::getStrmWorld(),
                                            "PCMGViaApproximationOrders"));
  LogManager::setLog("PCMGViaApproximationOrders");
  MOFEM_LOG_TAG("PCMGViaApproximationOrders", "PCMGViaApproximationOrders");
 
  MOFEM_LOG("PCMGViaApproximationOrders", Sev::verbose)
      << "Setup PCMGSetUpViaApproxOrders";
 
  CHKERR ctx->getOptions();
  CHKERR ctx->buildProlongationOperator(true, verb);
 
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR PCMGSetGalerkin(pc, PC_MG_GALERKIN_NONE);
#else
  CHKERR PCMGSetGalerkin(pc, PETSC_FALSE);
#endif
 
  CHKERR PCMGSetLevels(pc, ctx->nbLevels, NULL);
 
  MOFEM_LOG("PCMGViaApproximationOrders", Sev::noisy)
      << "Setup PCMGSetUpViaApproxOrders <- end";
 
  MoFEMFunctionReturn(0);
}

PetscOptionsGetBool()

PetscErrorCode MoFEM::PetscOptionsGetBool ( PetscOptions *  , const char  pre[], const char  name[], PetscBool *  bval, PetscBool *  set  )

inline

Examples

adolc_plasticity.cpp, ADOLCPlasticity.hpp, dm_build_partitioned_mesh.cpp, dynamic_first_order_con_law.cpp, eigen_elastic.cpp, EshelbianPlasticity.cpp, forces_and_sources_testing_users_base.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, helmholtz.cpp, nonlinear_dynamics.cpp, NonlinearElasticElementInterface.hpp, photon_diffusion.cpp, plastic.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, shallow_wave.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, testing_jacobian_of_hook_scaled_with_density_element.cpp, thermo_elastic.cpp, and unsaturated_transport.cpp.

Definition at line 182 of file DeprecatedPetsc.hpp.

                                                          {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetBool(pre, name, bval, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetEList()

PetscErrorCode MoFEM::PetscOptionsGetEList ( PetscOptions *  , const char  pre[], const char  name[], const char *const *  list, PetscInt  next, PetscInt *  value, PetscBool *  set  )

inline

Examples

adolc_plasticity.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, continuity_check_on_skeleton_with_simple_2d_for_h1.cpp, continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp, continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp, dynamic_first_order_con_law.cpp, ep.cpp, forces_and_sources_testing_edge_element.cpp, free_surface.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hcurl_divergence_operator_2d.cpp, hdiv_check_approx_in_3d.cpp, hdiv_divergence_operator.cpp, nonlinear_dynamics.cpp, plot_base.cpp, quad_polynomial_approximation.cpp, scalar_check_approximation.cpp, tensor_divergence_operator.cpp, and test_broken_space.cpp.

Definition at line 203 of file DeprecatedPetsc.hpp.

                                                           {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetEList(pre, name, list, next, value, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetInt()

PetscErrorCode MoFEM::PetscOptionsGetInt ( PetscOptions *  , const char  pre[], const char  name[], PetscInt *  ivalue, PetscBool *  set  )

inline

Examples

adolc_plasticity.cpp, approx_sphere.cpp, boundary_marker.cpp, dm_build_partitioned_mesh.cpp, dynamic_first_order_con_law.cpp, eigen_elastic.cpp, field_blas.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, hcurl_divergence_operator_2d.cpp, heat_equation.cpp, helmholtz.cpp, mixed_poisson.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, NonlinearElasticElementInterface.hpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, PlasticOpsMonitor.hpp, plate.cpp, plot_base.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, reaction_diffusion.cpp, scalar_check_approximation.cpp, schur_test_diag_mat.cpp, seepage.cpp, shallow_wave.cpp, tensor_divergence_operator.cpp, test_broken_space.cpp, thermo_elastic.cpp, and wave_equation.cpp.

Definition at line 142 of file DeprecatedPetsc.hpp.

                                                         {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetInt(pre, name, ivalue, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetIntArray()

PetscErrorCode MoFEM::PetscOptionsGetIntArray ( PetscOptions  options, const char  pre[], const char  name[], PetscInt  dvalue[], PetscInt *  nmax, PetscBool *  set  )

inline

Definition at line 215 of file DeprecatedPetsc.hpp.

                                                              {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetIntArray(pre, name, dvalue, nmax, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetReal()

PetscErrorCode MoFEM::PetscOptionsGetReal ( PetscOptions *  , const char  pre[], const char  name[], PetscReal *  dval, PetscBool *  set  )

inline

Examples

dynamic_first_order_con_law.cpp, and mixed_poisson.cpp.

Definition at line 152 of file DeprecatedPetsc.hpp.

                                                          {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetReal(pre, name, dval, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetRealArray()

PetscErrorCode MoFEM::PetscOptionsGetRealArray ( PetscOptions *  , const char  pre[], const char  name[], PetscReal  dval[], PetscInt *  nmax, PetscBool *  set  )

inline

Examples

dynamic_first_order_con_law.cpp, elasticity.cpp, seepage.cpp, and thermo_elastic.cpp.

Definition at line 192 of file DeprecatedPetsc.hpp.

                                                               {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetRealArray(pre, name, dval, nmax, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetScalar()

PetscErrorCode MoFEM::PetscOptionsGetScalar ( PetscOptions *  , const char  pre[], const char  name[], PetscScalar *  dval, PetscBool *  set  )

inline

Examples

adolc_plasticity.cpp, ADOLCPlasticityMaterialModels.hpp, eigen_elastic.cpp, ep.cpp, EshelbianPlasticity.cpp, free_surface.cpp, helmholtz.cpp, phase.cpp, photon_diffusion.cpp, plastic.cpp, plate.cpp, poisson_2d_dis_galerkin.cpp, schur_test_diag_mat.cpp, seepage.cpp, and thermo_elastic.cpp.

Definition at line 162 of file DeprecatedPetsc.hpp.

                                                                               {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetScalar(pre, name, dval, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetScalarArray()

PetscErrorCode MoFEM::PetscOptionsGetScalarArray ( PetscOptions  options, const char  pre[], const char  name[], PetscScalar  dvalue[], PetscInt *  nmax, PetscBool *  set  )

inline

Definition at line 228 of file DeprecatedPetsc.hpp.

                                                           {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetScalarArray(pre, name, dvalue, nmax, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

PetscOptionsGetString()

PetscErrorCode MoFEM::PetscOptionsGetString ( PetscOptions *  , const char  pre[], const char  name[], char  str[], size_t  size, PetscBool *  set  )

inline

Examples

build_large_problem.cpp, build_problems.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, cubit_bc_test.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, edge_and_bubble_shape_functions_on_quad.cpp, ep.cpp, EshelbianPlasticity.cpp, field_blas.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, hcurl_divergence_operator_2d.cpp, mesh_insert_interface_atom.cpp, node_merge.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, partition_mesh.cpp, phase.cpp, photon_diffusion.cpp, plot_base.cpp, prism_elements_from_surface.cpp, remove_entities_from_problem.cpp, and remove_entities_from_problem_not_partitioned.cpp.

Definition at line 172 of file DeprecatedPetsc.hpp.

                                                                         {
  PetscErrorCode ierr;
  MoFEMFunctionBeginHot;
  ierr = ::PetscOptionsGetString(pre, name, str, size, set);
  CHKERRQ(ierr);
  MoFEMFunctionReturnHot(0);
}

prism_type_1()

MoFEMErrorCode MoFEM::prism_type_1	(	const EntityHandle *	conn,
		const BitRefEdges	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_prism_conn
	)

Definition at line 1230 of file EntityRefine.cpp.

                                                          {
  MoFEMFunctionBeginHot;
  int ee = 0;
  for (; ee < 6; ee++) {
    if (split_edges.test(ee))
      break;
  }
  if (ee > 2)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  const int cycle_edges[3][6] = {
      {0, 1, 2, 3, 4, 5}, {1, 2, 0, 4, 5, 3}, {2, 0, 1, 5, 3, 4}};
  const int cycle_nodes[3][6] = {
      {0, 1, 2, 3, 4, 5}, {1, 2, 0, 4, 5, 3}, {2, 0, 1, 5, 3, 4}};
  if (edge_new_nodes[cycle_nodes[ee][0]] == no_handle)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  if (edge_new_nodes[cycle_nodes[ee][3]] == no_handle)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  // PRISM0
  new_prism_conn[0 * 6 + 0] = edge_new_nodes[cycle_edges[ee][0]];
  new_prism_conn[0 * 6 + 1] = conn[cycle_nodes[ee][2]];
  new_prism_conn[0 * 6 + 2] = conn[cycle_nodes[ee][0]];
  new_prism_conn[0 * 6 + 3] = edge_new_nodes[cycle_edges[ee][3]];
  new_prism_conn[0 * 6 + 4] = conn[cycle_nodes[ee][5]];
  new_prism_conn[0 * 6 + 5] = conn[cycle_nodes[ee][3]];
  // PRISM1
  new_prism_conn[1 * 6 + 0] = edge_new_nodes[cycle_edges[ee][0]];
  new_prism_conn[1 * 6 + 1] = conn[cycle_nodes[ee][2]];
  new_prism_conn[1 * 6 + 2] = conn[cycle_nodes[ee][1]];
  new_prism_conn[1 * 6 + 3] = edge_new_nodes[cycle_edges[ee][3]];
  new_prism_conn[1 * 6 + 4] = conn[cycle_nodes[ee][5]];
  new_prism_conn[1 * 6 + 5] = conn[cycle_nodes[ee][4]];
  MoFEMFunctionReturnHot(0);
}

prism_type_2()

MoFEMErrorCode MoFEM::prism_type_2	(	const EntityHandle *	conn,
		const BitRefEdges	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_prism_conn
	)

Definition at line 1266 of file EntityRefine.cpp.

                                                          {
  MoFEMFunctionBeginHot;
  const int cycle_edges[3][6] = {
      {0, 1, 2, 3, 4, 5}, {1, 2, 0, 4, 5, 3}, {2, 0, 1, 5, 3, 4}};
  const int cycle_nodes[3][6] = {
      {0, 1, 2, 3, 4, 5}, {1, 2, 0, 4, 5, 3}, {2, 0, 1, 5, 3, 4}};
  int ee = 0;
  for (; ee < 3; ee++) {
    BitRefEdges mach_pattern(0);
    mach_pattern.set(cycle_edges[ee][0]);
    mach_pattern.set(cycle_edges[ee][2]);
    mach_pattern.set(cycle_edges[ee][3]);
    mach_pattern.set(cycle_edges[ee][5]);
    if (mach_pattern == split_edges)
      break;
  }
  if (ee > 2)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  EntityHandle _conn_[6], _edge_new_nodes_[6];
  int nn = 0;
  for (; nn < 6; nn++) {
    _conn_[nn] = conn[cycle_nodes[ee][nn]];
    _edge_new_nodes_[nn] = edge_new_nodes[cycle_edges[ee][nn]];
  }
  if (_conn_[1] < _conn_[2]) {
    EntityHandle _conn____;
    _conn____ = _conn_[2];
    _conn_[2] = _conn_[1];
    _conn_[1] = _conn____;
    _conn____ = _conn_[5];
    _conn_[5] = _conn_[4];
    _conn_[4] = _conn____;
    _conn____ = _edge_new_nodes_[0];
    _edge_new_nodes_[0] = _edge_new_nodes_[2];
    _edge_new_nodes_[2] = _conn____;
    _conn____ = _edge_new_nodes_[6 - 3];
    _edge_new_nodes_[6 - 3] = _edge_new_nodes_[8 - 3];
    _edge_new_nodes_[8 - 3] = _conn____;
  }
  if (_edge_new_nodes_[0] == no_handle)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  if (_edge_new_nodes_[2] == no_handle)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  if (_edge_new_nodes_[6 - 3] == no_handle)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  if (_edge_new_nodes_[8 - 3] == no_handle)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  // PRIMS0
  new_prism_conn[0 * 6 + 0] = _conn_[0];
  new_prism_conn[0 * 6 + 1] = _edge_new_nodes_[0];
  new_prism_conn[0 * 6 + 2] = _edge_new_nodes_[2];
  new_prism_conn[0 * 6 + 3] = _conn_[3];
  new_prism_conn[0 * 6 + 4] = _edge_new_nodes_[6 - 3];
  new_prism_conn[0 * 6 + 5] = _edge_new_nodes_[8 - 3];
  // PRISM1
  new_prism_conn[1 * 6 + 0] = _conn_[1];
  new_prism_conn[1 * 6 + 1] = _conn_[2];
  new_prism_conn[1 * 6 + 2] = _edge_new_nodes_[0];
  new_prism_conn[1 * 6 + 3] = _conn_[4];
  new_prism_conn[1 * 6 + 4] = _conn_[5];
  new_prism_conn[1 * 6 + 5] = _edge_new_nodes_[6 - 3];
  // PRISM2
  new_prism_conn[2 * 6 + 0] = _conn_[2];
  new_prism_conn[2 * 6 + 1] = _edge_new_nodes_[0];
  new_prism_conn[2 * 6 + 2] = _edge_new_nodes_[2];
  new_prism_conn[2 * 6 + 3] = _conn_[5];
  new_prism_conn[2 * 6 + 4] = _edge_new_nodes_[6 - 3];
  new_prism_conn[2 * 6 + 5] = _edge_new_nodes_[8 - 3];
  MoFEMFunctionReturnHot(0);
}

prism_type_3()

MoFEMErrorCode MoFEM::prism_type_3	(	const EntityHandle *	conn,
		const BitRefEdges	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_prism_conn
	)

Definition at line 1339 of file EntityRefine.cpp.

                                                          {
  MoFEMFunctionBeginHot;
  int ee = 0;
  for (; ee < 6; ee++) {
    if (!split_edges.test(ee))
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  }
  // PRISM0
  new_prism_conn[0 * 6 + 0] = edge_new_nodes[0];
  new_prism_conn[0 * 6 + 1] = edge_new_nodes[2];
  new_prism_conn[0 * 6 + 2] = conn[0];
  new_prism_conn[0 * 6 + 3] = edge_new_nodes[6 - 3];
  new_prism_conn[0 * 6 + 4] = edge_new_nodes[8 - 3];
  new_prism_conn[0 * 6 + 5] = conn[3];
  // PRISM1
  new_prism_conn[1 * 6 + 0] = edge_new_nodes[0];
  new_prism_conn[1 * 6 + 1] = edge_new_nodes[1];
  new_prism_conn[1 * 6 + 2] = conn[1];
  new_prism_conn[1 * 6 + 3] = edge_new_nodes[6 - 3];
  new_prism_conn[1 * 6 + 4] = edge_new_nodes[7 - 3];
  new_prism_conn[1 * 6 + 5] = conn[4];
  // PRISM2
  new_prism_conn[2 * 6 + 0] = edge_new_nodes[1];
  new_prism_conn[2 * 6 + 1] = edge_new_nodes[2];
  new_prism_conn[2 * 6 + 2] = conn[2];
  new_prism_conn[2 * 6 + 3] = edge_new_nodes[7 - 3];
  new_prism_conn[2 * 6 + 4] = edge_new_nodes[8 - 3];
  new_prism_conn[2 * 6 + 5] = conn[5];
  // PRISM3
  new_prism_conn[3 * 6 + 0] = edge_new_nodes[0];
  new_prism_conn[3 * 6 + 1] = edge_new_nodes[1];
  new_prism_conn[3 * 6 + 2] = edge_new_nodes[2];
  new_prism_conn[3 * 6 + 3] = edge_new_nodes[6 - 3];
  new_prism_conn[3 * 6 + 4] = edge_new_nodes[7 - 3];
  new_prism_conn[3 * 6 + 5] = edge_new_nodes[8 - 3];
  MoFEMFunctionReturnHot(0);
}

quad_split_all_edges() [1/2]

MoFEMErrorCode MoFEM::quad_split_all_edges	(	const EntityHandle *	conn,
		const BitRefEdges	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_quad_conn
	)

Definition at line 1380 of file EntityRefine.cpp.

                                                                 {
 
  return 0;
                                    }

quad_split_all_edges() [2/2]

MoFEMErrorCode MoFEM::quad_split_all_edges	(	const EntityHandle *	conn,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_quad_conn
	)

rangeInserter()

template<typename I >

auto MoFEM::rangeInserter	(	const I	f,
		const I	s,
		boost::function< bool(I it)>	tester,
		boost::function< MoFEMErrorCode(I f, I s)>	inserter
	)

Insert ranges.

Template Parameters

I

Parameters

f
s
tester
inserter

Returns

auto

Definition at line 1945 of file Templates.hpp.

                                                                     {
  MoFEMFunctionBegin;
 
  auto first = f;
  while (first != s)
    if (tester(first)) {
 
      auto second = first;
      ++second;
 
      while (second != s) {
        if (tester(second))
          ++second;
        else
          break;
      }
 
      CHKERR inserter(first, second);
 
      first = second;
      if (first != s)
        ++first;
 
    } else {
      ++first;
    }
 
  MoFEMFunctionReturn(0);
}

reconstructMultiIndex()

template<typename MI , typename MO = Modify_change_nothing>

MoFEMErrorCode MoFEM::reconstructMultiIndex ( const MI &  mi, MO &&  mo = Modify_change_nothing()  )

inline

Template used to reconstruct multi-index.

Template Parameters

MI	multi-index
Modifier

Parameters

mi
mo

Returns

MoFEMErrorCode

Definition at line 1853 of file Templates.hpp.

                                                                               {
  MoFEMFunctionBegin;
  for (auto it = mi.begin(); it != mi.end(); ++it) {
    if (!const_cast<MI &>(mi).modify(it, mo))
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Houston we have a problem");
  }
  MoFEMFunctionReturn(0);
}

scalar_fun_one()

double MoFEM::scalar_fun_one ( const double  , const double  , const double    )

inline

Definition at line 146 of file FormsIntegrators.hpp.

                                                                       {
  return 1;
}

schur_mat_set_values_wrap()

MoFEMErrorCode MoFEM::schur_mat_set_values_wrap	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 2256 of file Schur.cpp.

                                                                    {
  return MatSetValues<AssemblyTypeSelector<PETSC>>(M, row_data, col_data, mat,
                                                   iora);
}

schurSaveBlockMesh()

MoFEMErrorCode MoFEM::schurSaveBlockMesh	(	boost::shared_ptr< BlockStructure >	block_mat_data,
		std::string	filename
	)

Save block matrix as a mesh.

Parameters

block_mat_data
filename

Returns

MoFEMErrorCode

Examples

schur_test_diag_mat.cpp.

Definition at line 2380 of file Schur.cpp.

                                       {
  MoFEMFunctionBegin;
 
  moab::Core core;
  moab::Interface &moab = core;
 
  ReadUtilIface *iface;
  CHKERR moab.query_interface(iface);
 
  auto size = block_mat_data->blockIndex.size();
 
  EntityHandle starting_vertex;
  vector<double *> arrays_coord;
  CHKERR iface->get_node_coords(3, 4 * size, 0, starting_vertex, arrays_coord);
  EntityHandle starting_handle;
  EntityHandle *array;
  CHKERR iface->get_element_connect(size, 4, MBQUAD, 0, starting_handle, array);
 
  double def_val_nrm2 = 0;
  Tag th_nrm2;
  CHKERR moab.tag_get_handle("nrm2", 1, MB_TYPE_DOUBLE, th_nrm2,
                             MB_TAG_CREAT | MB_TAG_DENSE, &def_val_nrm2);
 
  int def_val_mat_shift = 0;
  Tag th_mat_shift;
  CHKERR moab.tag_get_handle("mat_shift", 1, MB_TYPE_INTEGER, th_mat_shift,
                             MB_TAG_CREAT | MB_TAG_DENSE, &def_val_mat_shift);
 
  int i = 0;
  for (auto &d : block_mat_data->blockIndex) {
    auto row = d.getRow();
    auto col = d.getCol();
    auto nb_rows = d.getNbRows();
    auto nb_cols = d.getNbCols();
    auto mat_shift = d.getMatShift();
 
    // q0
    arrays_coord[0][4 * i + 0] = row;
    arrays_coord[1][4 * i + 0] = col;
    arrays_coord[2][4 * i + 0] = 0;
 
    // q1
    arrays_coord[0][4 * i + 1] = row + nb_rows;
    arrays_coord[1][4 * i + 1] = col;
    arrays_coord[2][4 * i + 1] = 0;
 
    // q2
    arrays_coord[0][4 * i + 2] = row + nb_rows;
    arrays_coord[1][4 * i + 2] = col + nb_cols;
    arrays_coord[2][4 * i + 2] = 0;
 
    // q3
    arrays_coord[0][4 * i + 3] = row;
    arrays_coord[1][4 * i + 3] = col + nb_cols;
    arrays_coord[2][4 * i + 3] = 0;
 
    // ele conn
    array[4 * i + 0] = starting_vertex + 4 * i + 0;
    array[4 * i + 1] = starting_vertex + 4 * i + 1;
    array[4 * i + 2] = starting_vertex + 4 * i + 2;
    array[4 * i + 3] = starting_vertex + 4 * i + 3;
 
    auto prt = &(*block_mat_data->dataBlocksPtr)[d.getMatShift()];
    auto nrm2 = cblas_dnrm2(nb_rows * nb_cols, prt, 1);
    EntityHandle ele = starting_handle + i;
    CHKERR moab.tag_set_data(th_nrm2, &ele, 1, &nrm2);
    CHKERR moab.tag_set_data(th_mat_shift, &ele, 1, &mat_shift);
 
    ++i;
  }
 
  CHKERR iface->update_adjacencies(starting_handle, size, 4, array);
  CHKERR moab.write_file(filename.c_str(), "VTK", "");
 
  MoFEMFunctionReturn(0);
}

schurSwitchPreconditioner()

MoFEMErrorCode MoFEM::schurSwitchPreconditioner

(

boost::shared_ptr< BlockStructure >

block_mat_data

)

Switch preconditioner.

Parameters

block_mat_data

Returns

MoFEMErrorCode

Examples

schur_test_diag_mat.cpp.

Definition at line 2365 of file Schur.cpp.

                                                                          {
  MoFEMFunctionBegin;
  if (block_mat_data->multiplyByPreconditioner) {
    block_mat_data->multiplyByPreconditioner = false;
  } else {
    if (!block_mat_data->preconditionerBlocksPtr) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "preconditionerBlocksPtr not set");
    }
    block_mat_data->multiplyByPreconditioner = true;
  }
  MoFEMFunctionReturn(0);
}

set_ref_ent_basic_data_ptr_impl()

template<int V, typename std::enable_if<(V >=0), int >::type * = nullptr>

void MoFEM::set_ref_ent_basic_data_ptr_impl

(

boost::shared_ptr< BasicEntityData > &

ptr

)

Definition at line 900 of file Core.cpp.

                                                                            {
  RefEntityTmp<V>::basicDataPtr = ptr;
};

setMPCParentAdjacency()

MoFEMErrorCode MoFEM::setMPCParentAdjacency

(

)

Definition at line 15 of file EssentialMPCsData.cpp.

                                       {
  MoFEMFunctionBegin;
 
  MoFEMFunctionReturn(0);
}

setSchurA00MatSolvePC()

MoFEMErrorCode MoFEM::setSchurA00MatSolvePC

(

SmartPetscObj< PC >

pc

)

Set PC for A00 block.

Parameters

pc

Returns

MoFEMErrorCode

Examples

plastic.cpp, schur_test_diag_mat.cpp, and test_broken_space.cpp.

Definition at line 2223 of file Schur.cpp.

                                                           {
  MoFEMFunctionBegin;
 
  auto apply = [](PC pc, Vec f, Vec x) {
    MoFEMFunctionBeginHot;
    Mat A, P;
    CHKERR PCGetOperators(pc, &A, &P);
    CHKERR MatSolve(P, f, x);
    MoFEMFunctionReturnHot(0);
  };
 
  CHKERR PCSetType(pc, PCSHELL);
  CHKERR PCShellSetApply(pc, apply);
  CHKERR PCShellSetName(pc, "MoFEMSchurBlockPC");
 
  MoFEMFunctionReturn(0);
}

setSchurBlockMatOps()

static MoFEMErrorCode MoFEM::setSchurBlockMatOps ( Mat  mat_raw )

static

Definition at line 1362 of file Schur.cpp.

                                                       {
  MoFEMFunctionBegin;
  CHKERR MatShellSetManageScalingShifts(mat_raw);
  CHKERR MatShellSetOperation(mat_raw, MATOP_MULT, (void (*)(void))mult);
  CHKERR MatShellSetOperation(mat_raw, MATOP_MULT_ADD,
                              (void (*)(void))mult_add);
  CHKERR MatShellSetOperation(mat_raw, MATOP_SOLVE, (void (*)(void))solve);
  CHKERR MatShellSetOperation(mat_raw, MATOP_SOLVE_ADD,
                              (void (*)(void))solve_add);
  CHKERR MatShellSetOperation(mat_raw, MATOP_ZERO_ENTRIES,
                              (void (*)(void))mat_zero);
  CHKERR MatShellSetOperation(mat_raw, MATOP_ZERO_ROWS_COLUMNS,
                              (void (*)(void))zero_rows_columns);
 
  MoFEMFunctionReturn(0);
};

setSchurMatSolvePC()

DEPRECATED MoFEMErrorCode MoFEM::setSchurMatSolvePC

(

SmartPetscObj< PC >

pc

)

Definition at line 2241 of file Schur.cpp.

                                                        {
  return setSchurA00MatSolvePC(pc);
}

shell_block_mat_asmb_wrap()

MoFEMErrorCode MoFEM::shell_block_mat_asmb_wrap	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 1900 of file Schur.cpp.

                                                                    {
  MoFEMFunctionBegin;
  PetscBool is_mat_shell = PETSC_FALSE;
  PetscObjectTypeCompare((PetscObject)M, MATSHELL, &is_mat_shell);
  if (is_mat_shell) {
    BlockStructure *ctx;
    CHKERR MatShellGetContext(M, (void **)&ctx);
    CHKERR shell_block_mat_asmb_wrap_impl(
        ctx, row_data, col_data, mat, iora,
        [](const DiagBlockIndex::Indexes *idx) { return idx->getMatShift(); },
        ctx->dataBlocksPtr);
  } else {
    CHKERR MatSetValues<AssemblyTypeSelector<PETSC>>(M, row_data, col_data, mat,
                                                     iora);
  }
  MoFEMFunctionReturn(0);
}

shell_block_mat_asmb_wrap_impl()

MoFEMErrorCode MoFEM::shell_block_mat_asmb_wrap_impl ( BlockStructure *  ctx, const EntitiesFieldData::EntData &  row_data, const EntitiesFieldData::EntData &  col_data, const MatrixDouble &  mat, InsertMode  iora, boost::function< int(const DiagBlockIndex::Indexes *)>  shift_extractor, boost::shared_ptr< std::vector< double >>  data_blocks_ptr  )

inline

Definition at line 1745 of file Schur.cpp.

                                                        {
 
  MoFEMFunctionBegin;
 
  if (row_data.getIndices().empty())
    MoFEMFunctionReturnHot(0);
  if (col_data.getIndices().empty())
    MoFEMFunctionReturnHot(0);
 
#ifndef NDEBUG
 
  PetscLogEventBegin(SchurEvents::MOFEM_EVENT_BlockStructureSetValues, 0, 0, 0,
                     0);
 
#endif // NDEBUG
 
  switch (iora) {
  case ADD_VALUES:
  case INSERT_VALUES:
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Wrong InsertMode");
  }
 
  auto get_row_data = [&]() -> std::pair<bool, VectorInt> {
    if (auto e_ptr = row_data.getFieldEntities()[0]) {
      if (auto stored_data_ptr =
              e_ptr->getSharedStoragePtr<EssentialBcStorage>()) {
        MOFEM_LOG("SELF", Sev::warning) << "Can lead to unhandled behaviour";
        return std::make_pair(true, stored_data_ptr->entityIndices);
      }
    }
    return std::make_pair(false, row_data.getIndices());
  };
 
  auto row_indices = get_row_data();
 
  std::vector<int> ent_row_indices;
  std::vector<int> ent_col_indices;
 
  for (auto &rent : row_data.getFieldEntities()) {
    if (auto r_cache = rent->entityCacheRowDofs.lock()) {
 
      auto &row_uid = rent->getLocalUniqueId();
      auto &row_ind = row_indices.second;
 
      for (auto &cent : col_data.getFieldEntities()) {
        if (auto c_cache = cent->entityCacheColDofs.lock()) {
 
          auto &col_uid = cent->getLocalUniqueId();
          auto &col_ind = col_data.getIndices();
 
          auto it = ctx->blockIndex.get<0>().find(
 
              boost::make_tuple(row_uid, col_uid)
 
          );
 
#ifndef NDEBUG
 
          if (it == ctx->blockIndex.get<0>().end()) {
            MOFEM_LOG_CHANNEL("SELF");
            MOFEM_TAG_AND_LOG("SELF", Sev::error, "BlockMat")
                << "missing block: row "
                << row_data.getFieldDofs()[0]->getName() << " col "
                << col_data.getFieldDofs()[0]->getName();
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "Block not allocated");
          }
 
#endif
 
          auto ri = row_ind.begin();
          auto rie = row_ind.end();
 
          auto shift = shift_extractor(&*it);
          auto s_mat = &(*data_blocks_ptr)[shift];
 
          auto get_ent_indices = [](auto &cache, auto &ind) {
            ind.clear();
            ind.reserve(std::distance(cache->loHi[0], cache->loHi[1]));
            for (auto e = cache->loHi[0]; e != cache->loHi[1]; ++e) {
              auto glob = (*e)->getPetscGlobalDofIdx();
              if (glob != -1)
                ind.push_back(glob);
            }
          };
 
          get_ent_indices(r_cache, ent_row_indices);
          if (ent_row_indices.empty())
            continue;
          get_ent_indices(c_cache, ent_col_indices);
          if (ent_col_indices.empty())
            continue;
 
          if (mat.size1() == ent_row_indices.size() &&
              mat.size2() == ent_col_indices.size()) {
 
            if (iora == ADD_VALUES) {
              cblas_daxpy(mat.data().size(), 1.0, mat.data().data(), 1, s_mat,
                          1);
            } else {
              cblas_dcopy(mat.data().size(), mat.data().data(), 1, s_mat, 1);
            }
 
          } else {
 
            int row = 0;
            for (auto re : ent_row_indices) {
              ri = std::find(ri, rie, re);
              if (!(ri == rie && *ri != -1)) {
 
                auto ci = col_ind.begin();
                auto cie = col_ind.end();
                auto ce = c_cache->loHi[0];
 
                int col = 0;
                for (auto ce : ent_col_indices) {
                  ci = std::find(ci, cie, ce);
                  if (!(ci == cie && *ci != -1)) {
                    auto &m = s_mat[row * ent_col_indices.size() + col];
                    if (iora == ADD_VALUES) {
                      m += mat(std::distance(row_ind.begin(), ri),
                               std::distance(col_ind.begin(), ci));
                    } else {
                      m = mat(std::distance(row_ind.begin(), ri),
                              std::distance(col_ind.begin(), ci));
                    }
                  }
                  ++col;
                } // cols
              }
              ++row;
            } // rows
          }
 
        } // iterate entities
      }
    }
  }
 
#ifndef NDEBUG
  PetscLogEventEnd(SchurEvents::MOFEM_EVENT_BlockStructureSetValues, 0, 0, 0,
                   0);
#endif // NDEBUG
 
  MoFEMFunctionReturn(0);
}

shell_block_preconditioner_mat_asmb_wrap()

MoFEMErrorCode MoFEM::shell_block_preconditioner_mat_asmb_wrap	(	Mat	M,
		const EntitiesFieldData::EntData &	row_data,
		const EntitiesFieldData::EntData &	col_data,
		const MatrixDouble &	mat,
		InsertMode	iora
	)

Definition at line 1920 of file Schur.cpp.

                     {
  MoFEMFunctionBegin;
  PetscBool is_mat_shell = PETSC_FALSE;
  PetscObjectTypeCompare((PetscObject)M, MATSHELL, &is_mat_shell);
  if (is_mat_shell) {
    BlockStructure *ctx;
    CHKERR MatShellGetContext(M, (void **)&ctx);
    if (!ctx->preconditionerBlocksPtr)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "No preconditionerBlocksPtr");
    CHKERR shell_block_mat_asmb_wrap_impl(
        ctx, row_data, col_data, mat, iora,
        [](const DiagBlockIndex::Indexes *idx) { return idx->getMatShift(); },
        ctx->preconditionerBlocksPtr);
  } else {
    CHKERR MatSetValues<AssemblyTypeSelector<PETSC>>(M, row_data, col_data, mat,
                                                     iora);
  }
  MoFEMFunctionReturn(0);
}

smartCreateDMMatrix()

DEPRECATED auto MoFEM::smartCreateDMMatrix ( DM  dm )

inline

Deprecated:

use createDMMatrix

Examples

mortar_contact_thermal.cpp, simple_contact.cpp, simple_contact_thermal.cpp, and test_jacobian_of_simple_contact_element.cpp.

Definition at line 1092 of file DMMoFEM.hpp.

{ return createDMMatrix(dm); }

smartCreateDMVector()

DEPRECATED auto MoFEM::smartCreateDMVector ( DM  dm )

inline

Deprecated:

use createDMVector

Examples

mortar_contact.cpp, mortar_contact_thermal.cpp, simple_contact.cpp, simple_contact_thermal.cpp, and test_jacobian_of_simple_contact_element.cpp.

Definition at line 1107 of file DMMoFEM.hpp.

{ return createDMVector(dm); }

smartGetDMKspCtx()

DEPRECATED auto MoFEM::smartGetDMKspCtx ( DM  dm )

inline

Deprecated:

getDMKspCtx

Definition at line 1121 of file DMMoFEM.hpp.

{ return getDMKspCtx(dm); }

smartGetDMSnesCtx()

DEPRECATED auto MoFEM::smartGetDMSnesCtx ( DM  dm )

inline

Deprecated:

use smartGetDMSnesCtx

Definition at line 1135 of file DMMoFEM.hpp.

{ return getDMSnesCtx(dm); }

smartGetDMTsCtx()

DEPRECATED auto MoFEM::smartGetDMTsCtx ( DM  dm )

inline

Deprecated:

use getDMTsCtx

Definition at line 1149 of file DMMoFEM.hpp.

{ return getDMTsCtx(dm); }

smartMatDuplicate()

DEPRECATED SmartPetscObj<Mat> MoFEM::smartMatDuplicate ( Mat  mat, MatDuplicateOption  op  )

inline

Deprecated:

use matDuplicate

Examples

test_jacobian_of_simple_contact_element.cpp.

Definition at line 244 of file PetscSmartObj.hpp.

                                                                              {
  return matDuplicate(mat, op);
}

smartVectorDuplicate()

DEPRECATED SmartPetscObj<Vec> MoFEM::smartVectorDuplicate ( Vec  vec )

inline

Deprecated:

use vectorDuplicate

Examples

dynamic_first_order_con_law.cpp, mortar_contact_thermal.cpp, simple_contact.cpp, simple_contact_thermal.cpp, and test_jacobian_of_simple_contact_element.cpp.

Definition at line 230 of file PetscSmartObj.hpp.

                                                                   {
  return vectorDuplicate(vec);
}

SnesMat()

PetscErrorCode MoFEM::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.

For more information pleas look to PETSc manual, i.e. SNESSetJacobian http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/SNES/SNESSetJacobian.html#SNESSetJacobian

Parameters

snes	SNES solver
x	Solution vector at current iteration
A	Tangent matrix
B	Preconditioner tangent matrix
ctx	Pointer to context i.e. SnesCtx

Returns

Error code

Examples

minimal_surface_area.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, nonlinear_dynamics.cpp, simple_contact.cpp, simple_contact_thermal.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 139 of file SnesCtx.cpp.

                                                                  {
  SnesCtx *snes_ctx = (SnesCtx *)ctx;
  // PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
  MoFEMFunctionBegin;
  PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesMat, 0, 0, 0, 0);
  if (snes_ctx->zeroPreCondMatrixB)
    CHKERR MatZeroEntries(B);
 
  snes_ctx->matAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR snes_ctx->mField.cache_problem_entities(snes_ctx->problemName,
                                                 cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.snes = snes;
    fe.snes_x = x;
    fe.snes_A = A;
    fe.snes_B = B;
    fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX;
 
    CHKERR SNESGetKSP(snes, &fe.ksp);
    
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
 
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR snes_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      snes_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
  for (auto &bit : snes_ctx->preProcess_Mat) {
    bit->matAssembleSwitch = boost::move(snes_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_preProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    snes_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
 
 
  for (auto &lit : snes_ctx->loops_to_do_Mat) {
    lit.second->matAssembleSwitch = boost::move(snes_ctx->matAssembleSwitch);
    set(*lit.second);
    CHKERR snes_ctx->mField.loop_finite_elements(
        snes_ctx->problemName, lit.first, *(lit.second), nullptr, snes_ctx->bH,
        cache_ptr);
    unset(*lit.second);
    snes_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }
 
  for (auto &bit : snes_ctx->postProcess_Mat) {
    bit->matAssembleSwitch = boost::move(snes_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_postProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    snes_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  if (*snes_ctx->matAssembleSwitch) {
    CHKERR MatAssemblyBegin(B, snes_ctx->typeOfAssembly);
    CHKERR MatAssemblyEnd(B, snes_ctx->typeOfAssembly);
  }
  PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesMat, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

SnesMoFEMSetAssemblyType()

MoFEMErrorCode MoFEM::SnesMoFEMSetAssemblyType	(	SNES	snes,
		MatAssemblyType	type
	)

Set assembly type at the end of SnesMat.

Note

Note that tangent matrix need have to have final assembly, you would use flush assembly in special case that you call SnesMat form other function set to SNESSetJacobian

Parameters

snes
type	type of assembly, either MAT_FLUSH_ASSEMBLY or MAT_FINAL_ASSEMBLY

Returns

error code

Definition at line 215 of file SnesCtx.cpp.

                                                                         {
  SnesCtx *snes_ctx;
  // PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
  MoFEMFunctionBegin;
  CHKERR SNESGetApplicationContext(snes, &snes_ctx);
  snes_ctx->typeOfAssembly = type;
  MoFEMFunctionReturn(0);
}

SnesMoFEMSetBehavior()

MoFEMErrorCode MoFEM::SnesMoFEMSetBehavior	(	SNES	snes,
		MoFEMTypes	bh
	)

Set behavior if finite element in sequence does not exist.

Parameters

snes
bh	If set to MF_EXIST check if element exist, default MF_EXIST. Otherwise set MF_ZERO

Returns

error code

Definition at line 224 of file SnesCtx.cpp.

                                                              {
  SnesCtx *snes_ctx;
  MoFEMFunctionBegin;
  CHKERR SNESGetApplicationContext(snes, &snes_ctx);
  snes_ctx->bH = bh;
  MoFEMFunctionReturn(0);
}

SnesRhs()

PetscErrorCode MoFEM::SnesRhs	(	SNES	snes,
		Vec	x,
		Vec	f,
		void *	ctx
	)

This is MoFEM implementation for the right hand side (residual vector) evaluation in SNES solver.

For more information pleas look to PETSc manual, i.e. SNESSetFunction http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/SNES/SNESSetFunction.html

Parameters

snes	SNES solver
x	Solution vector at current iteration
f	The right hand side vector
ctx	Pointer to context i.e. SnesCtx

Returns

Error code

Examples

minimal_surface_area.cpp, mortar_contact_thermal.cpp, navier_stokes.cpp, nonlinear_dynamics.cpp, simple_contact.cpp, simple_contact_thermal.cpp, test_jacobian_of_simple_contact_element.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 27 of file SnesCtx.cpp.

                                                           {
  SnesCtx *snes_ctx = (SnesCtx *)ctx;
  // PetscValidHeaderSpecific(snes,SNES_CLASSID,1);
  MoFEMFunctionBegin;
  PetscLogEventBegin(snes_ctx->MOFEM_EVENT_SnesRhs, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  if (snes_ctx->vErify) {
    // Verify finite elements, check for not a number
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
    MPI_Comm comm = PetscObjectComm((PetscObject)f);
    PetscSynchronizedPrintf(comm, "SNES Verify x\n");
    const Problem *prb_ptr;
    CHKERR snes_ctx->mField.get_problem(snes_ctx->problemName, &prb_ptr);
    CHKERR snes_ctx->mField.getInterface<Tools>()->checkVectorForNotANumber(
        prb_ptr, COL, x);
  }
  CHKERR snes_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      snes_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
 
  auto zero_ghost_vec = [](Vec g) {
    MoFEMFunctionBegin;
    Vec l;
    CHKERR VecGhostGetLocalForm(g, &l);
    double *a;
    CHKERR VecGetArray(l, &a);
    int s;
    CHKERR VecGetLocalSize(l, &s);
    for (int i = 0; i != s; ++i)
      a[i] = 0;
    CHKERR VecRestoreArray(l, &a);
    CHKERR VecGhostRestoreLocalForm(g, &l);
    MoFEMFunctionReturn(0);
  };
  CHKERR zero_ghost_vec(f);
 
  snes_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR snes_ctx->mField.cache_problem_entities(snes_ctx->problemName,
                                                 cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.snes = snes;
    fe.snes_x = x;
    fe.snes_f = f;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX;
 
    CHKERR SNESGetKSP(snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  for (auto &bit : snes_ctx->preProcess_Rhs) {
    bit->vecAssembleSwitch = boost::move(snes_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_preProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    snes_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  for (auto &lit : snes_ctx->loops_to_do_Rhs) {
    lit.second->vecAssembleSwitch = boost::move(snes_ctx->vecAssembleSwitch);
    set(*lit.second);
    CHKERR snes_ctx->mField.loop_finite_elements(
        snes_ctx->problemName, lit.first, *lit.second, nullptr, snes_ctx->bH,
        cache_ptr);
    unset(*lit.second);
    if (snes_ctx->vErify) {
      // Verify finite elements, check for not a number
      CHKERR VecAssemblyBegin(f);
      CHKERR VecAssemblyEnd(f);
      MPI_Comm comm = PetscObjectComm((PetscObject)f);
      PetscSynchronizedPrintf(comm, "SNES Verify f FE < %s >\n",
                              lit.first.c_str());
      const Problem *prb_ptr;
      CHKERR snes_ctx->mField.get_problem(snes_ctx->problemName, &prb_ptr);
      CHKERR snes_ctx->mField.getInterface<Tools>()->checkVectorForNotANumber(
          prb_ptr, ROW, f);
    }
 
    snes_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  for (auto &bit : snes_ctx->postProcess_Rhs) {
    bit->vecAssembleSwitch = boost::move(snes_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR snes_ctx->mField.problem_basic_method_postProcess(
        snes_ctx->problemName, *bit);
    unset(*bit);
    snes_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*(snes_ctx->vecAssembleSwitch)) {
    CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
  }
  PetscLogEventEnd(snes_ctx->MOFEM_EVENT_SnesRhs, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

solve()

static PetscErrorCode MoFEM::solve ( Mat  mat, Vec  x, Vec  y  )

static

Examples

free_surface.cpp, and mesh_smoothing.cpp.

Definition at line 1223 of file Schur.cpp.

                                                   {
  return solve_schur_block_shell(mat, x, y, INSERT_VALUES);
}

solve_add()

static PetscErrorCode MoFEM::solve_add ( Mat  mat, Vec  x, Vec  y  )

static

Definition at line 1226 of file Schur.cpp.

                                                       {
  return solve_schur_block_shell(mat, x, y, ADD_VALUES);
}

solve_schur_block_shell()

static MoFEMErrorCode MoFEM::solve_schur_block_shell ( Mat  mat, Vec  y, Vec  x, InsertMode  iora  )

static

Definition at line 1599 of file Schur.cpp.

                                                               {
  using matrix_range = ublas::matrix_range<MatrixDouble>;
  using range = ublas::range;
  MoFEMFunctionBegin;
  BlockStructure *ctx;
  CHKERR MatShellGetContext(mat, (void **)&ctx);
 
  PetscLogEventBegin(SchurEvents::MOFEM_EVENT_BlockStructureSolve, 0, 0, 0, 0);
 
  if (ctx->multiplyByPreconditioner) {
    if (!ctx->preconditionerBlocksPtr)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "No preconditionerBlocksPtr");
  }
 
  if (iora == INSERT_VALUES) {
    CHKERR VecZeroEntries(x);
  }
 
  double *x_array;
  CHKERR VecGetArray(x, &x_array);
  double *y_array;
  CHKERR VecGetArray(y, &y_array);
 
  std::vector<const DiagBlockIndex::Indexes *> blocks;
  MatrixDouble block_mat;
  VectorDouble block_y;
  VectorInt ipiv;
 
  auto &block_index = ctx->blockIndex.get<1>();
  for (auto it = block_index.begin(); it != block_index.end();) {
 
    // get blocks on finit element
    blocks.clear();
    auto last_uid = it->getFEUId();
    while (it != block_index.end() && it->getFEUId() == last_uid) {
      blocks.push_back(&*it);
      ++it;
    }
 
    // set local indices
    std::map<UId, std::tuple<int, int, int>> block_indexing; // uid block map
    for (auto b : blocks) {
      if (block_indexing.find(b->getRowUId()) == block_indexing.end()) {
        block_indexing[b->getRowUId()] =
            std::make_tuple(b->getNbRows(), b->getNbRows(), b->getLocRow());
      }
    }
    std::sort(blocks.begin(), blocks.end(), [](auto a, auto b) {
      if (a->getRowUId() == b->getRowUId())
        return a->getColUId() < b->getColUId();
      else
        return a->getRowUId() < b->getRowUId();
    });
 
    // set indexes to block
    int mat_block_size = 0; // size of block matrix
    for (auto &b : block_indexing) {
      auto &[index, size, loc] = b.second;
      index = mat_block_size;
      mat_block_size += size;
    }
 
    auto get_range = [](auto &b) {
      auto [index, size, loc] = b;
      return range(index, index + size);
    };
 
    std::vector<std::tuple<int, int, int, int, int>> block_data;
    block_data.reserve(blocks.size());
    for (auto s : blocks) {
      auto ruid = s->getRowUId();
      auto cuid = s->getColUId();
      auto &rbi = block_indexing.at(ruid);
      auto &cbi = block_indexing.at(cuid);
      if (auto shift = s->getMatShift(); shift != -1) {
        block_data.push_back(std::make_tuple(
 
            shift,
 
            s->getNbRows(), s->getNbCols(),
 
            get<0>(rbi), get<0>(cbi))
 
        );
      }
    }
    block_mat.resize(mat_block_size, mat_block_size, false);
    block_mat.clear();
    for (auto &bd : block_data) {
      auto &[shift, nb_rows, nb_cols, ridx, cidx] = bd;
      auto ptr = &(*(ctx->dataBlocksPtr))[shift];
      for (auto i = 0; i != nb_rows; ++i, ptr += nb_cols) {
        auto sub_ptr = &block_mat(ridx + i, cidx);
        cblas_dcopy(nb_cols, ptr, 1, sub_ptr, 1);
      }
    }
    if (ctx->multiplyByPreconditioner) {
      for (auto &bd : block_data) {
        auto &[shift, nb_rows, nb_cols, ridx, cidx] = bd;
        auto ptr = &(*(ctx->preconditionerBlocksPtr))[shift];
        for (auto i = 0; i != nb_rows; ++i, ptr += nb_cols) {
          auto sub_ptr = &block_mat(ridx + i, cidx);
          cblas_daxpy(nb_cols, 1., ptr, 1, sub_ptr, 1);
        }
      }
    }
    block_mat = trans(block_mat);
 
    block_y.resize(mat_block_size, false);
    block_y.clear();
 
    for (auto &b : block_indexing) {
      auto [index, size, loc] = b.second;
      auto ptr = &y_array[loc];
      cblas_dcopy(size, ptr, 1, &block_y[index], 1);
    }
 
    // note: this not exploits symmetry, requires more implementation
    constexpr int nrhs = 1;
    ipiv.resize(mat_block_size, false);
    auto info = lapack_dgesv(mat_block_size, nrhs, &*block_mat.data().begin(),
                             mat_block_size, &*ipiv.data().begin(),
                             &*block_y.data().begin(), mat_block_size);
    if (info != 0) {
      SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
               "error lapack solve dgesv info = %d", info);
    }
 
    for (auto &b : block_indexing) {
      auto [index, size, loc] = b.second;
      auto ptr = &x_array[loc];
      cblas_daxpy(size, 1.0, &block_y[index], 1, ptr, 1);
    }
  }
 
  CHKERR VecRestoreArray(x, &x_array);
  CHKERR VecRestoreArray(y, &y_array);
 
  // PetscLogFlops(xxx)
  PetscLogEventEnd(SchurEvents::MOFEM_EVENT_BlockStructureSolve, 0, 0, 0, 0);
 
  MoFEMFunctionReturn(0);
}

solveLinearSystem() [1/2]

MoFEMErrorCode MoFEM::solveLinearSystem ( const MatrixDouble &  mat, VectorDouble &  f  )

inline

Solve linear system of equations using Lapack.

Parameters

mat
f

Returns

MoFEMErrorCode

Definition at line 1435 of file Templates.hpp.

                                                         {
  MoFEMFunctionBegin;
  // copy matrix since on output lapack returns factorisation
  auto mat_copy = mat;
  CHKERR solveLinearSystem(mat_copy, f);
  MoFEMFunctionReturn(0);
}

solveLinearSystem() [2/2]

MoFEMErrorCode MoFEM::solveLinearSystem ( MatrixDouble &  mat, VectorDouble &  f  )

inline

solve linear system with lapack dgesv

Parameters

mat	input lhs square matrix / output L and U from the factorization
f	input rhs vector / output solution vector

Returns

MoFEMErrorCode

Definition at line 1401 of file Templates.hpp.

                                                                            {
  MoFEMFunctionBegin;
 
  const size_t M = mat.size1();
  const size_t N = mat.size2();
 
  if (M == 0 || M != N)
    SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "The input matrix for inverse computation is not square %d != %d",
             M, N);
  if (f.size() != M)
    f.resize(M, false);
 
  const int nrhs = 1;
  int info;
  int *ipiv = new int[M];
  info = lapack_dgesv(M, nrhs, &*mat.data().begin(), M, ipiv,
                      &*f.data().begin(), M);
  if (info != 0) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
             "error lapack solve dgesv info = %d", info);
  }
 
  delete[] ipiv;
  MoFEMFunctionReturn(0);
}

sub_mat_mult()

MoFEMErrorCode MoFEM::sub_mat_mult	(	Mat	a,
		Vec	x,
		Vec	f
	)

Definition at line 160 of file PCMGSetUpViaApproxOrders.cpp.

                                                 {
  return sub_mat_mult_generic<INSERT_VALUES>(a, x, f);
}

sub_mat_mult_add()

MoFEMErrorCode MoFEM::sub_mat_mult_add	(	Mat	a,
		Vec	x,
		Vec	f
	)

Definition at line 164 of file PCMGSetUpViaApproxOrders.cpp.

                                                     {
  return sub_mat_mult_generic<ADD_VALUES>(a, x, f);
}

sub_mat_mult_generic()

template<InsertMode MODE>

MoFEMErrorCode MoFEM::sub_mat_mult_generic	(	Mat	a,
		Vec	x,
		Vec	f
	)

Definition at line 144 of file PCMGSetUpViaApproxOrders.cpp.

                                                         {
  void *void_ctx;
  MoFEMFunctionBegin;
  CHKERR MatShellGetContext(a, &void_ctx);
  PCMGSubMatrixCtx *ctx = (PCMGSubMatrixCtx *)void_ctx;
  PetscLogEventBegin(ctx->MOFEM_EVENT_mult, 0, 0, 0, 0);
  CHKERR ctx->initData(x);
  CHKERR VecScatterBegin(ctx->sCat, x, ctx->X, INSERT_VALUES, SCATTER_REVERSE);
  CHKERR VecScatterEnd(ctx->sCat, x, ctx->X, INSERT_VALUES, SCATTER_REVERSE);
  CHKERR MatMult(ctx->A, ctx->X, ctx->F);
  CHKERR VecScatterBegin(ctx->sCat, ctx->F, f, MODE, SCATTER_FORWARD);
  CHKERR VecScatterEnd(ctx->sCat, ctx->F, f, MODE, SCATTER_FORWARD);
  PetscLogEventEnd(ctx->MOFEM_EVENT_mult, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

sub_mat_sor()

MoFEMErrorCode MoFEM::sub_mat_sor	(	Mat	mat,
		Vec	b,
		PetscReal	omega,
		MatSORType	flag,
		PetscReal	shift,
		PetscInt	its,
		PetscInt	lits,
		Vec	x
	)

Definition at line 168 of file PCMGSetUpViaApproxOrders.cpp.

                                  {
 
  //FIXME: that is crap implementation of SOR
 
  void *void_ctx;
  MoFEMFunctionBegin;
  CHKERR MatShellGetContext(mat, &void_ctx);
  PCMGSubMatrixCtx *ctx = (PCMGSubMatrixCtx *)void_ctx;
  PetscLogEventBegin(ctx->MOFEM_EVENT_sor, 0, 0, 0, 0);
  CHKERR ctx->initData(x);
  CHKERR VecScatterBegin(ctx->sCat, b, ctx->X, INSERT_VALUES, SCATTER_REVERSE);
  CHKERR VecScatterEnd(ctx->sCat, b, ctx->X, INSERT_VALUES, SCATTER_REVERSE);
  CHKERR MatSOR(ctx->A, ctx->X, omega, flag, shift, its, lits, ctx->F);
  CHKERR VecScatterBegin(ctx->sCat, ctx->F, x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecScatterEnd(ctx->sCat, ctx->F, x, INSERT_VALUES, SCATTER_FORWARD);
  PetscLogEventEnd(ctx->MOFEM_EVENT_sor, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

tet_type_1()

void MoFEM::tet_type_1	(	const EntityHandle *	conn,
		const int	split_edge,
		const EntityHandle	edge_new_node,
		EntityHandle *	new_tets_conn
	)

Definition at line 1096 of file EntityRefine.cpp.

                                                                               {
  // TET0
  new_tets_conn[0 * 4 + 0] = edge_new_node;
  new_tets_conn[0 * 4 + 1] = conn[edges_conn[2 * split_edge + 0]];
  new_tets_conn[0 * 4 + 2] = conn[edges_conn[2 * oposite_edge[split_edge] + 1]];
  new_tets_conn[0 * 4 + 3] = conn[edges_conn[2 * oposite_edge[split_edge] + 0]];
  // TET1
  new_tets_conn[1 * 4 + 0] = edge_new_node;
  new_tets_conn[1 * 4 + 1] = conn[edges_conn[2 * split_edge + 1]];
  new_tets_conn[1 * 4 + 2] = conn[edges_conn[2 * oposite_edge[split_edge] + 0]];
  new_tets_conn[1 * 4 + 3] = conn[edges_conn[2 * oposite_edge[split_edge] + 1]];
}

tet_type_2()

int MoFEM::tet_type_2	(	const EntityHandle *	conn,
		const int *	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tets_conn
	)

Definition at line 988 of file EntityRefine.cpp.

                                            {
  if (split_edges[0] == oposite_edge[split_edges[1]]) {
    // type 2b
    EntityHandle n0 = conn[edges_conn[2 * split_edges[0] + 0]];
    EntityHandle n1 = conn[edges_conn[2 * split_edges[0] + 1]];
    EntityHandle n2 = conn[edges_conn[2 * split_edges[1] + 0]];
    EntityHandle n3 = conn[edges_conn[2 * split_edges[1] + 1]];
    // TET0
    new_tets_conn[0 * 4 + 0] = edge_new_nodes[split_edges[0]];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes[split_edges[1]];
    new_tets_conn[0 * 4 + 2] = n2;
    new_tets_conn[0 * 4 + 3] = n0;
    // TET1
    new_tets_conn[1 * 4 + 0] = edge_new_nodes[split_edges[0]];
    new_tets_conn[1 * 4 + 1] = edge_new_nodes[split_edges[1]];
    new_tets_conn[1 * 4 + 2] = n1;
    new_tets_conn[1 * 4 + 3] = n2;
    // TET3
    new_tets_conn[2 * 4 + 0] = edge_new_nodes[split_edges[0]];
    new_tets_conn[2 * 4 + 1] = edge_new_nodes[split_edges[1]];
    new_tets_conn[2 * 4 + 2] = n0;
    new_tets_conn[2 * 4 + 3] = n3;
    // TET4
    new_tets_conn[3 * 4 + 0] = edge_new_nodes[split_edges[0]];
    new_tets_conn[3 * 4 + 1] = edge_new_nodes[split_edges[1]];
    new_tets_conn[3 * 4 + 2] = n3;
    new_tets_conn[3 * 4 + 3] = n1;
    return 1;
  } else {
    int sub_type = 0;
    // type 2a
    const char mach_pattern =
        edge_bits_mark[split_edges[0]] | edge_bits_mark[split_edges[1]];
    EntityHandle conn_[4] = {no_handle, no_handle, no_handle, no_handle};
    int edges_[6];
    for (int ee = 0; ee < 6; ee++) {
      char pattern;
      pattern = edge_bits_mark[edge_permutations[ee][1]] |
                edge_bits_mark[edge_permutations[ee][4]];
      if (pattern == mach_pattern) {
        int free_edge = oposite_edge[ee];
        conn_[0] = conn[edges_conn[ee * 2 + 0]];
        conn_[1] = conn[edges_conn[ee * 2 + 1]];
        conn_[2] = conn[edges_conn[free_edge * 2 + 0]];
        conn_[3] = conn[edges_conn[free_edge * 2 + 1]];
        for (int EE = 0; EE < 6; EE++)
          edges_[EE] = edge_permutations[ee][EE];
        sub_type |= 4;
        break;
      }
      pattern = edge_bits_mark[edge_permutations[ee][edge_mirror_cross[1]]] |
                edge_bits_mark[edge_permutations[ee][edge_mirror_cross[4]]];
      if (pattern == mach_pattern) {
        int free_edge = oposite_edge[ee];
        conn_[0] = conn[edges_conn[ee * 2 + 1]];
        conn_[1] = conn[edges_conn[ee * 2 + 0]];
        conn_[2] = conn[edges_conn[free_edge * 2 + 1]];
        conn_[3] = conn[edges_conn[free_edge * 2 + 0]];
        for (int EE = 0; EE < 6; EE++)
          edges_[EE] = edge_permutations[ee][edge_mirror_cross[EE]];
        sub_type |= 8;
        break;
      }
    }
    EntityHandle edge_new_nodes_[6];
    for (int ee = 0; ee < 6; ee++)
      edge_new_nodes_[ee] = edge_new_nodes[edges_[ee]];
    assert(edge_new_nodes_[1] != no_handle);
    assert(edge_new_nodes_[4] != no_handle);
    // TET0
    new_tets_conn[0 * 4 + 0] = conn_[1];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes_[4];
    new_tets_conn[0 * 4 + 2] = edge_new_nodes_[1];
    new_tets_conn[0 * 4 + 3] = conn_[0];
    bool free_edge_swappped5 = false;
    if (conn_[3] < conn_[2]) {
      free_edge_swappped5 = true;
      sub_type |= 16;
    }
    if (free_edge_swappped5) {
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 1] = conn_[2];
      new_tets_conn[1 * 4 + 2] = conn_[0];
      new_tets_conn[1 * 4 + 3] = conn_[3];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[4];
      new_tets_conn[2 * 4 + 2] = conn_[3];
      new_tets_conn[2 * 4 + 3] = conn_[0];
      return sub_type;
    }
    // TET1
    new_tets_conn[1 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[1 * 4 + 1] = conn_[2];
    new_tets_conn[1 * 4 + 2] = conn_[0];
    new_tets_conn[1 * 4 + 3] = conn_[3];
    // TET2
    new_tets_conn[2 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[2 * 4 + 1] = edge_new_nodes_[4];
    new_tets_conn[2 * 4 + 2] = conn_[2];
    new_tets_conn[2 * 4 + 3] = conn_[0];
    return sub_type;
  }
  return -1;
}

tet_type_3()

int MoFEM::tet_type_3	(	const EntityHandle *	conn,
		const int *	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tets_conn
	)

Definition at line 565 of file EntityRefine.cpp.

                                            {
  char mach_pattern = 0;
  for (int ee = 0; ee < 3; ee++)
    mach_pattern |= edge_bits_mark[split_edges[ee]];
  EntityHandle conn_[4];
  int edges_[6];
  int type = -1;
  bool is_rotated = false;
  for (int ee = 0; ee < 6; ee++) {
    char pattern0, pattern1, pattern2;
    pattern0 = edge_bits_mark[edge_permutations[ee][0]] |
               edge_bits_mark[edge_permutations[ee][1]] |
               edge_bits_mark[edge_permutations[ee][4]];
    pattern1 = edge_bits_mark[edge_permutations[ee][1]] |
               edge_bits_mark[edge_permutations[ee][4]] |
               edge_bits_mark[edge_permutations[ee][5]];
    pattern2 = edge_bits_mark[edge_permutations[ee][4]] |
               edge_bits_mark[edge_permutations[ee][1]] |
               edge_bits_mark[edge_permutations[ee][2]];
    if (pattern0 == mach_pattern || pattern1 == mach_pattern ||
        pattern2 == mach_pattern) {
      // printf("nothing\n");
      int free_edge = oposite_edge[ee];
      conn_[0] = conn[edges_conn[ee * 2 + 0]];
      conn_[1] = conn[edges_conn[ee * 2 + 1]];
      conn_[2] = conn[edges_conn[free_edge * 2 + 0]];
      conn_[3] = conn[edges_conn[free_edge * 2 + 1]];
      for (int EE = 0; EE < 6; EE++)
        edges_[EE] = edge_permutations[ee][EE];
      if (pattern0 == mach_pattern) {
        // printf("nothing\n");
        type = 0;
      } else if (pattern1 == mach_pattern)
        type = 1;
      else if (pattern2 == mach_pattern)
        type = 2;
      break;
    }
    pattern0 = edge_bits_mark[edge_permutations[ee][edge_mirror_cross[0]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[1]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[4]]];
    pattern1 = edge_bits_mark[edge_permutations[ee][edge_mirror_cross[1]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[4]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[5]]];
    pattern2 = edge_bits_mark[edge_permutations[ee][edge_mirror_cross[4]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[1]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[2]]];
    if (pattern0 == mach_pattern || pattern1 == mach_pattern ||
        pattern2 == mach_pattern) {
      // printf("edge_mirror_cross\n");
      int free_edge = oposite_edge[ee];
      conn_[0] = conn[edges_conn[ee * 2 + 1]];
      conn_[1] = conn[edges_conn[ee * 2 + 0]];
      conn_[2] = conn[edges_conn[free_edge * 2 + 1]];
      conn_[3] = conn[edges_conn[free_edge * 2 + 0]];
      for (int EE = 0; EE < 6; EE++)
        edges_[EE] = edge_permutations[ee][edge_mirror_cross[EE]];
      if (pattern0 == mach_pattern) {
        // printf("edge_mirror_cross\n");
        type = 0;
      } else if (pattern1 == mach_pattern)
        type = 1;
      else if (pattern2 == mach_pattern)
        type = 2;
      break;
    }
    pattern2 = edge_bits_mark[edge_permutations[ee][edge_mirror_vertical[4]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_vertical[1]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_vertical[2]]];
    if (pattern2 == mach_pattern) {
      is_rotated = true;
      // printf("edge_mirror_vertical\n");
      int free_edge = oposite_edge[ee];
      conn_[0] = conn[edges_conn[ee * 2 + 0]];
      conn_[1] = conn[edges_conn[ee * 2 + 1]];
      conn_[2] = conn[edges_conn[free_edge * 2 + 1]];
      conn_[3] = conn[edges_conn[free_edge * 2 + 0]];
      for (int EE = 0; EE < 6; EE++)
        edges_[EE] = edge_permutations[ee][edge_mirror_vertical[EE]];
      if (pattern0 == mach_pattern) {
        // printf("edge_mirror_vertical\n");
        type = 0;
      } else if (pattern1 == mach_pattern)
        type = 1;
      else if (pattern2 == mach_pattern)
        type = 2;
      break;
    }
    pattern2 =
        edge_bits_mark[edge_permutations
                           [ee][edge_mirror_cross[edge_mirror_vertical[4]]]] |
        edge_bits_mark[edge_permutations
                           [ee][edge_mirror_cross[edge_mirror_vertical[1]]]] |
        edge_bits_mark
            [edge_permutations[ee][edge_mirror_cross[edge_mirror_vertical[2]]]];
    if (pattern2 == mach_pattern) {
      is_rotated = true;
      int free_edge = oposite_edge[ee];
      conn_[0] = conn[edges_conn[ee * 2 + 1]];
      conn_[1] = conn[edges_conn[ee * 2 + 0]];
      conn_[2] = conn[edges_conn[free_edge * 2 + 0]];
      conn_[3] = conn[edges_conn[free_edge * 2 + 1]];
      for (int EE = 0; EE < 6; EE++)
        edges_[EE] =
            edge_permutations[ee][edge_mirror_cross[edge_mirror_vertical[EE]]];
      if (pattern0 == mach_pattern) {
        // printf("edge_mirror_cross|edge_mirror_vertical\n");
        type = 0;
      } else if (pattern1 == mach_pattern)
        type = 1;
      else if (pattern2 == mach_pattern)
        type = 2;
      break;
    }
  }
  assert(type != -1);
  EntityHandle edge_new_nodes_[6];
  for (int ee = 0; ee < 6; ee++)
    edge_new_nodes_[ee] = edge_new_nodes[edges_[ee]];
  if (type == 0) {
    EntityHandle conn__[4];
    EntityHandle edge_new_nodes__[6];
    bcopy(conn_, conn__, 4 * sizeof(EntityHandle));
    bcopy(edge_new_nodes_, edge_new_nodes__, 6 * sizeof(EntityHandle));
    for (int rotate_idx = 0; rotate_idx < 3; rotate_idx++) {
      // fprintf(stderr,"%d\n",rotate_idx);
      for (int ii = 0; ii < 4; ii++)
        conn_[ii] = conn__[cyclic_node_rotate_face_3[rotate_idx][ii]];
      for (int ee = 0; ee < 6; ee++)
        edge_new_nodes_[ee] =
            edge_new_nodes__[cyclic_edge_rotate_face_3[rotate_idx][ee]];
      if ((conn_[0] > conn_[2]) && (conn_[0] > conn_[3]))
        break;
    }
    assert(conn_[0] > conn_[2]);
    assert(conn_[0] > conn_[3]);
    assert(edge_new_nodes_[0] != no_handle);
    assert(edge_new_nodes_[1] != no_handle);
    assert(edge_new_nodes_[4] != no_handle);
    // TET0
    new_tets_conn[0 * 4 + 0] = edge_new_nodes_[0];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[0 * 4 + 2] = edge_new_nodes_[4];
    new_tets_conn[0 * 4 + 3] = conn_[1];
    bool free_edge_swappped5 = false;
    if (conn_[3] < conn_[2]) {
      free_edge_swappped5 = true;
    }
    if (free_edge_swappped5) {
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[0];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[3];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[0];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 2] = conn_[2];
      new_tets_conn[2 * 4 + 3] = conn_[3];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[0];
      new_tets_conn[3 * 4 + 1] = conn_[0];
      new_tets_conn[3 * 4 + 2] = conn_[3];
      new_tets_conn[3 * 4 + 3] = conn_[2];
      // printf("free_edge_swappped5\n");
      return 4;
    }
    assert(conn_[3] > conn_[2]);
    // TET1
    new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[1 * 4 + 1] = edge_new_nodes_[0];
    new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
    new_tets_conn[1 * 4 + 3] = conn_[2];
    // TET2
    new_tets_conn[2 * 4 + 0] = edge_new_nodes_[0];
    new_tets_conn[2 * 4 + 1] = edge_new_nodes_[4];
    new_tets_conn[2 * 4 + 2] = conn_[2];
    new_tets_conn[2 * 4 + 3] = conn_[3];
    // TET3
    new_tets_conn[3 * 4 + 0] = edge_new_nodes_[0];
    new_tets_conn[3 * 4 + 1] = conn_[0];
    new_tets_conn[3 * 4 + 2] = conn_[3];
    new_tets_conn[3 * 4 + 3] = conn_[2];
    // printf("no free_edge_swappped5\n");
  } else if (type == 1) {
    assert(edge_new_nodes_[1] != no_handle);
    assert(edge_new_nodes_[4] != no_handle);
    assert(edge_new_nodes_[5] != no_handle);
    // TET0
    new_tets_conn[0 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes_[4];
    new_tets_conn[0 * 4 + 2] = edge_new_nodes_[5];
    new_tets_conn[0 * 4 + 3] = conn_[0];
    // TET1
    new_tets_conn[1 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[1 * 4 + 1] = edge_new_nodes_[5];
    new_tets_conn[1 * 4 + 2] = conn_[0];
    new_tets_conn[1 * 4 + 3] = conn_[3];
    // TET2
    new_tets_conn[2 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[2 * 4 + 1] = edge_new_nodes_[5];
    new_tets_conn[2 * 4 + 2] = conn_[2];
    new_tets_conn[2 * 4 + 3] = conn_[0];
    // TET3
    new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[3 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[3 * 4 + 2] = conn_[1];
    new_tets_conn[3 * 4 + 3] = conn_[0];
  } else if (type == 2) {
    assert(edge_new_nodes_[1] != no_handle);
    assert(edge_new_nodes_[4] != no_handle);
    assert(edge_new_nodes_[2] != no_handle);
    bool free_edge_swappped5 = false;
    if (conn_[3] < conn_[2]) {
      free_edge_swappped5 = true;
    }
    bool free_edge_swappped0 = false;
    if (conn_[0] > conn_[1]) {
      free_edge_swappped0 = true;
    }
    if (free_edge_swappped5 && (!free_edge_swappped0)) {
      // TET0
      new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
      if (is_rotated) {
        new_tets_conn[0 * 4 + 2] = conn_[0];
        new_tets_conn[0 * 4 + 3] = conn_[1];
      } else {
        new_tets_conn[0 * 4 + 2] = conn_[1];
        new_tets_conn[0 * 4 + 3] = conn_[0];
      }
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[1 * 4 + 2] = conn_[3];
        new_tets_conn[1 * 4 + 3] = conn_[0];
      } else {
        new_tets_conn[1 * 4 + 2] = conn_[0];
        new_tets_conn[1 * 4 + 3] = conn_[3];
      }
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[2 * 4 + 2] = conn_[2];
        new_tets_conn[2 * 4 + 3] = conn_[3];
      } else {
        new_tets_conn[2 * 4 + 2] = conn_[3];
        new_tets_conn[2 * 4 + 3] = conn_[2];
      }
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[1];
      if (is_rotated) {
        new_tets_conn[3 * 4 + 2] = conn_[3];
        new_tets_conn[3 * 4 + 3] = conn_[0];
      } else {
        new_tets_conn[3 * 4 + 2] = conn_[0];
        new_tets_conn[3 * 4 + 3] = conn_[3];
      }
      return type;
    } else if (free_edge_swappped0 && (!free_edge_swappped5)) {
      // TET0
      new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
      if (is_rotated) {
        new_tets_conn[0 * 4 + 2] = edge_new_nodes_[2];
        new_tets_conn[0 * 4 + 3] = conn_[1];
      } else {
        new_tets_conn[0 * 4 + 2] = conn_[1];
        new_tets_conn[0 * 4 + 3] = edge_new_nodes_[2];
      }
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
      if (is_rotated) {
        new_tets_conn[1 * 4 + 2] = conn_[2];
        new_tets_conn[1 * 4 + 3] = edge_new_nodes_[2];
      } else {
        new_tets_conn[1 * 4 + 2] = edge_new_nodes_[2];
        new_tets_conn[1 * 4 + 3] = conn_[2];
      }
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[2 * 4 + 2] = conn_[0];
        new_tets_conn[2 * 4 + 3] = conn_[1];
      } else {
        new_tets_conn[2 * 4 + 2] = conn_[1];
        new_tets_conn[2 * 4 + 3] = conn_[0];
      }
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[3 * 4 + 2] = conn_[3];
        new_tets_conn[3 * 4 + 3] = conn_[0];
      } else {
        new_tets_conn[3 * 4 + 2] = conn_[0];
        new_tets_conn[3 * 4 + 3] = conn_[3];
      }
      // TET4
      new_tets_conn[4 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[4 * 4 + 2] = conn_[2];
        new_tets_conn[4 * 4 + 3] = conn_[3];
      } else {
        new_tets_conn[4 * 4 + 2] = conn_[3];
        new_tets_conn[4 * 4 + 3] = conn_[2];
      }
      return 5;
    } else if (free_edge_swappped0 && free_edge_swappped5) {
      // TET0
      new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
      if (is_rotated) {
        new_tets_conn[0 * 4 + 2] = edge_new_nodes_[2];
        new_tets_conn[0 * 4 + 3] = conn_[1];
      } else {
        new_tets_conn[0 * 4 + 2] = conn_[1];
        new_tets_conn[0 * 4 + 3] = edge_new_nodes_[2];
      }
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[1 * 4 + 2] = conn_[2];
        new_tets_conn[1 * 4 + 3] = conn_[3];
      } else {
        new_tets_conn[1 * 4 + 2] = conn_[3];
        new_tets_conn[1 * 4 + 3] = conn_[2];
      }
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[2 * 4 + 2] = conn_[0];
        new_tets_conn[2 * 4 + 3] = conn_[1];
      } else {
        new_tets_conn[2 * 4 + 2] = conn_[1];
        new_tets_conn[2 * 4 + 3] = conn_[0];
      }
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[3 * 4 + 2] = conn_[3];
        new_tets_conn[3 * 4 + 3] = conn_[0];
      } else {
        new_tets_conn[3 * 4 + 2] = conn_[0];
        new_tets_conn[3 * 4 + 3] = conn_[3];
      }
      // TET4
      new_tets_conn[4 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[2];
      if (is_rotated) {
        new_tets_conn[4 * 4 + 2] = edge_new_nodes_[1];
        new_tets_conn[4 * 4 + 3] = conn_[3];
      } else {
        new_tets_conn[4 * 4 + 2] = conn_[3];
        new_tets_conn[4 * 4 + 3] = edge_new_nodes_[1];
      }
      return 6;
    }
    // TET0
    new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
    if (is_rotated) {
      new_tets_conn[0 * 4 + 2] = conn_[0];
      new_tets_conn[0 * 4 + 3] = conn_[1];
    } else {
      new_tets_conn[0 * 4 + 2] = conn_[1];
      new_tets_conn[0 * 4 + 3] = conn_[0];
    }
    // TET1
    new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[1 * 4 + 1] = edge_new_nodes_[2];
    if (is_rotated) {
      new_tets_conn[1 * 4 + 2] = conn_[2];
      new_tets_conn[1 * 4 + 3] = edge_new_nodes_[4];
    } else {
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[2];
    }
    // TET2
    new_tets_conn[2 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[2 * 4 + 1] = edge_new_nodes_[2];
    if (is_rotated) {
      new_tets_conn[2 * 4 + 2] = conn_[2];
      new_tets_conn[2 * 4 + 3] = conn_[3];
    } else {
      new_tets_conn[2 * 4 + 2] = conn_[3];
      new_tets_conn[2 * 4 + 3] = conn_[2];
    }
    // TET3
    new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
    if (is_rotated) {
      new_tets_conn[3 * 4 + 2] = conn_[0];
      new_tets_conn[3 * 4 + 3] = edge_new_nodes_[1];
    } else {
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[1];
      new_tets_conn[3 * 4 + 3] = conn_[0];
    }
    // TET4
    new_tets_conn[4 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[4 * 4 + 1] = edge_new_nodes_[2];
    if (is_rotated) {
      new_tets_conn[4 * 4 + 2] = conn_[3];
      new_tets_conn[4 * 4 + 3] = conn_[0];
    } else {
      new_tets_conn[4 * 4 + 2] = conn_[0];
      new_tets_conn[4 * 4 + 3] = conn_[3];
    }
    return 7;
  }
  return type;
}

tet_type_4()

int MoFEM::tet_type_4	(	const EntityHandle *	conn,
		const int *	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tets_conn
	)

Definition at line 239 of file EntityRefine.cpp.

                                            {
  char mach_pattern = 0;
  for (int ee = 0; ee < 4; ee++)
    mach_pattern |= edge_bits_mark[split_edges[ee]];
  EntityHandle conn_[4] = {no_handle, no_handle, no_handle, no_handle};
  int edges_[6];
  int type = -1;
  for (int ee = 0; ee < 6; ee++) {
    char pattern0, pattern1;
    pattern0 = edge_bits_mark[edge_permutations[ee][0]] |
               edge_bits_mark[edge_permutations[ee][1]] |
               edge_bits_mark[edge_permutations[ee][4]] |
               edge_bits_mark[edge_permutations[ee][3]];
    pattern1 = edge_bits_mark[edge_permutations[ee][1]] |
               edge_bits_mark[edge_permutations[ee][4]] |
               edge_bits_mark[edge_permutations[ee][2]] |
               edge_bits_mark[edge_permutations[ee][3]];
    if (pattern0 == mach_pattern || pattern1 == mach_pattern) {
      int free_edge = oposite_edge[ee];
      conn_[0] = conn[edges_conn[ee * 2 + 0]];
      conn_[1] = conn[edges_conn[ee * 2 + 1]];
      conn_[2] = conn[edges_conn[free_edge * 2 + 0]];
      conn_[3] = conn[edges_conn[free_edge * 2 + 1]];
      for (int EE = 0; EE < 6; EE++)
        edges_[EE] = edge_permutations[ee][EE];
      if (pattern0 == mach_pattern)
        type = 0;
      else if (pattern1 == mach_pattern)
        type = 1;
      // printf("no mirror\n");
      break;
    }
    pattern0 = edge_bits_mark[edge_permutations[ee][edge_mirror_cross[0]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[1]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[4]]] |
               edge_bits_mark[edge_permutations[ee][edge_mirror_cross[3]]];
    pattern1 = edge_bits_mark[edge_permutations[ee][1]] |
               edge_bits_mark[edge_permutations[ee][4]] |
               edge_bits_mark[edge_permutations[ee][2]] |
               edge_bits_mark[edge_permutations[ee][3]];
    if (pattern0 == mach_pattern || pattern1 == mach_pattern) {
      int free_edge = oposite_edge[ee];
      conn_[0] = conn[edges_conn[ee * 2 + 1]];
      conn_[1] = conn[edges_conn[ee * 2 + 0]];
      conn_[2] = conn[edges_conn[free_edge * 2 + 1]];
      conn_[3] = conn[edges_conn[free_edge * 2 + 0]];
      for (int EE = 0; EE < 6; EE++)
        edges_[EE] = edge_permutations[ee][edge_mirror_cross[EE]];
      if (pattern0 == mach_pattern)
        type = 0;
      else if (pattern1 == mach_pattern)
        type = 1;
      // printf("mirror\n");
      break;
    }
  }
  assert(type != -1);
  EntityHandle edge_new_nodes_[6];
  for (int ee = 0; ee < 6; ee++)
    edge_new_nodes_[ee] = edge_new_nodes[edges_[ee]];
  if (type == 0) {
    assert(edge_new_nodes_[0] != no_handle);
    assert(edge_new_nodes_[1] != no_handle);
    assert(edge_new_nodes_[4] != no_handle);
    assert(edge_new_nodes_[3] != no_handle);
    bool free_edge_swappped5 = false;
    if (conn_[3] < conn_[2]) {
      free_edge_swappped5 = true;
    }
    bool free_edge_swappped2 = false;
    if (conn_[0] < conn_[2]) {
      free_edge_swappped2 = true;
    }
    // TET0
    new_tets_conn[0 * 4 + 0] = conn_[1];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[0 * 4 + 2] = edge_new_nodes_[0];
    new_tets_conn[0 * 4 + 3] = edge_new_nodes_[4];
    if (free_edge_swappped5 && (!free_edge_swappped2)) {
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[3];
      // TET2
      new_tets_conn[2 * 4 + 0] = conn_[3];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[2 * 4 + 3] = conn_[2];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[0];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[3 * 4 + 3] = edge_new_nodes_[1];
      // TET4
      new_tets_conn[4 * 4 + 0] = conn_[2];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[0];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 3] = conn_[0];
      // TET5
      new_tets_conn[5 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[5 * 4 + 1] = edge_new_nodes_[0];
      new_tets_conn[5 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[5 * 4 + 3] = conn_[2];
      return 2;
    } else if (free_edge_swappped2 && (!free_edge_swappped5)) {
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[0];
      new_tets_conn[1 * 4 + 3] = conn_[0];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 2] = conn_[0];
      new_tets_conn[2 * 4 + 3] = conn_[2];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[0];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[3 * 4 + 3] = edge_new_nodes_[1];
      // TET4
      new_tets_conn[4 * 4 + 0] = conn_[2];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 3] = conn_[3];
      // TET5
      new_tets_conn[5 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[5 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[5 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[5 * 4 + 3] = conn_[2];
      return 3;
    } else if (free_edge_swappped2 && free_edge_swappped5) {
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[0];
      new_tets_conn[1 * 4 + 3] = conn_[0];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 2] = conn_[0];
      new_tets_conn[2 * 4 + 3] = conn_[2];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[0];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[3 * 4 + 3] = edge_new_nodes_[1];
      // TET4
      new_tets_conn[4 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 3] = conn_[3];
      // TET5
      new_tets_conn[5 * 4 + 0] = conn_[3];
      new_tets_conn[5 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[5 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[5 * 4 + 3] = conn_[2];
      return 4;
    } else {
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[0];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[2];
      // TET2
      new_tets_conn[2 * 4 + 0] = conn_[2];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[2 * 4 + 3] = edge_new_nodes_[0];
      // TET3
      new_tets_conn[3 * 4 + 0] = conn_[2];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[0];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 3] = conn_[0];
      // TET4
      new_tets_conn[4 * 4 + 0] = conn_[2];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 3] = conn_[3];
    }
  } else if (type == 1) {
    assert(edge_new_nodes_[1] != no_handle);
    assert(edge_new_nodes_[2] != no_handle);
    assert(edge_new_nodes_[3] != no_handle);
    assert(edge_new_nodes_[4] != no_handle);
    bool free_edge_swappped5 = false;
    if (conn_[3] < conn_[2]) {
      free_edge_swappped5 = true;
    }
    bool free_edge_swappped0 = false;
    if (conn_[0] > conn_[1]) {
      free_edge_swappped0 = true;
    }
    if (free_edge_swappped0 && (!free_edge_swappped5)) {
      // TET0
      new_tets_conn[0 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[0 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[0 * 4 + 2] = conn_[1];
      new_tets_conn[0 * 4 + 3] = conn_[0];
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[1];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[2 * 4 + 2] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 3] = conn_[1];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 3] = conn_[2];
      // TET4
      new_tets_conn[4 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 3] = conn_[2];
      // TET5
      new_tets_conn[5 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[5 * 4 + 1] = edge_new_nodes_[4];
      new_tets_conn[5 * 4 + 2] = conn_[2];
      new_tets_conn[5 * 4 + 3] = conn_[3];
      return 5;
    } else if (free_edge_swappped5 && (!free_edge_swappped0)) {
      // TET0
      new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
      new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[0 * 4 + 2] = conn_[1];
      new_tets_conn[0 * 4 + 3] = conn_[0];
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[0];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[2];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[2 * 4 + 3] = conn_[0];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 3] = conn_[3];
      // TET4
      new_tets_conn[4 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 3] = conn_[3];
      // TET5
      new_tets_conn[5 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[5 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[5 * 4 + 2] = conn_[3];
      new_tets_conn[5 * 4 + 3] = conn_[2];
      return 6;
    } else if (free_edge_swappped5 && free_edge_swappped0) {
      // TET0
      new_tets_conn[0 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[0 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[0 * 4 + 2] = conn_[1];
      new_tets_conn[0 * 4 + 3] = conn_[0];
      // TET1
      new_tets_conn[1 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
      new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[1 * 4 + 3] = conn_[1];
      // TET2
      new_tets_conn[2 * 4 + 0] = edge_new_nodes_[3];
      new_tets_conn[2 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[2 * 4 + 2] = edge_new_nodes_[1];
      new_tets_conn[2 * 4 + 3] = conn_[1];
      // TET3
      new_tets_conn[3 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[3 * 4 + 2] = edge_new_nodes_[3];
      new_tets_conn[3 * 4 + 3] = conn_[3];
      // TET4
      new_tets_conn[4 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
      new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
      new_tets_conn[4 * 4 + 3] = conn_[3];
      // TET5
      new_tets_conn[5 * 4 + 0] = edge_new_nodes_[1];
      new_tets_conn[5 * 4 + 1] = edge_new_nodes_[2];
      new_tets_conn[5 * 4 + 2] = conn_[3];
      new_tets_conn[5 * 4 + 3] = conn_[2];
      return 7;
    }
    // TET0
    new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[0 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[0 * 4 + 2] = conn_[1];
    new_tets_conn[0 * 4 + 3] = conn_[0];
    // TET1
    new_tets_conn[1 * 4 + 0] = edge_new_nodes_[3];
    new_tets_conn[1 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[1 * 4 + 2] = edge_new_nodes_[4];
    new_tets_conn[1 * 4 + 3] = conn_[0];
    // TET2
    new_tets_conn[2 * 4 + 0] = edge_new_nodes_[2];
    new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[2 * 4 + 2] = edge_new_nodes_[3];
    new_tets_conn[2 * 4 + 3] = conn_[0];
    // TET3
    new_tets_conn[3 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[3 * 4 + 1] = edge_new_nodes_[2];
    new_tets_conn[3 * 4 + 2] = edge_new_nodes_[3];
    new_tets_conn[3 * 4 + 3] = conn_[2];
    // TET4
    new_tets_conn[4 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[4 * 4 + 1] = edge_new_nodes_[3];
    new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
    new_tets_conn[4 * 4 + 3] = conn_[2];
    // TET5
    new_tets_conn[5 * 4 + 0] = edge_new_nodes_[3];
    new_tets_conn[5 * 4 + 1] = edge_new_nodes_[4];
    new_tets_conn[5 * 4 + 2] = conn_[2];
    new_tets_conn[5 * 4 + 3] = conn_[3];
  }
  return type;
}

tet_type_5()

int MoFEM::tet_type_5	(	moab::Interface &	moab,
		const EntityHandle *	conn,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tets_conn
	)

Definition at line 133 of file EntityRefine.cpp.

                                            {
  int free_edge = -1;
  for (int ee = 0; ee < 6; ee++) {
    if (edge_new_nodes[ee] == no_handle) {
      free_edge = ee;
      break;
    }
  }
  int edge0 = oposite_edge[free_edge];
  EntityHandle conn_[] = {
      conn[edges_conn[edge0 * 2 + 0]], conn[edges_conn[edge0 * 2 + 1]],
      conn[edges_conn[free_edge * 2 + 0]], conn[edges_conn[free_edge * 2 + 1]]};
  const int *edges_ = &edge_permutations[edge0][0];
  EntityHandle edge_new_nodes_[6];
  for (int ee = 0; ee < 6; ee++)
    edge_new_nodes_[ee] = edge_new_nodes[edges_[ee]];
  bool free_edge_swappped = false;
  if (conn_[3] < conn_[2]) {
    free_edge_swappped = true;
    EntityHandle conn__2_ = conn_[2];
    conn_[2] = conn_[3];
    conn_[3] = conn__2_;
  }
  assert(conn_[0] != no_handle);
  assert(conn_[1] != no_handle);
  assert(conn_[2] != no_handle);
  assert(conn_[3] != no_handle);
  assert(edge_new_nodes_[0] != no_handle);
  assert(edge_new_nodes_[1] != no_handle);
  assert(edge_new_nodes_[2] != no_handle);
  assert(edge_new_nodes_[3] != no_handle);
  assert(edge_new_nodes_[4] != no_handle);
  // TET0
  new_tets_conn[0 * 4 + 0] = edge_new_nodes_[4];
  new_tets_conn[0 * 4 + 1] = edge_new_nodes_[0];
  new_tets_conn[0 * 4 + 2] = edge_new_nodes_[1];
  new_tets_conn[0 * 4 + 3] = conn_[1];
  // TET1
  new_tets_conn[1 * 4 + 0] = edge_new_nodes_[2];
  new_tets_conn[1 * 4 + 1] = edge_new_nodes_[0];
  new_tets_conn[1 * 4 + 2] = edge_new_nodes_[3];
  new_tets_conn[1 * 4 + 3] = conn_[0];
  // TET4
  new_tets_conn[2 * 4 + 0] = conn_[2];
  new_tets_conn[2 * 4 + 1] = edge_new_nodes_[3];
  new_tets_conn[2 * 4 + 2] = edge_new_nodes_[4];
  if (free_edge_swappped) {
    new_tets_conn[2 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[2 * 4 + 2] = edge_new_nodes_[2];
  }
  new_tets_conn[2 * 4 + 3] = conn_[3];
  double coords[6 * 3];
  moab.get_coords(edge_new_nodes_, 6, coords);
  cblas_daxpy(3, -1, &coords[4 * 3], 1, &coords[2 * 3], 1);
  cblas_daxpy(3, -1, &coords[3 * 3], 1, &coords[1 * 3], 1);
  double L[2] = {cblas_dnrm2(3, &coords[2 * 3], 1),
                 cblas_dnrm2(3, &coords[1 * 3], 1)};
  if (L[1] <= L[0]) {
    // VARIANT 1 diag 4-2
    // TET2
    new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[3 * 4 + 1] = edge_new_nodes_[3];
    new_tets_conn[3 * 4 + 2] = edge_new_nodes_[1];
    new_tets_conn[3 * 4 + 3] = edge_new_nodes_[0];
    // TET3
    new_tets_conn[4 * 4 + 0] = edge_new_nodes_[2];
    new_tets_conn[4 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[4 * 4 + 2] = edge_new_nodes_[3];
    new_tets_conn[4 * 4 + 3] = edge_new_nodes_[0];
    // TET5
    new_tets_conn[5 * 4 + 0] = edge_new_nodes_[4];
    new_tets_conn[5 * 4 + 1] = edge_new_nodes_[1];
    new_tets_conn[5 * 4 + 2] = edge_new_nodes_[3];
    new_tets_conn[5 * 4 + 3] = conn_[2];
    // TET6
    new_tets_conn[6 * 4 + 0] = edge_new_nodes_[1];
    new_tets_conn[6 * 4 + 1] = edge_new_nodes_[2];
    new_tets_conn[6 * 4 + 2] = edge_new_nodes_[3];
    new_tets_conn[6 * 4 + 3] = conn_[2];
    return 1;
  }
  // VARIANT 2 diag 1-3
  // TET2
  new_tets_conn[3 * 4 + 0] = edge_new_nodes_[4];
  new_tets_conn[3 * 4 + 1] = edge_new_nodes_[3];
  new_tets_conn[3 * 4 + 2] = edge_new_nodes_[2];
  new_tets_conn[3 * 4 + 3] = edge_new_nodes_[0];
  // TET3
  new_tets_conn[4 * 4 + 0] = edge_new_nodes_[2];
  new_tets_conn[4 * 4 + 1] = edge_new_nodes_[1];
  new_tets_conn[4 * 4 + 2] = edge_new_nodes_[4];
  new_tets_conn[4 * 4 + 3] = edge_new_nodes_[0];
  // TET5
  new_tets_conn[5 * 4 + 0] = edge_new_nodes_[4];
  new_tets_conn[5 * 4 + 1] = edge_new_nodes_[1];
  new_tets_conn[5 * 4 + 2] = edge_new_nodes_[2];
  new_tets_conn[5 * 4 + 3] = conn_[2];
  // TET6
  new_tets_conn[6 * 4 + 0] = edge_new_nodes_[4];
  new_tets_conn[6 * 4 + 1] = edge_new_nodes_[2];
  new_tets_conn[6 * 4 + 2] = edge_new_nodes_[3];
  new_tets_conn[6 * 4 + 3] = conn_[2];
  return 0;
}

tet_type_6()

void MoFEM::tet_type_6	(	moab::Interface &	moab,
		const EntityHandle *	conn,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tets_conn
	)

Definition at line 31 of file EntityRefine.cpp.

                                             {
  // 0:01 - 4 1:12-5 2:20-6 3:03-7 4:13-8 5:23-9
  // TET0
  new_tets_conn[0 * 4 + 0] = conn[0];
  new_tets_conn[0 * 4 + 1] = edge_new_nodes[0];
  new_tets_conn[0 * 4 + 2] = edge_new_nodes[2];
  new_tets_conn[0 * 4 + 3] = edge_new_nodes[3];
  // TET1
  new_tets_conn[1 * 4 + 0] = conn[1];
  new_tets_conn[1 * 4 + 1] = edge_new_nodes[0];
  new_tets_conn[1 * 4 + 2] = edge_new_nodes[4];
  new_tets_conn[1 * 4 + 3] = edge_new_nodes[1];
  // TET2
  new_tets_conn[2 * 4 + 0] = conn[2];
  new_tets_conn[2 * 4 + 1] = edge_new_nodes[1];
  new_tets_conn[2 * 4 + 2] = edge_new_nodes[5];
  new_tets_conn[2 * 4 + 3] = edge_new_nodes[2];
  // TET3
  new_tets_conn[3 * 4 + 0] = conn[3];
  new_tets_conn[3 * 4 + 1] = edge_new_nodes[3];
  new_tets_conn[3 * 4 + 2] = edge_new_nodes[5];
  new_tets_conn[3 * 4 + 3] = edge_new_nodes[4];
  double coords[6 * 3];
  moab.get_coords(edge_new_nodes, 6, coords);
  cblas_daxpy(3, -1, &coords[4 * 3], 1, &coords[2 * 3], 1);
  cblas_daxpy(3, -1, &coords[3 * 3], 1, &coords[1 * 3], 1);
  cblas_daxpy(3, -1, &coords[5 * 3], 1, &coords[0 * 3], 1);
  double L[3] = {cblas_dnrm2(3, &coords[2 * 3], 1),
                 cblas_dnrm2(3, &coords[1 * 3], 1),
                 cblas_dnrm2(3, &coords[0 * 3], 1)};
  // VARIANT 1 - diag 4-2
  if (L[0] <= L[1] && L[0] <= L[2]) {
    // TET4
    new_tets_conn[4 * 4 + 0] = edge_new_nodes[4];
    new_tets_conn[4 * 4 + 1] = edge_new_nodes[3];
    new_tets_conn[4 * 4 + 2] = edge_new_nodes[2];
    new_tets_conn[4 * 4 + 3] = edge_new_nodes[0];
    // TET5
    new_tets_conn[5 * 4 + 0] = edge_new_nodes[4];
    new_tets_conn[5 * 4 + 1] = edge_new_nodes[2];
    new_tets_conn[5 * 4 + 2] = edge_new_nodes[3];
    new_tets_conn[5 * 4 + 3] = edge_new_nodes[5];
    // TET6
    new_tets_conn[6 * 4 + 0] = edge_new_nodes[4];
    new_tets_conn[6 * 4 + 1] = edge_new_nodes[2];
    new_tets_conn[6 * 4 + 2] = edge_new_nodes[1];
    new_tets_conn[6 * 4 + 3] = edge_new_nodes[0];
    // TET7
    new_tets_conn[7 * 4 + 0] = edge_new_nodes[4];
    new_tets_conn[7 * 4 + 1] = edge_new_nodes[1];
    new_tets_conn[7 * 4 + 2] = edge_new_nodes[2];
    new_tets_conn[7 * 4 + 3] = edge_new_nodes[5];
    return;
  }
  // VARIANT 2 - diag 3-1
  if (L[1] <= L[0] && L[1] <= L[2]) {
    // TET4
    new_tets_conn[4 * 4 + 0] = edge_new_nodes[4];
    new_tets_conn[4 * 4 + 1] = edge_new_nodes[3];
    new_tets_conn[4 * 4 + 2] = edge_new_nodes[1];
    new_tets_conn[4 * 4 + 3] = edge_new_nodes[0];
    // TET5
    new_tets_conn[5 * 4 + 0] = edge_new_nodes[4];
    new_tets_conn[5 * 4 + 1] = edge_new_nodes[1];
    new_tets_conn[5 * 4 + 2] = edge_new_nodes[3];
    new_tets_conn[5 * 4 + 3] = edge_new_nodes[5];
    // TET6
    new_tets_conn[6 * 4 + 0] = edge_new_nodes[1];
    new_tets_conn[6 * 4 + 1] = edge_new_nodes[3];
    new_tets_conn[6 * 4 + 2] = edge_new_nodes[2];
    new_tets_conn[6 * 4 + 3] = edge_new_nodes[0];
    // TET7
    new_tets_conn[7 * 4 + 0] = edge_new_nodes[1];
    new_tets_conn[7 * 4 + 1] = edge_new_nodes[2];
    new_tets_conn[7 * 4 + 2] = edge_new_nodes[3];
    new_tets_conn[7 * 4 + 3] = edge_new_nodes[5];
    return;
  }
  // VARIANT 3 - diag 5-0
  // TET4
  new_tets_conn[4 * 4 + 0] = edge_new_nodes[5];
  new_tets_conn[4 * 4 + 1] = edge_new_nodes[2];
  new_tets_conn[4 * 4 + 2] = edge_new_nodes[0];
  new_tets_conn[4 * 4 + 3] = edge_new_nodes[3];
  // TET5
  new_tets_conn[5 * 4 + 0] = edge_new_nodes[5];
  new_tets_conn[5 * 4 + 1] = edge_new_nodes[0];
  new_tets_conn[5 * 4 + 2] = edge_new_nodes[2];
  new_tets_conn[5 * 4 + 3] = edge_new_nodes[1];
  // TET6
  new_tets_conn[6 * 4 + 0] = edge_new_nodes[5];
  new_tets_conn[6 * 4 + 1] = edge_new_nodes[0];
  new_tets_conn[6 * 4 + 2] = edge_new_nodes[4];
  new_tets_conn[6 * 4 + 3] = edge_new_nodes[3];
  // TET7
  new_tets_conn[7 * 4 + 0] = edge_new_nodes[5];
  new_tets_conn[7 * 4 + 1] = edge_new_nodes[4];
  new_tets_conn[7 * 4 + 2] = edge_new_nodes[0];
  new_tets_conn[7 * 4 + 3] = edge_new_nodes[1];
}

toString()

template<class X >

std::string MoFEM::toString ( X  x )

inline

Definition at line 106 of file Templates.hpp.

                                                  {
  std::ostringstream buffer;
  buffer << x;
  return buffer.str();
}

tri_type_1()

MoFEMErrorCode MoFEM::tri_type_1	(	const EntityHandle *	conn,
		const int	split_edge,
		const EntityHandle	edge_new_node,
		EntityHandle *	new_tris_conn
	)

Definition at line 1137 of file EntityRefine.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  if (split_edge == 0) {
    // TRI0
    new_tris_conn[0 * 3 + 0] = conn[0];
    new_tris_conn[0 * 3 + 1] = edge_new_node;
    new_tris_conn[0 * 3 + 2] = conn[2];
    // TRI1
    new_tris_conn[1 * 3 + 0] = edge_new_node;
    new_tris_conn[1 * 3 + 1] = conn[1];
    new_tris_conn[1 * 3 + 2] = conn[2];
  } else if (split_edge == 1) {
    // TRI0
    new_tris_conn[0 * 3 + 0] = conn[0];
    new_tris_conn[0 * 3 + 1] = conn[1];
    new_tris_conn[0 * 3 + 2] = edge_new_node;
    // TRI1
    new_tris_conn[1 * 3 + 0] = conn[0];
    new_tris_conn[1 * 3 + 1] = edge_new_node;
    new_tris_conn[1 * 3 + 2] = conn[2]; 
  } else if (split_edge == 2) {
    // TRI0
    new_tris_conn[0 * 3 + 0] = conn[0];
    new_tris_conn[0 * 3 + 1] = conn[1];
    new_tris_conn[0 * 3 + 2] = edge_new_node;
    // TRI1
    new_tris_conn[1 * 3 + 0] = edge_new_node;;
    new_tris_conn[1 * 3 + 1] = conn[1];
    new_tris_conn[1 * 3 + 2] = conn[2]; 
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Impossible case");
  }
 
  MoFEMFunctionReturnHot(0);
}

tri_type_2()

MoFEMErrorCode MoFEM::tri_type_2	(	const EntityHandle *	conn,
		const int *	split_edges,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tris_conn
	)

Definition at line 1177 of file EntityRefine.cpp.

                                                       {
 
  MoFEMFunctionBeginHot;
 
  if(split_edges[0] == 0 && split_edges[1] == 1)  {
    // TRI0
    new_tris_conn[0 * 3 + 0] = conn[0];
    new_tris_conn[0 * 3 + 1] = edge_new_nodes[0];
    new_tris_conn[0 * 3 + 2] = edge_new_nodes[1];
    // TRI1
    new_tris_conn[1 * 3 + 0] = edge_new_nodes[0];
    new_tris_conn[1 * 3 + 1] = conn[1];
    new_tris_conn[1 * 3 + 2] = edge_new_nodes[1]; 
    // TRI2
    new_tris_conn[2 * 3 + 0] = conn[0];
    new_tris_conn[2 * 3 + 1] = edge_new_nodes[1];
    new_tris_conn[2 * 3 + 2] = conn[2]; 
  } else if(split_edges[0] == 0 && split_edges[1] == 2) {
    // TRI0
    new_tris_conn[0 * 3 + 0] = conn[0];
    new_tris_conn[0 * 3 + 1] = edge_new_nodes[0];
    new_tris_conn[0 * 3 + 2] = edge_new_nodes[2];
    // TRI1
    new_tris_conn[1 * 3 + 0] = edge_new_nodes[0];
    new_tris_conn[1 * 3 + 1] = conn[1];
    new_tris_conn[1 * 3 + 2] = edge_new_nodes[2]; 
    // TRI2
    new_tris_conn[2 * 3 + 0] = edge_new_nodes[2];
    new_tris_conn[2 * 3 + 1] = conn[1];
    new_tris_conn[2 * 3 + 2] = conn[2]; 
  } else if(split_edges[0] == 1 && split_edges[1] == 2) {
    // TRI0
    new_tris_conn[0 * 3 + 0] = conn[0];
    new_tris_conn[0 * 3 + 1] = conn[1];
    new_tris_conn[0 * 3 + 2] = edge_new_nodes[2];
    // TRI1
    new_tris_conn[1 * 3 + 0] = edge_new_nodes[2];
    new_tris_conn[1 * 3 + 1] = conn[1];
    new_tris_conn[1 * 3 + 2] = edge_new_nodes[1]; 
    // TRI2
    new_tris_conn[2 * 3 + 0] = edge_new_nodes[2];
    new_tris_conn[2 * 3 + 1] = edge_new_nodes[1];
    new_tris_conn[2 * 3 + 2] = conn[2];
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Impossible case");
  }
 
  MoFEMFunctionReturnHot(0);
}

tri_type_3()

MoFEMErrorCode MoFEM::tri_type_3	(	const EntityHandle *	conn,
		const EntityHandle *	edge_new_nodes,
		EntityHandle *	new_tris_conn
	)

Definition at line 1111 of file EntityRefine.cpp.

                                                       {
  MoFEMFunctionBeginHot;
  // TRI0
  new_tris_conn[0 * 3 + 0] = conn[0];
  new_tris_conn[0 * 3 + 1] = edge_new_nodes[0];
  new_tris_conn[0 * 3 + 2] = edge_new_nodes[2];
 
  // TRI1
  new_tris_conn[1 * 3 + 0] = edge_new_nodes[0];
  new_tris_conn[1 * 3 + 1] = conn[1];
  new_tris_conn[1 * 3 + 2] = edge_new_nodes[1];
 
  // TRI2
  new_tris_conn[2 * 3 + 0] = edge_new_nodes[2];
  new_tris_conn[2 * 3 + 1] = edge_new_nodes[1];
  new_tris_conn[2 * 3 + 2] = conn[2];
 
  // TRI3
  new_tris_conn[3 * 3 + 0] = edge_new_nodes[0];
  new_tris_conn[3 * 3 + 1] = edge_new_nodes[1];
  new_tris_conn[3 * 3 + 2] = edge_new_nodes[2];
  MoFEMFunctionReturnHot(0);
}

TSAdaptChooseMoFEM()

static PetscErrorCode MoFEM::TSAdaptChooseMoFEM	(	TSAdapt	adapt,
		TS	ts,
		PetscReal	h,
		PetscInt *	next_sc,
		PetscReal *	next_h,
		PetscBool *	accept,
		PetscReal *	wlte,
		PetscReal *	wltea,
		PetscReal *	wlter
	)

Definition at line 737 of file TsCtx.cpp.

                                                                      {
  MoFEMFunctionBegin;
 
  auto ts_adapt_mofem = boost::make_shared<TSAdaptMoFEM>();
 
  *next_sc = 0; /* Reuse the same order scheme */
  *wlte = -1;   /* Weighted local truncation error was not evaluated */
  *wltea = -1;  /* Weighted absolute local truncation error is not used */
  *wlter = -1;  /* Weighted relative local truncation error is not used */
 
  *accept = PETSC_TRUE;
  *next_h = h; /* Reuse the old step */
 
  if (!ts_adapt_mofem->offApat) {
 
    SNES snes;
    CHKERR TSGetSNES(ts, &snes);
 
    SNESConvergedReason reason;
    CHKERR SNESGetConvergedReason(snes, &reason);
 
    int it;
    CHKERR SNESGetIterationNumber(snes, &it);
 
    if (reason < 0) {
      h *= ts_adapt_mofem->alpha;
      *next_h = h;
      MOFEM_LOG_C(
          "TSWORLD", Sev::warning,
          "\tDiverged set step length: it = %d, h = %3.4g set h = %3.4g \n", it,
          h, *next_h);
    } else if (reason > 0) {
      h *= pow((static_cast<double>(ts_adapt_mofem->desiredIt) /
                static_cast<double>(it + 1)),
               static_cast<double>(ts_adapt_mofem->gamma));
      *next_h = PetscClipInterval(h, adapt->dt_min, adapt->dt_max);
      MOFEM_LOG_C(
          "TSWORLD", Sev::inform,
          "\tConverged set step length: it = %d, h = %3.4g set h = %3.4g \n",
          it, h, *next_h);
    }
  }
 
  MoFEMFunctionReturn(0);
}

TSAdaptCreateMoFEM()

PetscErrorCode MoFEM::TSAdaptCreateMoFEM

(

TSAdapt

adapt

)

Craete MOFEM adapt.

CHKERR TSAdaptRegister(TSADAPTMOFEM, TSAdaptCreateMoFEM);
TSAdapt adapt;
CHKERR TSGetAdapt(solver, &adapt);
CHKERR TSAdaptSetType(adapt, TSADAPTMOFEM);

Parameters

adapt

Returns

PetscErrorCode

Examples

adolc_plasticity.cpp.

Definition at line 797 of file TsCtx.cpp.

                                                 {
  PetscFunctionBegin;
  adapt->ops->choose = TSAdaptChooseMoFEM;
  adapt->ops->reset = TSAdaptResetMoFEM;
  adapt->ops->destroy = TSAdaptDestroyMoFEM;
  PetscFunctionReturn(0);
}

TSAdaptDestroyMoFEM()

static PetscErrorCode MoFEM::TSAdaptDestroyMoFEM

(

TSAdapt

adapt

)

Definition at line 791 of file TsCtx.cpp.

                                                  {
  MoFEMFunctionBegin;
  CHKERR TSAdaptResetMoFEM(adapt);
  MoFEMFunctionReturn(0);
}

TSAdaptResetMoFEM()

static PetscErrorCode MoFEM::TSAdaptResetMoFEM

(

TSAdapt

adapt

)

Definition at line 786 of file TsCtx.cpp.

                                                {
  PetscFunctionBegin;
  PetscFunctionReturn(0);
}

TsMonitorSet()

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

Set monitor for TS solver.

See PETSc for details

Parameters

ts
step
t
u
ctx

Returns

PetscErrorCode

Examples

EshelbianPlasticity.cpp, free_surface.cpp, nonlinear_dynamics.cpp, Remodeling.cpp, and UnsaturatedFlow.hpp.

Definition at line 259 of file TsCtx.cpp.

                                       {
  MoFEMFunctionBegin;
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxMonitor, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
 
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ts = ts;
    fe.ts_u = u;
    fe.ts_t = t;
    fe.ts_step = step;
    fe.ts_F = PETSC_NULL;
    fe.ts_ctx = TSMethod::CTX_TSTSMONITORSET;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetX | PetscData::CtxSetTime;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preprocess
  for (auto &bit : ts_ctx->preProcessMonitor) {
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
  }
 
  for (auto &lit : ts_ctx->loopsMonitor) {
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessMonitor) {
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
  }
 
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxMonitor, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

TsSetI2Function()

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

Calculation the right hand side for second order PDE in time.

PETSc for details

Parameters

ts
t
u
u_t
u_tt
F
ctx

Returns

PetscErrorCode

Definition at line 612 of file TsCtx.cpp.

                                                 {
  MoFEMFunctionBegin;
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateBegin(u_tt, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u_tt, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
 
  auto zero_ghost_vec = [](Vec g) {
    MoFEMFunctionBegin;
    Vec l;
    CHKERR VecGhostGetLocalForm(g, &l);
    double *a;
    CHKERR VecGetArray(l, &a);
    int s;
    CHKERR VecGetLocalSize(l, &s);
    for (int i = 0; i != s; ++i)
      a[i] = 0;
    CHKERR VecRestoreArray(l, &a);
    CHKERR VecGhostRestoreLocalForm(g, &l);
    MoFEMFunctionReturn(0);
  };
  CHKERR zero_ghost_vec(F);
 
  ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  int step;
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR TSGetStepNumber(ts, &step);
#else
  CHKERR TSGetTimeStepNumber(ts, &step);
#endif
 
  auto set = [&](auto &fe) {
    fe.ts_u = u;
    fe.ts_u_t = u_t;
    fe.ts_u_tt = u_tt;
    fe.ts_F = F;
    fe.ts_t = t;
    fe.ts_step = step;
    fe.ts_ctx = TSMethod::CTX_TSSETIFUNCTION;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX |
                  PetscData::CtxSetX_T | PetscData::CtxSetX_TT |
                  PetscData::CtxSetTime;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.ts = ts;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preprocess
  for (auto &bit : ts_ctx->preProcessIFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  // fe loops
  for (auto &lit : ts_ctx->loopsIFunction) {
    lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
    ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessIFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*ts_ctx->vecAssembleSwitch) {
    CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(F);
    CHKERR VecAssemblyEnd(F);
  }
 
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

TsSetI2Jacobian()

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

Calculation Jacobian for second order PDE in time.

See PETSc for details

Parameters

ts
t	time at step/stage being solved
u	state vectora
u_t	time derivative of state vector
u_tt	second time derivative of state vector
a	shift for u_t
aa	shift for u_tt
A	Jacobian of G(U) = F(t,U,W+v*U,W'+a*U), equivalent to dF/dU + v*dF/dU_t + a*dF/dU_tt
B	preconditioning matrix for J, may be same as J
ctx	TsCtx context for matrix evaluation routine

Returns

PetscErrorCode

Examples

plastic.cpp.

Definition at line 511 of file TsCtx.cpp.

                                          {
  MoFEMFunctionBegin;
 
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxI2Function, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateBegin(u_tt, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u_tt, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
  if (ts_ctx->zeroMatrix) {
    CHKERR MatZeroEntries(B);
  }
  int step;
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR TSGetStepNumber(ts, &step);
#else
  CHKERR TSGetTimeStepNumber(ts, &step);
#endif
 
  ts_ctx->matAssembleSwitch =
      boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ts_u = u;
    fe.ts_u_t = u_t;
    fe.ts_u_tt = u_tt;
    fe.ts_A = A;
    fe.ts_B = B;
    fe.ts_t = t;
    fe.ts_a = a;
    fe.ts_aa = aa;
    fe.ts_step = step;
 
    fe.ts_ctx = TSMethod::CTX_TSSETIJACOBIAN;
    fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
                  PetscData::CtxSetX_T | PetscData::CtxSetX_TT |
                  PetscData::CtxSetTime;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
                  
    fe.ts = ts;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preprocess
  for (auto &bit : ts_ctx->preProcessIJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  for (auto &lit : ts_ctx->loopsIJacobian) {
    lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
    ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessIJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  if (*(ts_ctx->matAssembleSwitch)) {
    CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
    CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
  }
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxI2Function, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

TsSetIFunction()

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

Set IFunction for TS solver.

See petsc for details

Parameters

ts
t
u
u_t
F
ctx

Returns

PetscErrorCode

Examples

free_surface.cpp, and nonlinear_dynamics.cpp.

Definition at line 56 of file TsCtx.cpp.

                                         {
  MoFEMFunctionBegin;
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
 
  auto zero_ghost_vec = [](Vec g) {
    MoFEMFunctionBegin;
    Vec l;
    CHKERR VecGhostGetLocalForm(g, &l);
    double *a;
    CHKERR VecGetArray(l, &a);
    int s;
    CHKERR VecGetLocalSize(l, &s);
    for (int i = 0; i != s; ++i)
      a[i] = 0;
    CHKERR VecRestoreArray(l, &a);
    CHKERR VecGhostRestoreLocalForm(g, &l);
    MoFEMFunctionReturn(0);
  };
  CHKERR zero_ghost_vec(F);
 
  ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
 
  int step;
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR TSGetStepNumber(ts, &step);
#else
  CHKERR TSGetTimeStepNumber(ts, &step);
#endif
 
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ts = ts;
    fe.ts_u = u;
    fe.ts_u_t = u_t;
    fe.ts_F = F;
    fe.ts_t = t;
    fe.ts_step = step;
    fe.ts_ctx = TSMethod::CTX_TSSETIFUNCTION;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX |
                  PetscData::CtxSetX_T | PetscData::CtxSetTime;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preprocess
  for (auto &bit : ts_ctx->preProcessIFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  // fe loops
  for (auto &lit : ts_ctx->loopsIFunction) {
    lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
    ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessIFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*ts_ctx->vecAssembleSwitch) {
    CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(F);
    CHKERR VecAssemblyEnd(F);
  }
 
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

TsSetIJacobian()

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

Set function evaluating jacobian in TS solver.

See PETSc for details

Parameters

ts
t
u
u_t
a
A
B
ctx

Returns

PetscErrorCode

Examples

free_surface.cpp, heat_equation.cpp, level_set.cpp, nonlinear_dynamics.cpp, and plastic.cpp.

Definition at line 165 of file TsCtx.cpp.

                                                       {
  MoFEMFunctionBegin;
 
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
  if (ts_ctx->zeroMatrix) {
    CHKERR MatZeroEntries(B);
  }
  int step;
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR TSGetStepNumber(ts, &step);
#else
  CHKERR TSGetTimeStepNumber(ts, &step);
#endif
 
  ts_ctx->matAssembleSwitch =
      boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ts = ts;
    fe.ts_u = u;
    fe.ts_u_t = u_t;
    fe.ts_A = A;
    fe.ts_B = B;
    fe.ts_t = t;
    fe.ts_a = a;
    fe.ts_step = step;
    fe.ts_ctx = TSMethod::CTX_TSSETIJACOBIAN;
    fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
                  PetscData::CtxSetX_T | PetscData::CtxSetTime;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preproces
  for (auto &bit : ts_ctx->preProcessIJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  for (auto &lit : ts_ctx->loopsIJacobian) {
    lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
    ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessIJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  if (*(ts_ctx->matAssembleSwitch)) {
    CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
    CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
  }
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

TsSetRHSFunction()

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

TS solver function.

See PETSc for details

Parameters

ts
t
u
F
ctx

Returns

PetscErrorCode

Definition at line 323 of file TsCtx.cpp.

                                                                             {
  MoFEMFunctionBegin;
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
 
  auto zero_ghost_vec = [](Vec g) {
    MoFEMFunctionBegin;
    Vec l;
    CHKERR VecGhostGetLocalForm(g, &l);
    double *a;
    CHKERR VecGetArray(l, &a);
    int s;
    CHKERR VecGetLocalSize(l, &s);
    for (int i = 0; i != s; ++i)
      a[i] = 0;
    CHKERR VecRestoreArray(l, &a);
    CHKERR VecGhostRestoreLocalForm(g, &l);
    MoFEMFunctionReturn(0);
  };
  CHKERR zero_ghost_vec(F);
 
  ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  int step;
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR TSGetStepNumber(ts, &step);
#else
  CHKERR TSGetTimeStepNumber(ts, &step);
#endif
 
  auto set = [&](auto &fe) {
    fe.ts_u = u;
    fe.ts_F = F;
    fe.ts_t = t;
    fe.ts = ts;
    fe.ts_step = step;
    fe.ts_ctx = TSMethod::CTX_TSSETRHSFUNCTION;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.data_ctx =
        PetscData::CtxSetF | PetscData::CtxSetX | PetscData::CtxSetTime;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  for (auto &bit : ts_ctx->preProcessRHSFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  // fe loops
  for (auto &lit : ts_ctx->loopsRHSFunction) {
    lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
    ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessRHSFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*ts_ctx->vecAssembleSwitch) {
    CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(F);
    CHKERR VecAssemblyEnd(F);
  }
 
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

TsSetRHSJacobian()

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

TS solver function.

See PETSc for details

Parameters

ts
t
u
A
B
ctx

Returns

PetscErrorCode

Definition at line 422 of file TsCtx.cpp.

                                           {
  MoFEMFunctionBegin;
  TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSJacobian, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
 
  if (ts_ctx->zeroMatrix) {
    CHKERR MatZeroEntries(B);
  }
 
  ts_ctx->matAssembleSwitch =
      boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  int step;
#if PETSC_VERSION_GE(3, 8, 0)
  CHKERR TSGetStepNumber(ts, &step);
#else
  CHKERR TSGetTimeStepNumber(ts, &step);
#endif
 
  auto set = [&](auto &fe) {
    fe.ts_u = u;
    fe.ts_A = A;
    fe.ts_B = B;
    fe.ts_t = t;
    fe.ts_step = step;
    fe.ts_ctx = TSMethod::CTX_TSSETRHSJACOBIAN;
    fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
                  PetscData::CtxSetTime;
    fe.ts = ts;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preprocess
  for (auto &bit : ts_ctx->preProcessRHSJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  // fe loops
  for (auto &lit : ts_ctx->loopsRHSJacobian) {
    lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*lit.second);
    CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                               *(lit.second), nullptr,
                                               ts_ctx->bH, cache_ptr);
    unset(*lit.second);
    ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }
 
  // post process
  for (auto &bit : ts_ctx->postProcessRHSJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    unset(*bit);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  if (*(ts_ctx->matAssembleSwitch)) {
    CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
    CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
  }
 
  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSJacobian, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

type_from_handle()

auto MoFEM::type_from_handle ( const EntityHandle  h )

inline

get type from entity handle

Examples

HookeElement.hpp, plastic.cpp, and poisson_2d_homogeneous.cpp.

Definition at line 1898 of file Templates.hpp.

                                                   {
  return static_cast<EntityType>(h >> MB_ID_WIDTH);
};

type_name_from_handle()

auto MoFEM::type_name_from_handle ( const EntityHandle  h )

inline

get entity type name from handle

Definition at line 1922 of file Templates.hpp.

                                                        {
  return moab::CN::EntityTypeName(type_from_handle(h));
};

VecSetValues() [1/2]

template<typename T = EntityStorage>

MoFEMErrorCode MoFEM::VecSetValues ( Vec  V, const EntitiesFieldData::EntData &  data, const double *  ptr, InsertMode  iora  )

inline

Assemble PETSc vector.

Function extract indices from entity data and assemble vector

See PETSc documentation

Parameters

V
data
ptr
iora

Returns

MoFEMErrorCode

Examples

child_and_parent.cpp, ContactOps.hpp, hanging_node_approx.cpp, higher_derivatives.cpp, HookeElement.cpp, level_set.cpp, MagneticElement.hpp, mixed_poisson.cpp, NavierStokesElement.cpp, photon_diffusion.cpp, poisson_2d_dis_galerkin.cpp, PoissonDiscontinousGalerkin.hpp, PoissonOperators.hpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, Remodeling.cpp, simple_elasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 1589 of file EntitiesFieldData.hpp.

                                                                       {
  static_assert(!std::is_same<T, T>::value,
                "VecSetValues value for this data storage is not implemented");
  return MOFEM_NOT_IMPLEMENTED;
}

VecSetValues() [2/2]

template<typename T = EntityStorage>

MoFEMErrorCode MoFEM::VecSetValues ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  vec, InsertMode  iora  )

inline

Assemble PETSc vector.

Function extract indices from entity data and assemble vector

See PETSc documentation

Parameters

V
data
vec
iora

Returns

MoFEMErrorCode

Definition at line 1621 of file EntitiesFieldData.hpp.

                                                                             {
  return VecSetValues<T>(V, data, &*vec.data().begin(), iora);
}

VecSetValues< AssemblyTypeSelector< BLOCK_MAT > >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< AssemblyTypeSelector< BLOCK_MAT > > ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  nf, InsertMode  iora  )

inline

Definition at line 249 of file Schur.hpp.

                     {
  return VecSetValues<EssentialBcStorage>(V, data, nf, iora);
}

VecSetValues< AssemblyTypeSelector< BLOCK_PRECONDITIONER_SCHUR > >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< AssemblyTypeSelector< BLOCK_PRECONDITIONER_SCHUR > > ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  nf, InsertMode  iora  )

inline

Definition at line 324 of file Schur.hpp.

                     {
  return ::VecSetValues(V, data.getIndices().size(),
                        &*data.getIndices().begin(), &*nf.begin(), iora);
}

VecSetValues< AssemblyTypeSelector< BLOCK_SCHUR > >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< AssemblyTypeSelector< BLOCK_SCHUR > > ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  nf, InsertMode  iora  )

inline

Definition at line 290 of file Schur.hpp.

                     {
  return VecSetValues<EssentialBcStorage>(V, data, nf, iora);
}

VecSetValues< AssemblyTypeSelector< PETSC > >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< AssemblyTypeSelector< PETSC > > ( Vec  V, const EntitiesFieldData::EntData &  data, const double *  ptr, InsertMode  iora  )

inline

Definition at line 125 of file FormsIntegrators.hpp.

                     {
  return VecSetValues<EssentialBcStorage>(V, data, ptr, iora);
}

VecSetValues< AssemblyTypeSelector< SCHUR > >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< AssemblyTypeSelector< SCHUR > > ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  nf, InsertMode  iora  )

inline

Definition at line 219 of file Schur.hpp.

                     {
  return VecSetValues<SchurElemMats>(V, data, nf, iora);
}

VecSetValues< EntityStorage >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< EntityStorage > ( Vec  V, const EntitiesFieldData::EntData &  data, const double *  ptr, InsertMode  iora  )

inline

Definition at line 1599 of file EntitiesFieldData.hpp.

                                                                {
  return VecSetValues(V, data.getIndices().size(), &*data.getIndices().begin(),
                      ptr, iora);
}

VecSetValues< SchurElemMats >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< SchurElemMats > ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  nf, InsertMode  iora  )

inline

Definition at line 207 of file Schur.hpp.

                                                                     {
  return VecSetValues<EssentialBcStorage>(V, data, nf, iora);
}

VecSetValues< SchurElemMatsBlock >()

template<>

MoFEMErrorCode MoFEM::VecSetValues< SchurElemMatsBlock > ( Vec  V, const EntitiesFieldData::EntData &  data, const VectorDouble &  nf, InsertMode  iora  )

inline

Definition at line 270 of file Schur.hpp.

                                                                          {
  return VecSetValues<EssentialBcStorage>(V, data, nf, iora);
}

vectorDuplicate()

SmartPetscObj<Vec> MoFEM::vectorDuplicate ( Vec  vec )

inline

Create duplicate vector of smart vector.

For details abut arguments see here: VecDuplicate.

Examples

child_and_parent.cpp, dg_projection.cpp, eigen_elastic.cpp, elasticity.cpp, ep.cpp, free_surface.cpp, hanging_node_approx.cpp, hcurl_check_approx_in_2d.cpp, hdiv_check_approx_in_3d.cpp, heat_method.cpp, helmholtz.cpp, higher_derivatives.cpp, level_set.cpp, mixed_poisson.cpp, navier_stokes.cpp, phase.cpp, plastic.cpp, plate.cpp, poisson_2d_dis_galerkin.cpp, poisson_2d_homogeneous.cpp, scalar_check_approximation.cpp, shallow_wave.cpp, simple_interface.cpp, test_broken_space.cpp, and wave_equation.cpp.

Definition at line 221 of file PetscSmartObj.hpp.

                                                   {
  Vec duplicate;
  CHK_THROW_MESSAGE(VecDuplicate(vec, &duplicate), "Failed to duplicate Vec");
  return SmartPetscObj<Vec>(duplicate);
};

zero_rows_columns()

static PetscErrorCode MoFEM::zero_rows_columns ( Mat  A, PetscInt  N, const PetscInt  rows[], PetscScalar  diag, Vec  x, Vec  b  )

static

Definition at line 1230 of file Schur.cpp.

                                                      {
 
  MoFEMFunctionBeginHot;
  BlockStructure *ctx;
  CHKERR MatShellGetContext(A, (void **)&ctx);
 
  PetscLogEventBegin(SchurEvents::MOFEM_EVENT_zeroRowsAndCols, 0, 0, 0, 0);
 
  using BlockIndexView = multi_index_container<
 
      const DiagBlockIndex::Indexes *,
 
      indexed_by<
 
          ordered_non_unique<
 
              const_mem_fun<DiagBlockIndex::Indexes, int,
                            &DiagBlockIndex::Indexes::rowShift>
 
              >,
 
          ordered_non_unique<
 
              const_mem_fun<DiagBlockIndex::Indexes, int,
                            &DiagBlockIndex::Indexes::colShift>
 
              >
 
          >>;
 
  BlockIndexView view;
  auto hint = view.get<0>().end();
  for (auto &v : ctx->blockIndex) {
    hint = view.insert(hint, &v);
  }
 
  const int *ptr = &rows[0];
  int is_nb_rows = N;
  SmartPetscObj<IS> is_local;
 
  MPI_Comm comm;
  CHKERR PetscObjectGetComm((PetscObject)A, &comm);
  int size;
  MPI_Comm_size(comm, &size);
  if (size > 1) {
    auto is = createISGeneral(comm, N, rows, PETSC_USE_POINTER);
    is_local = isAllGather(is);
  }
  if (is_local) {
    CHKERR ISGetSize(is_local, &is_nb_rows);
#ifndef NDEBUG
    if constexpr (debug_schur) {
      CHKERR ISView(is_local, PETSC_VIEWER_STDOUT_WORLD);
    }
#endif
    CHKERR ISGetIndices(is_local, &ptr);
  }
 
  int loc_m, loc_n;
  CHKERR MatGetLocalSize(A, &loc_m, &loc_n);
 
  for (auto n = 0; n != is_nb_rows; ++n) {
    auto row = ptr[n];
    auto rlo = view.get<0>().lower_bound(row);
    auto rhi = view.get<0>().end();
    for (; rlo != rhi; ++rlo) {
      auto r_shift = row - (*rlo)->getRow();
      if (r_shift >= 0 && r_shift < (*rlo)->getNbRows()) {
        auto *ptr = &(*ctx->dataBlocksPtr)[(*rlo)->getMatShift()];
        for (auto i = 0; i != (*rlo)->getNbCols(); ++i) {
          ptr[i + r_shift * (*rlo)->getNbCols()] = 0;
        }
      } else if ((*rlo)->getRow() + (*rlo)->getNbRows() > row) {
        break;
      }
    }
  }
 
  for (auto n = 0; n != is_nb_rows; ++n) {
    auto col = ptr[n];
    auto clo = view.get<1>().lower_bound(col);
    auto chi = view.get<1>().end();
    for (; clo != chi; ++clo) {
      auto c_shift = col - (*clo)->getCol();
      if (c_shift >= 0 && c_shift < (*clo)->getNbCols()) {
 
        auto *ptr = &(*ctx->dataBlocksPtr)[(*clo)->getMatShift()];
        for (auto i = 0; i != (*clo)->getNbRows(); ++i) {
          ptr[c_shift + i * (*clo)->getNbCols()] = 0;
        }
 
        // diagonal
        if (
 
            (*clo)->getRow() == (*clo)->getCol() &&
            (*clo)->getLocRow() < loc_m && (*clo)->getLocCol() < loc_n
 
        ) {
          auto r_shift = col - (*clo)->getCol();
          if (r_shift >= 0 && r_shift < (*clo)->getNbRows()) {
            ptr[c_shift + r_shift * (*clo)->getNbCols()] = diag;
          }
        }
      } else if ((*clo)->getCol() + (*clo)->getNbCols() > col) {
        break;
      }
    }
  }
 
  if (is_local) {
    CHKERR ISRestoreIndices(is_local, &ptr);
  }
 
  PetscLogEventEnd(SchurEvents::MOFEM_EVENT_zeroRowsAndCols, 0, 0, 0, 0);
 
  MoFEMFunctionReturnHot(0);
}

Variable Documentation

cyclic_edge_rotate_face_3

constexpr int MoFEM::cyclic_edge_rotate_face_3[3][6]

staticconstexpr

Initial value:

= {
    {4, 0, 3, 5, 1, 2}, {0, 1, 2, 3, 4, 5}, {1, 4, 5, 2, 0, 3}}

Definition at line 27 of file EntityRefine.cpp.

cyclic_node_rotate_face_3

constexpr int MoFEM::cyclic_node_rotate_face_3[3][4]

staticconstexpr

Initial value:

= {
    {3, 1, 0, 2}, {0, 1, 2, 3}, {2, 1, 3, 0}}

Definition at line 25 of file EntityRefine.cpp.

DataForcesAndSourcesCore

DEPRECATED typedef EntitiesFieldData MoFEM::DataForcesAndSourcesCore

Deprecated:

Use EntitiesFieldData

Definition at line 1789 of file EntitiesFieldData.hpp.

debug

const static bool MoFEM::debug = false

static

Examples

bernstein_bezier_generate_base.cpp, cell_forces.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, free_surface.cpp, gauss_points_on_outer_product.cpp, hertz_surface.cpp, level_set.cpp, mesh_cut.cpp, mesh_insert_interface_atom.cpp, node_merge.cpp, operators_tests.cpp, schur_test_diag_mat.cpp, split_sideset.cpp, test_broken_space.cpp, and wavy_surface.cpp.

Definition at line 9 of file ConstrainMatrixCtx.cpp.

debug_schur

constexpr bool MoFEM::debug_schur = false

constexpr

Definition at line 12 of file Schur.cpp.

DerivedDataForcesAndSourcesCore

DEPRECATED typedef DerivedEntitiesFieldData MoFEM::DerivedDataForcesAndSourcesCore

Deprecated:

Use DerivedEntitiesFieldData

Definition at line 1794 of file EntitiesFieldData.hpp.

dummy_file

char MoFEM::dummy_file

static

Definition at line 356 of file LogManager.cpp.

edge_bits_mark

constexpr char MoFEM::edge_bits_mark[] = {1, 2, 4, 8, 16, 32}

staticconstexpr

Definition at line 29 of file EntityRefine.cpp.

edge_mirror_cross

constexpr int MoFEM::edge_mirror_cross[6] = {0, 3, 4, 1, 2, 5}

staticconstexpr

Definition at line 23 of file EntityRefine.cpp.

edge_mirror_vertical

constexpr int MoFEM::edge_mirror_vertical[6] = {0, 4, 3, 2, 1, 5}

staticconstexpr

Definition at line 24 of file EntityRefine.cpp.

edge_permutations

constexpr int MoFEM::edge_permutations[6][6]

staticconstexpr

Initial value:

= {
    {0, 1, 2, 3, 4, 5}, {1, 2, 0, 4, 5, 3}, {2, 0, 1, 5, 3, 4},
    {3, 4, 0, 2, 5, 1}, {4, 5, 1, 0, 3, 2}, {5, 3, 2, 1, 4, 0}}

Definition at line 20 of file EntityRefine.cpp.

EdgeElementForcesAndSourcesCoreBase

DEPRECATED typedef EdgeElementForcesAndSourcesCore MoFEM::EdgeElementForcesAndSourcesCoreBase

Deprecated:

use EdgeElementForcesAndSourcesCore

Definition at line 289 of file EdgeElementForcesAndSourcesCore.hpp.

edges_conn

constexpr int MoFEM::edges_conn[] = {0, 1, 1, 2, 2, 0, 0, 3, 1, 3, 2, 3}

staticconstexpr

Definition at line 18 of file EntityRefine.cpp.

EntMethod

DEPRECATED typedef DofMethod MoFEM::EntMethod

Deprecated:

name changed use DofMethod insead EntMethod

Definition at line 510 of file LoopMethods.hpp.

FaceElementForcesAndSourcesCoreBase

DEPRECATED typedef FaceElementForcesAndSourcesCore MoFEM::FaceElementForcesAndSourcesCoreBase

Deprecated:

use FaceElementForcesAndSourcesCore

Definition at line 344 of file FaceElementForcesAndSourcesCore.hpp.

field_it

Field_multiIndex::index<FieldName_mi_tag>::type::iterator MoFEM::field_it

Definition at line 123 of file Projection10NodeCoordsOnField.cpp.

FlatPrismElementForcesAndSurcesCore

DEPRECATED typedef FlatPrismElementForcesAndSourcesCore MoFEM::FlatPrismElementForcesAndSurcesCore

USe FlatPrismElementForcesAndSourcesCore.

Definition at line 172 of file FlatPrismElementForcesAndSourcesCore.hpp.

ForcesAndSurcesCore

DEPRECATED typedef ForcesAndSourcesCore MoFEM::ForcesAndSurcesCore

Deprecated:

Used ForcesAndSourcesCore instead

Definition at line 998 of file ForcesAndSourcesCore.hpp.

K

VectorDouble MoFEM::K

Examples

ADOLCPlasticityMaterialModels.hpp, eigen_elastic.cpp, EshelbianOperators.cpp, HookeElement.cpp, HookeElement.hpp, Remodeling.cpp, simple_elasticity.cpp, and UnsaturatedFlow.hpp.

Definition at line 125 of file Projection10NodeCoordsOnField.cpp.

L

VectorDouble MoFEM::L

Examples

EshelbianOperators.cpp, level_set.cpp, navier_stokes.cpp, PlasticOpsGeneric.hpp, PlasticOpsLargeStrains.hpp, PlasticOpsSmallStrains.hpp, and Remodeling.cpp.

Definition at line 124 of file Projection10NodeCoordsOnField.cpp.

max_gemv_size

constexpr int MoFEM::max_gemv_size = 2

constexpr

Definition at line 1413 of file Schur.cpp.

MoFEM_BLOCK_MAT

constexpr const char MoFEM::MoFEM_BLOCK_MAT[] = "mofem_block_mat"

constexpr

Definition at line 21 of file Schur.hpp.

no_handle

const EntityHandle MoFEM::no_handle

Initial value:

=
    0

No entity handle is indicated by zero handle, i.e. root meshset.

Definition at line 12 of file Common.hpp.

oposite_edge

constexpr int MoFEM::oposite_edge[] = {5, 3, 4, 1, 2, 0}

staticconstexpr

Definition at line 19 of file EntityRefine.cpp.

th

Tag MoFEM::th

Examples

bernstein_bezier_generate_base.cpp, EshelbianOperators.cpp, hanging_node_approx.cpp, HookeElement.hpp, HookeInternalStressElement.hpp, MagneticElement.hpp, mesh_cut.cpp, mortar_contact_thermal.cpp, plot_base.cpp, prism_elements_from_surface.cpp, and simple_contact_thermal.cpp.

Definition at line 122 of file Projection10NodeCoordsOnField.cpp.

VolumeElementForcesAndSourcesCoreBase

DEPRECATED typedef VolumeElementForcesAndSourcesCore MoFEM::VolumeElementForcesAndSourcesCoreBase

Deprecated:

use VolumeElementForcesAndSourcesCore

Definition at line 194 of file VolumeElementForcesAndSourcesCore.hpp.

VolumeElementForcesAndSourcesCoreOnContactPrismSideBase

DEPRECATED typedef VolumeElementForcesAndSourcesCoreOnContactPrismSide MoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSideBase

Deprecated:

use VolumeElementForcesAndSourcesCore

Definition at line 188 of file VolumeElementForcesAndSourcesCoreOnContactPrismSide.hpp.

VolumeElementForcesAndSourcesCoreOnSideBase

DEPRECATED typedef VolumeElementForcesAndSourcesCoreOnSide MoFEM::VolumeElementForcesAndSourcesCoreOnSideBase

Deprecated:

use VolumeElementForcesAndSourcesCore

Definition at line 324 of file VolumeElementForcesAndSourcesCoreOnSide.hpp.