Namespace containing definitions specific for Hermes2D. More...

Namespaces
	PostProcessing
	Solution (mesh function) Postprocessing capabilities.

	RefinementSelectors
	Namespace which encapsulates all refinement selectors.

	Views
	Namespace containing Views classes, Linearizer classes, and support for these.

Classes
class	AbsFilter
	Calculates absolute value of a real solution. More...

singleton	Adapt

class	AdaptivityStoppingCriterion

class	AdaptSolver

class	AdaptSolverCriterion

class	AdaptSolverCriterionErrorThreshold

class	AdaptSolverCriterionFixed

class	AdaptStoppingCriterionCumulative

class	AdaptStoppingCriterionLevels

class	AdaptStoppingCriterionSingleElement

class	AngleFilter
	Computes the angle of a complex solution. More...

class	Api2D
	API Class containing settings for the whole Hermes2D. More...

class	Arc

class	AsmList

class	BottomValFilter
	BottomValFilter takes functions and puts a threshold on their lowest values. More...

class	ComplexAbsFilter
	Computes the absolute value of a complex solution. More...

class	ComplexFilter

class	ConstantSolution

class	ConstantSolutionVector

class	CubicSpline

class	Curve

class	CurvMap

class	CurvMapStatic

class	DefaultErrorCalculator

class	DefaultEssentialBCConst
	Class representing constant essential boundary condition. More...

class	DefaultEssentialBCNonConst

class	DefaultNormCalculator

class	DefaultNormFormSurf

class	DefaultNormFormVol

class	DiffFilter
	Calculates the difference of two functions. More...

class	DiscontinuousFunc
	This class represents a function with jump discontinuity on an interface of two elements. More...

class	DiscontinuousFunc< Ord >

singleton	DiscreteProblem

singleton	DiscreteProblemDGAssembler

singleton	DiscreteProblemIntegrationOrderCalculator
	Provides methods of integration order calculation. More...

singleton	DiscreteProblemSelectiveAssembler
	Provides capabilities to (re-)assemble a matrix / vector only where necessary. See also Solver::keep_element_values() More...

singleton	DiscreteProblemThreadAssembler
	This class is a one-thread (non-DG) assembly worker. More...

class	DXDYFilter

class	EggShell

class	Element
	Stores one element of a mesh. More...

class	ElementToRefine
	A refinement record. More...

singleton	ErrorCalculator
	Evaluation of an error between a (coarse) solution and a reference solution. More...

singleton	ErrorThreadCalculator

class	EssentialBCs

class	EssentialBoundaryCondition

class	ExactSolution
	Represents an exact solution of a PDE. More...

class	ExactSolutionConstantArray

class	ExactSolutionEggShell
	Eggshell function. More...

class	ExactSolutionScalar

class	ExactSolutionVector

class	Filter

class	Form
	Abstract, base class for any form - i.e. integral in the weak formulation of (a system of) PDE By default, the form is initialized with the following natural attributes: More...

singleton	Func

class	Func< double >
	Calculated function values (from the class Function) on an element for assembling. More...

class	Func< Ord >

class	Func< std::complex< double > >
	Calculated function values (from the class Function) on an element for assembling. More...

class	Function
	Represents an arbitrary function defined on an element. More...

singleton	Geom
	Geometry (coordinates, normals, tangents) of either an element or an edge. More...

singleton	GeomSurf
	Geometry - surface. More...

class	GeomSurf< Hermes::Ord >
	Geometry - surface - for order calculation. More...

singleton	GeomVol
	Geometry - volumetric. More...

class	GeomVol< Hermes::Ord >
	Geometry - volumetric - for order calculation. More...

class	GnuplotGraph

class	Graph

class	H1ShapesetJacobi
	Shape functions based on integrated Jacobi polynomials. More...

class	H1Space

class	HashTable
	Stores and searches node tables. More...

class	HcurlShapesetGradLeg
	H(curl) shapeset with Legendre bubbles and gradients of H1 functions as edges. More...

class	HcurlSpace

class	HdivShapesetLegendre
	H(div) shapeset based on Legendre polynomials. More...

class	HdivSpace

class	ImagFilter

singleton	InterfaceGeom

class	InterfaceGeom< Hermes::Ord >
	Geometry - interface (DG) - for order calculation. More...

singleton	KellyTypeAdapt

class	L2MarkerWiseConstSpace

class	L2ShapesetLegendre
	L2 shapeset - products of legendre polynomials. More...

class	L2ShapesetTaylor
	L2 Taylor shapeset - Taylor basis functions as proposed by Kuzmin, Luo. More...

class	L2Space

class	LinearFilter

class	LinearSolver

class	MagFilter
	Calculates the magnitude of a vector function. More...

class	MarkerArea

class	MatlabGraph

class	MatrixDefaultNormFormVol

class	MatrixForm
	Abstract, base class for matrix form - i.e. a single integral in the bilinear form on the left hand side of the variational formulation of a (system of) PDE. By default, the matrix form is initialized with the following natural attribute: More...

class	MatrixFormDG
	Abstract, base class for matrix DG form - i.e. bilinear form, where the integration is with respect to 1D-Lebesgue measure (element inner-domain edges). More...

class	MatrixFormSurf
	Abstract, base class for matrix Surface form - i.e. MatrixForm, where the integration is with respect to 1D-Lebesgue measure (element domain-boundary edges). More...

class	MatrixFormVol
	Abstract, base class for matrix Volumetric form - i.e. MatrixForm, where the integration is with respect to 2D-Lebesgue measure (elements). More...

class	Mesh
	Represents a finite element mesh. Typical usage: MeshSharedPtr mesh; Hermes::Hermes2D::MeshReaderH2DXML mloader; try { mloader.load("mesh.xml", &mesh); } catch(Exceptions::MeshLoadFailureException& e) { e.print_msg(); return -1; }. More...

class	MeshData
	Class to stored 2d mesh parameters. The MeshData class organizes all the necessary data structures required to store information in the input mesh file. All variables are stored internally as a mapping between strings and a list of strings. Symbolic expressions are not supported for variables. The variables are stored in a vector of strings. This is true for single-valued variables, lists and list of lists. The contents of the variables are thus accessed differently depending on their contents. More...

singleton	MeshFunction
	Represents a function defined on a mesh. More...

singleton	MeshFunctionSharedPtr

class	MeshHashGrid

class	MeshHashGridElement

class	MeshReader

class	MeshReaderExodusII

class	MeshReaderH1DXML

class	MeshReaderH2D

class	MeshReaderH2DXML

class	MeshUtil

class	mono_lu_init

class	MultimeshDGNeighborTree

class	MultimeshDGNeighborTreeNode

class	NeighborSearch
	This class characterizes a neighborhood of a given edge in terms of adjacent elements and provides methods for getting limit values of discontinuous functions from both sides of the edge. More...

class	NewtonSolver

struct	Node
	Stores one node of a mesh. More...

class	NormForm

class	NormFormDG

class	NormFormSurf

class	NormFormVol

class	Nurbs
	Represents one NURBS curve. More...

singleton	OGProjection
	Class for (global) orthogonal projecting. If the projection is not necessary (if a solution belongs to the space), then its solution vector is used. More...

class	PicardSolver

class	PNGGraph

class	PrecalcShapeset
	Caches precalculated shape function values. More...

class	PrecalcShapesetAssembling
	PrecalcShapeset variant for fast assembling. More...

class	PrecalcShapesetAssemblingInternal

class	PrecalcShapesetAssemblingStorage
	PrecalcShapesetAssembling common storage. More...

class	Quad1D

class	Quad1DStd
	1D quadrature points on the standard reference domain (-1,1) More...

class	Quad2D

class	Quad2DCheb

class	Quad2DLin

class	Quad2DStd
	2D quadrature points on the standard reference domains (-1,1)^2 More...

class	RealFilter
	Removes the imaginary part from a function. More...

struct	Rect

class	RefMap
	Represents the reference mapping. More...

singleton	RungeKutta

class	Shapeset
	Should be exactly the same as is the count of enum ShapesetType. More...

class	SimpleFilter

class	SimpleGraph

singleton	Solution
	Represents the solution of a PDE. More...

class	Solver

singleton	Space
	Represents a finite element space over a domain. More...

class	SpaceSharedPtr
	Used to pass the instances of Space around. More...

class	SquareFilter
	Calculates the square of a function. More...

class	StateReassemblyHelper

class	SumFilter
	Calculates the sum of two functions. More...

struct	SurfPos
	Determines the position on an element surface (edge in 2D and Face in 3D). More...

class	TopValFilter
	TopValFilter takes functions and puts a threshold on their highest values. More...

class	Transformable

class	Traverse

struct	Trf
	2D transformation. More...

class	UExtFunction
	Function operating on previous nonlinear solutions in assembling (u_ext) More...

class	UExtFunctionSharedPtr

struct	UniData

class	ValFilter
	ValFilter takes functions and puts a threshold on their lowest AND highest values. More...

class	VectorDefaultNormFormVol

class	VectorForm
	Abstract, base class for vector form - i.e. a single integral in the linear form on the right hand side of the variational formulation of a (system of) PDE. More...

class	VectorFormDG
	Abstract, base class for vector DG form - i.e. linear Form, where the integration is with respect to 1D-Lebesgue measure (element inner-domain edges). More...

class	VectorFormSurf
	Abstract, base class for vector Surface form - i.e. VectorForm, where the integration is with respect to 1D-Lebesgue measure (element domain-boundary edges). More...

class	VectorFormVol
	Abstract, base class for vector Volumetric form - i.e. VectorForm, where the integration is with respect to 2D-Lebesgue measure (elements). More...

class	VonMisesFilter
	Calculates the Von Mises stress. More...

class	WeakForm
	Represents the weak formulation of a PDE problem. More...

class	WeakFormSharedPtr
	Used to pass the instances of WeakForm around. More...

class	ZeroSolution

class	ZeroSolutionVector

Typedefs
typedef std::tr1::shared_ptr < Hermes::Hermes2D::Mesh >	MeshSharedPtr

typedef H1ShapesetJacobi	H1Shapeset
	Experimental. More...

typedef HcurlShapesetGradLeg	HcurlShapeset
	This is the default Hcurl shapeset typedef.

typedef HdivShapesetLegendre	HdivShapeset
	This is the default Hdiv shapeset typedef.

typedef L2ShapesetLegendre	L2Shapeset
	This is the default shapeset typedef.

Enumerations
enum	AdaptivityType { pAdaptivity, hAdaptivity, hpAdaptivity }

enum	CalculatedErrorType { AbsoluteError, RelativeErrorToElementNorm, RelativeErrorToGlobalNorm }
	Enum passed to the class ErrorCalculator specifying the calculated errors.

enum	Hermes2DApiParam { xmlSchemasDirPath, precalculatedFormsDirPath }
	Enumeration of potential keys in the Api2D::parameters storage.

enum	EssentialBCValueType { BC_FUNCTION, BC_CONST }
	Types of description of boundary values, either a function (callback), or a constant.

enum	{ H2D_FN_VAL_0 = 0x0001, H2D_FN_VAL_1 = 0x0040, H2D_FN_DX_0 = 0x0002, H2D_FN_DX_1 = 0x0080, H2D_FN_DY_0 = 0x0004, H2D_FN_DY_1 = 0x0100 }
	Precalculation masks.

enum	SolutionType { HERMES_UNDEF = -1, HERMES_SLN = 0, HERMES_EXACT = 1 }

enum	NormType { HERMES_L2_NORM, HERMES_H1_NORM, HERMES_H1_SEMINORM, HERMES_HCURL_NORM, HERMES_HDIV_NORM, HERMES_UNSET_NORM }

enum	ElementMode2D { HERMES_MODE_TRIANGLE = 0, HERMES_MODE_QUAD = 1 }

enum	SpaceType { HERMES_H1_SPACE = 0, HERMES_HCURL_SPACE = 1, HERMES_HDIV_SPACE = 2, HERMES_L2_SPACE = 3, HERMES_L2_MARKERWISE_CONST_SPACE = 4, HERMES_INVALID_SPACE = -9999 }

enum	ShapesetType { HERMES_H1_JACOBI = 0, HERMES_L2_LEGENDRE = 1, HERMES_L2_TAYLOR = 2, HERMES_HDIV_LEGENDRE = 3, HERMES_HCURL_GRADLEG = 4 }
	Important not to change the indices - used in an array enumeration.

enum	GeomType { HERMES_PLANAR = 0, HERMES_AXISYM_X = 1, HERMES_AXISYM_Y = 2 }
	Geometrical type of weak forms.

enum	SymFlag { HERMES_ANTISYM = -1, HERMES_NONSYM = 0, HERMES_SYM = 1 }
	Bilinear form symmetry flag, see WeakForm::add_matrix_form.

enum	LinearizerOutputType { OpenGL, FileExport }

enum	CurvType { ArcType, NurbsType }

enum	{ HERMES_TYPE_VERTEX = 0, HERMES_TYPE_EDGE = 1 }

enum	FunctionsEvaluatedType { CoarseSolutions, FineSolutions, SolutionsDifference }
	Enum passed to the class NormForm specifying the functions the form acts upon.

enum	GIP2DIndices { H2D_GIP2D_X = 0, H2D_GIP2D_Y = 1, H2D_GIP2D_W = 2 }
	Indices of values in the value returned by Quad2D::get_points(). More...

enum	RefinementType { H2D_REFINEMENT_P = 0, H2D_REFINEMENT_H = 1, H2D_REFINEMENT_H_ANISO_H = 2, H2D_REFINEMENT_H_ANISO_V = 3 }
	Possible refinements of an element. More...

enum	FunctionExpansionIndex { H2D_FEI_VALUE = 0, H2D_FEI_DX = 1, H2D_FEI_DY = 2, H2D_FEI_DXX = 3, H2D_FEI_DYY = 4, H2D_FEI_DXY = 5 }
	Index of a function expansion. Used to selected a value in Shapeset::get_value(). More...

Functions
HERMES_API unsigned char	init_geometry_points_allocated (RefMap *reference_mapping, unsigned short reference_mapping_count, int order, GeomVol< double > &geometry, double jacobian_x_weights)

HERMES_API unsigned char	init_geometry_points_allocated (RefMap rep_reference_mapping, int order, GeomVol< double > &geometry, double jacobian_x_weights)

HERMES_API unsigned char	init_surface_geometry_points_allocated (RefMap *reference_mapping, unsigned short reference_mapping_count, int &order, unsigned char isurf, int marker, GeomSurf< double > &geometry, double jacobian_x_weights)

HERMES_API unsigned char	init_surface_geometry_points_allocated (RefMap rep_reference_mapping, int &order, unsigned char isurf, int marker, GeomSurf< double > &geometry, double jacobian_x_weights)

HERMES_API GeomVol< double > *	init_geom_vol (RefMap *rm, const int order)
	Init element geometry for volumetric integrals.

HERMES_API void	init_geom_vol_allocated (GeomVol< double > &geom, RefMap *rm, const int order)
	Init element geometry for volumetric integrals.

HERMES_API GeomSurf< double > *	init_geom_surf (RefMap rm, unsigned char isurf, int marker, const int order, double3 &tan)
	Init element geometry for surface integrals.

HERMES_API void	init_geom_surf_allocated (GeomSurf< double > &geom, RefMap rm, unsigned char isurf, int marker, const int order, double3 &tan)
	Init element geometry for surface integrals.

HERMES_API Func< double > *	init_fn (PrecalcShapeset fu, RefMap rm, const int order)
	Init the shape function for the evaluation of the volumetric/surface integral (transformation of values).

template<typename Scalar >
HERMES_API Func< Scalar > *	init_fn (MeshFunction< Scalar > *fu, const int order)
	Init the mesh-function for the evaluation of the volumetric/surface integral.

template<typename Scalar >
HERMES_API Func< Scalar > *	preallocate_fn (pj_pool_t *memoryPool=nullptr)
	Preallocate the Func (all we need is np & nc).

HERMES_API void	init_fn_preallocated (Func< double > u, PrecalcShapeset fu, RefMap *rm, const int order)
	Init the shape function for the evaluation of the volumetric/surface integral (transformation of values) - preallocated version.

template<typename Scalar >
HERMES_API void	init_fn_preallocated (Func< Scalar > u, MeshFunction< Scalar > fu, const int order)
	Init the mesh-function for the evaluation of the volumetric/surface integral - preallocated version.

template<typename Scalar >
HERMES_API void	init_fn_preallocated (Func< Scalar > u, UExtFunction< Scalar > fu, Func< Scalar > ext, Func< Scalar > u_ext, const int order, Geom< double > *geometry, ElementMode2D mode)
	Init UExt function - preallocated version.

template<typename Scalar >
HERMES_API Func< Scalar > *	init_zero_fn (ElementMode2D mode, int order, Quad2D *quad_2d=nullptr, int nc=1)

template<typename Scalar >
HERMES_API Func< Scalar > *	init_fn (UExtFunction< Scalar > fu, Func< Scalar > ext, Func< Scalar > u_ext, const int order, Geom< double > geometry, ElementMode2D mode)
	Init UExt function - volumetric.

const char *	spaceTypeToString (SpaceType spaceType)

SpaceType	spaceTypeFromString (const char *spaceTypeString)

HERMES_API void	set_order_limit_table (int tri_table, unsigned short quad_table, unsigned short n)
	can be called to set a custom order limiting table

HERMES_API void	update_limit_table (ElementMode2D mode)

HERMES_API void	limit_order (int &o, ElementMode2D mode)

HERMES_API void	limit_order_nowarn (int &o, ElementMode2D mode)

HERMES_API bool	is_refin_aniso (const RefinementType refin_type)
	Retuns true if a given refinement is an ANISO-refinement. More...

HERMES_API int	get_refin_sons (const RefinementType refin_type)
	Returns a maximum number of sons that will be generated if a given refinement is applied. More...

HERMES_API const std::string	get_refin_str (const RefinementType refin_type)
	Returns a string representation of the refinement. More...

template<typename Real >
Real	int_v (int n, double wt, Func< Real > v)

template<typename Real , typename Geom >
Real	int_x_v (int n, double wt, Func< Real > v, Geom *e)

template<typename Real , typename Geom >
Real	int_y_v (int n, double wt, Func< Real > v, Geom *e)

template<typename Real , typename Scalar >
Scalar	int_u_v (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_u_ext_v (int n, double wt, Func< Scalar > u_ext, Func< Real > *v)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_x_u_v (int n, double wt, Func< Real > u, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_x_u_ext_v (int n, double wt, Func< Scalar > u_ext, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_y_u_v (int n, double wt, Func< Real > u, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_y_u_ext_v (int n, double wt, Func< Scalar > u_ext, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_F_v (int n, double wt, Real(F)(Real x, Real y), Func< Real > v, Geom e)

template<typename Real , typename Scalar >
Scalar	int_grad_u_grad_v (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_grad_u_ext_grad_v (int n, double wt, Func< Scalar > u_ext, Func< Real > *v)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_x_grad_u_grad_v (int n, double wt, Func< Real > u, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_x_grad_u_ext_grad_v (int n, double wt, Func< Scalar > u_ext, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_y_grad_u_grad_v (int n, double wt, Func< Real > u, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_y_grad_u_ext_grad_v (int n, double wt, Func< Scalar > u_ext, Func< Real > v, Geom e)

template<typename Real , typename Scalar >
Scalar	int_dudx_v (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_dudy_v (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_u_dvdx (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_u_dvdx_over_x (int n, double wt, Func< Real > u, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_u_ext_dvdx_over_x (int n, double wt, Func< Scalar > u_ext, Func< Real > v, Geom e)

template<typename Real , typename Scalar >
Scalar	int_u_dvdy (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_u_dvdy_over_y (int n, double wt, Func< Real > u, Func< Real > v, Geom e)

template<typename Real , typename Scalar , typename Geom >
Scalar	int_u_ext_dvdy_over_y (int n, double wt, Func< Scalar > u_ext, Func< Real > v, Geom e)

template<typename Real , typename Scalar >
Scalar	int_dudx_dvdx (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_dudy_dvdy (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_dudx_dvdy (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_dudy_dvdx (int n, double wt, Func< Real > u, Func< Real > *v)

template<typename Real , typename Scalar >
Scalar	int_w_nabla_u_v (int n, double wt, Func< Real > w1, Func< Real > w2, Func< Real > u, Func< Real > *v)

template<typename Scalar >
double	int_h1_error (Function< Scalar > fu, Function< Scalar > fv, RefMap ru, RefMap rv)

template<typename Scalar >
double	int_h1_semi_error (Function< Scalar > fu, Function< Scalar > fv, RefMap ru, RefMap rv)

template<typename Scalar >
double	int_l2_error (Function< Scalar > fu, Function< Scalar > fv, RefMap ru, RefMap rv)

template<typename Scalar >
double	int_dx_error (Function< Scalar > fu, Function< Scalar > fv, RefMap ru, RefMap rv)

template<typename Scalar >
double	int_dy_error (Function< Scalar > fu, Function< Scalar > fv, RefMap ru, RefMap rv)

template<typename Scalar >
double	int_h1_norm (Function< Scalar > fu, RefMap ru)

template<typename Scalar >
double	int_h1_seminorm (Function< Scalar > fu, RefMap ru)

template<typename Scalar >
double	int_l2_norm (Function< Scalar > fu, RefMap ru)

template<>
bool	compare (std::complex< double > a, std::complex< double > b)

template<>
bool	compare (double a, double b)

template<typename Scalar >
void	get_states_to_reassemble (Traverse::State *&states, unsigned int &num_states, SparseMatrix< Scalar > mat, Vector< Scalar > rhs, Vector< Scalar > dirichlet_lift_rhs, Scalar *&coeff_vec)

template<typename Scalar >
Func< Scalar > *	init_fn (MeshFunction< Scalar > *fu, const int order)
	Init the mesh-function for the evaluation of the volumetric/surface integral.

template<typename Scalar >
Func< Scalar > *	preallocate_fn (pj_pool_t *memoryPool)
	Preallocate the Func (all we need is np & nc).

template<typename Scalar >
void	init_fn_preallocated (Func< Scalar > u, MeshFunction< Scalar > fu, const int order)
	Init the mesh-function for the evaluation of the volumetric/surface integral - preallocated version.

template<typename Scalar >
void	init_fn_preallocated (Func< Scalar > u, UExtFunction< Scalar > fu, Func< Scalar > ext, Func< Scalar > u_ext, const int order, Geom< double > *geometry, ElementMode2D mode)
	Init UExt function - preallocated version.

template<typename Scalar >
Func< Scalar > *	init_zero_fn (ElementMode2D mode, int order, Quad2D *quad, int nc)

template<typename Scalar >
Func< Scalar > *	init_fn (UExtFunction< Scalar > fu, Func< Scalar > ext, Func< Scalar > u_ext, const int order, Geom< double > geometry, ElementMode2D mode)
	Init UExt function - volumetric.

template HERMES_API Func < double > *	init_fn (MeshFunction< double > *fu, const int order)

template HERMES_API Func < std::complex< double > > *	init_fn (MeshFunction< std::complex< double > > *fu, const int order)

template HERMES_API void	init_fn_preallocated (Func< double > u, MeshFunction< double > fu, const int order)

template HERMES_API void	init_fn_preallocated (Func< std::complex< double > > u, MeshFunction< std::complex< double > > fu, const int order)

template HERMES_API void	init_fn_preallocated (Func< double > u, UExtFunction< double > fu, Func< double > ext, Func< double > u_ext, const int order, Geom< double > *geometry, ElementMode2D mode)

template HERMES_API void	init_fn_preallocated (Func< std::complex< double > > u, UExtFunction< std::complex< double > > fu, Func< std::complex< double > > ext, Func< std::complex< double > > u_ext, const int order, Geom< double > *geometry, ElementMode2D mode)

template HERMES_API Func < double > *	init_fn (UExtFunction< double > fu, Func< double > ext, Func< double > u_ext, const int order, Geom< double > geometry, ElementMode2D mode)

template HERMES_API Func < std::complex< double > > *	init_fn (UExtFunction< std::complex< double > > fu, Func< std::complex< double > > ext, Func< std::complex< double > > u_ext, const int order, Geom< double > geometry, ElementMode2D mode)

int	rtb_criterion (Element *e)

template HERMES_API Traverse::State **	Traverse::get_states< std::complex< double > > (std::vector< MeshFunctionSharedPtr< std::complex< double > > > mesh_functions, unsigned int &states_count)

HERMES_API void	set_order_limit_table (unsigned short tri_table, unsigned short quad_table, unsigned short n)

HERMES_API void	reset_warn_order ()

HERMES_API void	warn_order ()

Variables
HERMES_API Hermes::Hermes2D::Api2D	Hermes2DApi
	Global instance used inside Hermes which is also accessible to users.

const int	H2D_FN_VAL = H2D_FN_VAL_0 \| H2D_FN_VAL_1
	Both components are usually requested together...

const int	H2D_FN_DX = H2D_FN_DX_0 \| H2D_FN_DX_1

const int	H2D_FN_DY = H2D_FN_DY_0 \| H2D_FN_DY_1

const int	H2D_FN_DEFAULT = H2D_FN_VAL \| H2D_FN_DX \| H2D_FN_DY
	default precalculation mask

const int	H2D_FN_COMPONENT_0 = H2D_FN_VAL_0 \| H2D_FN_DX_0 \| H2D_FN_DY_0

const int	H2D_FN_COMPONENT_1 = H2D_FN_VAL_1 \| H2D_FN_DX_1 \| H2D_FN_DY_1

const int	H2D_GRAD = H2D_FN_DX_0 \| H2D_FN_DY_0

const int	H2D_CURL = H2D_FN_DX \| H2D_FN_DY

HERMES_API Trf	tri_trf [H2D_TRF_NUM]
	A table of triangle sub-subdomain transforms. Only first ::H2D_TRF_TRI_NUM transformations are valid, the rest are identity transformation. More...

HERMES_API Trf	quad_trf [H2D_TRF_NUM]
	A table of quad sub-subdomain transforms. Only first ::H2D_TRF_QUAD_NUM transformations are valid, the rest are identity transformation. More...

const int	H2D_ORDER_BITS = 5
	How many bits the encoded_order number takes.

const int	H2D_ORDER_MASK = (1 << H2D_ORDER_BITS) - 1

CurvMapStatic	curvMapStatic
	Global instance used inside Hermes which is also accessible to users.

const int	TOP_LEVEL_REF = 123456

HERMES_API unsigned	g_mesh_seq = 0

HERMES_API unsigned short	g_safe_max_order
	limit_order is used in integrals

HERMES_API unsigned short	g_max_order

HERMES_API Quad1DStd	g_quad_1d_std

HERMES_API Quad2DStd	g_quad_2d_std

double3	lin_pts_0_tri []

double3	lin_pts_0_quad []

double3	lin_pts_1_tri [12]

double3	lin_pts_1_quad [21]

unsigned short	quad_indices [9][5]

unsigned short	tri_indices [5][3]

unsigned char	lin_np_tri [2] = { 3, 12 }

unsigned char	lin_np_quad [2] = { 4, 21 }

unsigned char *	lin_np [2] = { lin_np_tri, lin_np_quad }

double3 *	lin_tables_tri [2] = { lin_pts_0_tri, lin_pts_1_tri }

double3 *	lin_tables_quad [2] = { lin_pts_0_quad, lin_pts_1_quad }

double3 **	lin_tables [2] = { lin_tables_tri, lin_tables_quad }

HERMES_API Quad2DLin	g_quad_lin

template HERMES_API class	AdaptStoppingCriterionCumulative< double >

template HERMES_API class	AdaptStoppingCriterionSingleElement< double >

template HERMES_API class	AdaptStoppingCriterionLevels< double >

template HERMES_API class	Adapt< double >

template HERMES_API class	AdaptSolver< double, LinearSolver< double > >

template HERMES_API class	DefaultErrorCalculator< double, HERMES_H1_NORM >

template HERMES_API class	DefaultErrorCalculator< double, HERMES_L2_NORM >

template HERMES_API class	DefaultErrorCalculator< double, HERMES_H1_SEMINORM >

template HERMES_API class	DefaultErrorCalculator< double, HERMES_HCURL_NORM >

template HERMES_API class	DefaultErrorCalculator< double, HERMES_HDIV_NORM >

template HERMES_API class	DefaultNormCalculator< double, HERMES_H1_NORM >

template HERMES_API class	DefaultNormCalculator< double, HERMES_L2_NORM >

template HERMES_API class	DefaultNormCalculator< double, HERMES_H1_SEMINORM >

template HERMES_API class	DefaultNormCalculator< double, HERMES_HCURL_NORM >

template HERMES_API class	DefaultNormCalculator< double, HERMES_HDIV_NORM >

template HERMES_API class	ErrorCalculator< double >

template HERMES_API class	ErrorThreadCalculator< double >

template HERMES_API class	AsmList< double >

template HERMES_API class	EssentialBoundaryCondition< double >

template HERMES_API class	DefaultEssentialBCConst< double >

template HERMES_API class	DefaultEssentialBCNonConst< double >

template HERMES_API class	EssentialBCs< double >

template class HERMES_API	DiscreteProblemDGAssembler< double >

template class HERMES_API	MultimeshDGNeighborTree< double >

template class HERMES_API	DiscreteProblem< double >

double	wt_order = 1.0
	"Fake" integration weight for order calculation.

Func< Hermes::Ord >	func_order [g_max_quad+1]

template class HERMES_API	DiscreteProblemIntegrationOrderCalculator< double >

template class HERMES_API	DiscreteProblemSelectiveAssembler< double >

template class HERMES_API	DiscreteProblemThreadAssembler< double >

template class HERMES_API	DiscontinuousFunc< double >

template class HERMES_API	GeomVol< double >

template class HERMES_API	GeomSurf< double >

template class HERMES_API	Geom< double >

template class HERMES_API	InterfaceGeom< double >

template class HERMES_API	UExtFunctionSharedPtr< double >

template HERMES_API class	ExactSolutionScalar< double >

template HERMES_API class	ExactSolutionConstantArray< double, double >

template HERMES_API class	ExactSolutionConstantArray< double, int >

template HERMES_API class	ExactSolutionConstantArray< double, unsigned int >

template HERMES_API class	ExactSolutionConstantArray< double, bool >

template HERMES_API class	ExactSolutionVector< double >

template HERMES_API class	ConstantSolution< double >

template HERMES_API class	ConstantSolutionVector< double >

template HERMES_API class	ZeroSolution< double >

template HERMES_API class	ZeroSolutionVector< double >

template HERMES_API class	UExtFunction< double >

template class HERMES_API	Filter< double >

template class HERMES_API	SimpleFilter< double >

template class HERMES_API	DXDYFilter< double >

template class HERMES_API	MagFilter< double >

template class HERMES_API	DiffFilter< double >

template class HERMES_API	SumFilter< double >

template class HERMES_API	SquareFilter< double >

template class HERMES_API	Function< double >

template class HERMES_API	MeshFunctionSharedPtr< double >

template class HERMES_API	MeshFunction< double >

class Hermes::Hermes2D::mono_lu_init	mono_lu

template class HERMES_API	Solution< double >

H1ShapesetJacobi	ref_map_shapeset

template class HERMES_API	NeighborSearch< double >

template HERMES_API class	NormFormVol< double >

template HERMES_API class	NormFormSurf< double >

template HERMES_API class	NormFormDG< double >

template HERMES_API class	DefaultNormFormVol< double >

template HERMES_API class	DefaultNormFormSurf< double >

template HERMES_API class	MatrixDefaultNormFormVol< double >

template HERMES_API class	VectorDefaultNormFormVol< double >

template class HERMES_API	OGProjection< double >

template class HERMES_API	LinearSolver< double >

template class HERMES_API	NewtonSolver< double >

template class HERMES_API	PicardSolver< double >

template class HERMES_API	RungeKutta< double >

template class HERMES_API	Solver< double >

unsigned	g_space_seq = 0

template class HERMES_API	Space< double >

template class HERMES_API	SpaceSharedPtr< double >

template HERMES_API class	H1Space< double >

template class HERMES_API	HcurlSpace< double >

template HERMES_API class	HdivSpace< double >

template HERMES_API class	L2Space< double >

template HERMES_API class	L2MarkerWiseConstSpace< double >

template class HERMES_API	WeakForm< double >

template class HERMES_API	Form< double >

template class HERMES_API	MatrixForm< double >

template class HERMES_API	MatrixFormVol< double >

template class HERMES_API	MatrixFormSurf< double >

template class HERMES_API	MatrixFormDG< double >

template class HERMES_API	VectorForm< double >

template class HERMES_API	VectorFormVol< double >

template class HERMES_API	VectorFormSurf< double >

template class HERMES_API	VectorFormDG< double >

template class HERMES_API	WeakFormSharedPtr< double >

Detailed Description

Namespace containing definitions specific for Hermes2D.

Typedef Documentation

typedef H1ShapesetJacobi Hermes::Hermes2D::H1Shapeset

Experimental.

This is the default shapeset typedef

Definition at line 59 of file shapeset_h1_all.h.

Enumeration Type Documentation

enum Hermes::Hermes2D::AdaptivityType

h-, p-, hp-adaptivity Also influences the selectors - i.e. for h-, or p- adaptivity

Definition at line 56 of file adapt_solver.h.

enum Hermes::Hermes2D::ElementMode2D

Element type identification. The enum values must not change.

Definition at line 121 of file global.h.

enum Hermes::Hermes2D::FunctionExpansionIndex

Index of a function expansion. Used to selected a value in Shapeset::get_value().

Enumerator
H2D_FEI_VALUE	Index of a function value f.
H2D_FEI_DX	Index of df/dx.
H2D_FEI_DY	Index of df/dy.
H2D_FEI_DXX	Index of df/dxdx.
H2D_FEI_DYY	Index of df/dydy.
H2D_FEI_DXY	Index of df/dxdy.

Definition at line 25 of file shapeset.h.

enum Hermes::Hermes2D::GIP2DIndices

Indices of values in the value returned by Quad2D::get_points().

Enumerator
H2D_GIP2D_X	X-axis coordinate.
H2D_GIP2D_Y	Y-axis coordinate.
H2D_GIP2D_W	A weight.

Definition at line 25 of file quad.h.

enum Hermes::Hermes2D::LinearizerOutputType

Linearizer can store data in an effective way depending on the purpose.

whether it is an OpenGL (Hermes views, Agros2d) or a file export (VTK, Tecplot)

Definition at line 165 of file global.h.

enum Hermes::Hermes2D::NormType

Projection norms. Used in projections and adaptivity.

Definition at line 109 of file global.h.

enum Hermes::Hermes2D::RefinementType

Possible refinements of an element.

Enumerator
H2D_REFINEMENT_P	P-refinement.
H2D_REFINEMENT_H	H-refinement.
H2D_REFINEMENT_H_ANISO_H	ANISO-refienement. The element is split along the horizontal axis. Quadrilaterals only.
H2D_REFINEMENT_H_ANISO_V	ANISO-refienement. The element is split along the vertical axis. Quadrilaterals only.

Definition at line 26 of file element_to_refine.h.

Function Documentation

int HERMES_API Hermes::Hermes2D::get_refin_sons ( const RefinementType refin_type )

Returns a maximum number of sons that will be generated if a given refinement is applied.

Parameters

[in] refin_type A refinement type. Possible values are defined in the enum RefinementType.

Returns: A number of possible sons. In a case of P-refinement, the function returns 1 even thought this refinement yields just a change in orders.

Definition at line 15 of file element_to_refine.cpp.

Referenced by Hermes::Hermes2D::RefinementSelectors::OptimumSelector< Scalar >::append_candidates_split(), and Hermes::Hermes2D::ElementToRefine::get_num_sons().

const HERMES_API std::string Hermes::Hermes2D::get_refin_str ( const RefinementType refin_type )

Returns a string representation of the refinement.

Used for debugging and event logging purposes.

Parameters

[in] refin_type A refinement type. Possible values are defined in the enum RefinementType.

Returns: A string representation of a given refinement.

Definition at line 27 of file element_to_refine.cpp.

unsigned char Hermes::Hermes2D::init_geometry_points_allocated	(	RefMap **	reference_mapping,
		unsigned short	reference_mapping_count,
		int	order,
		GeomVol< double > &	geometry,
		double *	jacobian_x_weights
	)

{*, *} Init geometry, jacobian * weights, return the number of integration points.

Definition at line 104 of file discrete_problem_helpers.cpp.

Referenced by Hermes::Hermes2D::PostProcessing::VolumetricIntegralCalculator< Scalar >::calculate().

template<typename Scalar >

template HERMES_API Func< std::complex< double > > * Hermes::Hermes2D::init_zero_fn	(	ElementMode2D	mode,
		int	order,
		Quad2D *	quad_2d = `nullptr`,
		int	nc = `1`
	)

Utilities follow Init zero function

Definition at line 733 of file forms.cpp.

template<typename Scalar >

Func<Scalar>* Hermes::Hermes2D::init_zero_fn	(	ElementMode2D	mode,
		int	order,
		Quad2D *	quad_2d = `nullptr`,
		int	nc = `1`
	)

Utilities follow Init zero function

Definition at line 733 of file forms.cpp.

bool HERMES_API Hermes::Hermes2D::is_refin_aniso ( const RefinementType refin_type )

Retuns true if a given refinement is an ANISO-refinement.

Parameters

[in] refin_type A refinement type. Possible values are defined in the enum RefinementType.

Returns: True of a given refinement is an ANISO-refinement.

Definition at line 7 of file element_to_refine.cpp.

HERMES_API void Hermes::Hermes2D::warn_order ( )

Todo:: Fix this, so that it complies with the rest of the code.

Definition at line 66 of file limit_order.cpp.

Variable Documentation

Func<Hermes::Ord> Hermes::Hermes2D::func_order[g_max_quad+1]

Initial value:

=
    {
      Func<Hermes::Ord>(0),
      Func<Hermes::Ord>(1),
      Func<Hermes::Ord>(2),
      Func<Hermes::Ord>(3),
      Func<Hermes::Ord>(4),
      Func<Hermes::Ord>(5),
      Func<Hermes::Ord>(6),
      Func<Hermes::Ord>(7),
      Func<Hermes::Ord>(8),
      Func<Hermes::Ord>(9),
      Func<Hermes::Ord>(10),
      Func<Hermes::Ord>(11),
      Func<Hermes::Ord>(12),
      Func<Hermes::Ord>(13),
      Func<Hermes::Ord>(14),
      Func<Hermes::Ord>(15),
      Func<Hermes::Ord>(16),
      Func<Hermes::Ord>(17),
      Func<Hermes::Ord>(18),
      Func<Hermes::Ord>(19),
      Func<Hermes::Ord>(20),
      Func<Hermes::Ord>(21),
      Func<Hermes::Ord>(22),
      Func<Hermes::Ord>(23),
      Func<Hermes::Ord>(24)
    }

Definition at line 43 of file discrete_problem_integration_order_calculator.cpp.

double3 Hermes::Hermes2D::lin_pts_0_quad

Initial value:

=
    {
      { -1.0, -1.0, 0.0 },
      { 1.0, -1.0, 0.0 },
      { 1.0, 1.0, 0.0 },
      { -1.0, 1.0, 0.0 }
    }

Definition at line 2576 of file quad_std.cpp.

double3 Hermes::Hermes2D::lin_pts_0_tri

Initial value:

=
    {
      { -1.0, -1.0, 0.0 },
      { 1.0, -1.0, 0.0 },
      { -1.0, 1.0, 0.0 }
    }

The tables with index zero are for obtaining solution values at the element vertices. Index one tables serve for the retrieval of interior values. Index one tables are used for adaptive approximation of the solution by transforming their points to sub-elements. Actually, the tables contain two levels of refinement – this is an optimization to reduce the number of calls to sln->get_values().

Definition at line 2569 of file quad_std.cpp.

double3 Hermes::Hermes2D::lin_pts_1_quad

Initial value:

=
    {
      { 0.0, -1.0, 0.0 }, 
      { 1.0, 0.0, 0.0 }, 
      { 0.0, 1.0, 0.0 }, 
      { -1.0, 0.0, 0.0 }, 
      { 0.0, 0.0, 0.0 }, 
      { -0.5, -1.0, 0.0 }, 
      { 0.0, -0.5, 0.0 }, 
      { -0.5, 0.0, 0.0 }, 
      { -1.0, -0.5, 0.0 }, 
      { -0.5, -0.5, 0.0 }, 
      { 0.5, -1.0, 0.0 }, 
      { 1.0, -0.5, 0.0 }, 
      { 0.5, 0.0, 0.0 }, 
      { 0.5, -0.5, 0.0 }, 
      { 1.0, 0.5, 0.0 }, 
      { 0.5, 1.0, 0.0 }, 
      { 0.0, 0.5, 0.0 }, 
      { 0.5, 0.5, 0.0 }, 
      { -0.5, 1.0, 0.0 }, 
      { -1.0, 0.5, 0.0 }, 
      { -0.5, 0.5, 0.0 }  
    }

Definition at line 2600 of file quad_std.cpp.

double3 Hermes::Hermes2D::lin_pts_1_tri

Initial value:

=
    {
      { 0.0, -1.0, 0.0 }, 
      { 0.0, 0.0, 0.0 }, 
      { -1.0, 0.0, 0.0 }, 
      { -0.5, -1.0, 0.0 }, 
      { -0.5, -0.5, 0.0 }, 
      { -1.0, -0.5, 0.0 }, 
      { 0.5, -1.0, 0.0 }, 
      { 0.5, -0.5, 0.0 }, 
      { 0.0, -0.5, 0.0 }, 
      { -0.5, 0.0, 0.0 }, 
      { -0.5, 0.5, 0.0 }, 
      { -1.0, 0.5, 0.0 }  
    }

Definition at line 2584 of file quad_std.cpp.

unsigned short Hermes::Hermes2D::quad_indices

Initial value:

=
    {
      { 0, 1, 2, 3, 4 },
      { 5, 6, 7, 8, 9 }, { 10, 11, 12, 6, 13 },
      { 12, 14, 15, 16, 17 }, { 7, 16, 18, 19, 20 },
      { 0, 11, 4, 8, 6 }, { 4, 14, 2, 19, 16 },
      { 5, 4, 18, 3, 7 }, { 10, 1, 15, 4, 12 }
    }

Definition at line 2625 of file quad_std.cpp.

Trf Hermes::Hermes2D::quad_trf

Initial value:

=
    {
      { { 0.5, 0.5 }, { -0.5, -0.5 } }, 
      { { 0.5, 0.5 }, { 0.5, -0.5 } }, 
      { { 0.5, 0.5 }, { 0.5, 0.5 } }, 
      { { 0.5, 0.5 }, { -0.5, 0.5 } }, 
      { { 1.0, 0.5 }, { 0.0, -0.5 } }, 
      { { 1.0, 0.5 }, { 0.0, 0.5 } }, 
      { { 0.5, 1.0 }, { -0.5, 0.0 } }, 
      { { 0.5, 1.0 }, { 0.5, 0.0 } }, 
      { H2D_IDENTIFY_TRF }              
    }

A table of quad sub-subdomain transforms. Only first ::H2D_TRF_QUAD_NUM transformations are valid, the rest are identity transformation.

Definition at line 37 of file transformable.cpp.

Referenced by Hermes::Hermes2D::RefinementSelectors::ProjBasedSelector< Scalar >::calc_projection_errors().

unsigned short Hermes::Hermes2D::tri_indices

Initial value:

=
    {
      { 0, 1, 2 }, { 3, 4, 5 }, { 6, 7, 8 }, { 9, 10, 11 }, { 9, 4, 8 }
    }

Definition at line 2634 of file quad_std.cpp.

Trf Hermes::Hermes2D::tri_trf

Initial value:

=
    {
      { { 0.5, 0.5 }, { -0.5, -0.5 } }, 
      { { 0.5, 0.5 }, { 0.5, -0.5 } }, 
      { { 0.5, 0.5 }, { -0.5, 0.5 } }, 
      { { -0.5, -0.5 }, { -0.5, -0.5 } }, 
      { H2D_IDENTIFY_TRF },              
      { H2D_IDENTIFY_TRF },              
      { H2D_IDENTIFY_TRF },              
      { H2D_IDENTIFY_TRF },              
      { H2D_IDENTIFY_TRF }               
    }

A table of triangle sub-subdomain transforms. Only first ::H2D_TRF_TRI_NUM transformations are valid, the rest are identity transformation.

Definition at line 24 of file transformable.cpp.

Referenced by Hermes::Hermes2D::RefinementSelectors::ProjBasedSelector< Scalar >::calc_projection_errors().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation