ptems::HPPredictedErrorStrategy< DIM, X, N > Class Template Reference

Class for performing \(hp\)-adaptive refinement, where the selection on whether to perform \(h\)- or \(p\)-refinement is based on the predicted convergence rate of the error estimate for a smooth or non-smooth function; cf. More...

#include <ptems/hpstrategies.hpp>

Inheritance diagram for ptems::HPPredictedErrorStrategy< DIM, X, N >:

Collaboration diagram for ptems::HPPredictedErrorStrategy< DIM, X, N >:

Public Member Functions
	HPPredictedErrorStrategy (const PDiscreteFunctionSpace< DIM, X, N > &space, double gammaH, double gammaP, double gammaN=1, std::size_t minP=1, bool preferP=false)
	Creates an object for performing \(hp\)-adaptive refinement based on the predicted convergence rate of the error estimate. More...
	HPPredictedErrorStrategy (const PDiscreteFunctionSpace< DIM, X, N > &space, double gammaH, double gammaP, bool preferP)
	Creates an object for performing \(hp\)-adaptive refinement based on the predicted convergence rate of the error estimate. More...
const PDiscreteFunctionSpace< DIM, double, N > &	Space ()
	Gets the finite element space the refinement strategy is on. More...
FEMesh< DIM >::Modifications	AdaptWithStrategyAndDefaultSmoothing (const Estimators &estimators, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor, and with default mesh smoothing options (default constructed MeshSmoother). More...
FEMesh< DIM >::Modifications	AdaptWithStrategyAndDefaultSmoothing (const Estimators &estimators, const DiscreteFunction< DIM, double, N, N > &func, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified function defined on the space, and with default mesh smoothing options (default constructed MeshSmoother). More...
FEMesh< DIM >::Modifications	AdaptWithStrategyAndDefaultSmoothing (const Estimators &estimators, const DiscreteFuncs &funcs, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified functions defined on the space, and with default mesh smoothing options (default constructed MeshSmoother). More...
FEMesh< DIM >::Modifications	AdaptConformingWithStrategy (const Estimators &estimators, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor, with mesh smoothing options for conforming meshes (i.e., MeshSmoother::Conforming()). More...
FEMesh< DIM >::Modifications	AdaptConformingWithStrategy (const Estimators &estimators, const DiscreteFunction< DIM, double, N, N > &func, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified function defined on the space with mesh smoothing options for conforming meshes (i.e., MeshSmoother::Conforming()). More...
FEMesh< DIM >::Modifications	AdaptConformingWithStrategy (const Estimators &estimators, const DiscreteFuncs &funcs, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified functions defined on the space with mesh smoothing options for conforming meshes (i.e., MeshSmoother::Conforming()). More...
FEMesh< DIM >::Modifications	AdaptWithStrategy (const Estimators &estimators, MeshSmoother smoother, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor and with the specified mesh smoothing options. More...
FEMesh< DIM >::Modifications	AdaptWithStrategy (const Estimators &estimators, const DiscreteFunction< DIM, double, N, N > &func, MeshSmoother smoother, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified function defined on the space and with the specified mesh smoothing options. More...
FEMesh< DIM >::Modifications	AdaptWithStrategy (const Estimators &estimators, const DiscreteFuncs &funcs, MeshSmoother smoother, Args... args)
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified functions defined on the space and with the specified mesh smoothing options. More...
FEMesh< DIM >::Modifications	Adapt (const Container &flags, const Estimators &estimators, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and using a container of flags indicating the refinement to perform. More...
FEMesh< DIM >::Modifications	Adapt (const Container &flags, const Estimators &estimators, const DiscreteFunction< DIM, double, N, N > &func, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and using a container of flags indicating the refinement to perform. More...
FEMesh< DIM >::Modifications	Adapt (const Container &flags, const Estimators &estimators, const DiscreteFuncs &funcs, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and using a container of flags indicating the refinement to perform. More...
FEMesh< DIM >::Modifications	Adapt (const Container &refine, const Container &coarsen, const Estimators &estimators, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a set of elements to refine and coarsen. More...
FEMesh< DIM >::Modifications	Adapt (const Container &refine, const Container &coarsen, const Estimators &estimators, const DiscreteFunction< DIM, double, N, N > &func, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a set of elements to refine and coarsen. More...
FEMesh< DIM >::Modifications	Adapt (const Container &refine, const Container &coarsen, const Estimators &estimators, const DiscreteFuncs &funcs, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a set of elements to refine and coarsen. More...
FEMesh< DIM >::Modifications	Adapt (Func flagFunction, const Estimators &estimators, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a function for deciding which elements to refine. More...
FEMesh< DIM >::Modifications	Adapt (Func flagFunction, const Estimators &estimators, const DiscreteFunction< DIM, double, N, N > &func, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a function for deciding which elements to refine. More...
FEMesh< DIM >::Modifications	Adapt (Func flagFunction, const Estimators &estimators, const DiscreteFuncs &funcs, MeshSmoother smoother=MeshSmoother{})
	Perform \(hp\)-adaptive refinement on the contained space and mesh using a function for deciding which elements to refine. More...

Protected Member Functions
virtual bool	ShouldPolydegAdapt (const HPRefinementData< DIM, X, N > &data, std::size_t element, bool refine) override
	Method called by the adaptation routines to decide if \(p\)-refinement should be performed for an element. More...
virtual void	PostProcessSpaceRefine (const HPRefinementData< DIM, X, N > &data, const std::vector< AdaptationType > &pRefinements) override
	Method called by the adaptation routines after \(p\)-refinement, but before \(h\)-refinement. More...
virtual void	PostProcessMeshRefine (const HPRefinementData< DIM, X, N > &data, const typename FEMesh< DIM >::Modifications &changes, const std::vector< AdaptationType > &pRefinements) override
	Method called by the adaptation routines after both \(h\)-refinement and \(p\)-refinement. More...
virtual bool	ShouldPolydegAdapt (const HPRefinementData< DIM, double, N > &data, std::size_t element, bool refine)=0
	Method called by the adaptation routines to decide if \(p\)-refinement should be performed for an element. More...
virtual void	PostProcessSpaceRefine ([[maybe_unused]] const HPRefinementData< DIM, double, N > &data,[[maybe_unused]] const std::vector< AdaptationType > &pRefinements)
	Method called by the adaptation routines after \(p\)-refinement, but before \(h\)-refinement. More...
virtual void	PostProcessMeshRefine ([[maybe_unused]] const HPRefinementData< DIM, double, N > &data,[[maybe_unused]] const typename FEMesh< DIM >::Modifications &changes,[[maybe_unused]] const std::vector< AdaptationType > &pRefinements)
	Method called by the adaptation routines after both \(h\)-refinement and \(p\)-refinement. More...

Detailed Description

template<std::size_t DIM, typename X = double, std::size_t N = 1>
class ptems::HPPredictedErrorStrategy< DIM, X, N >

Class for performing \(hp\)-adaptive refinement, where the selection on whether to perform \(h\)- or \(p\)-refinement is based on the predicted convergence rate of the error estimate for a smooth or non-smooth function; cf.

[5].

For each element \(K\in\mathcal{T}_h\) marked for refinement the algorithm performs \(p\)-refinement if \(\eta_{K} < \eta_{K}^{\rm pred}\), where \(\eta_{K}\) is the error indicator for the element and \(\eta_{K}^{\rm pred}\) is the predicted error based on the estimated rate of convergence for a smooth function. The calculation of \(\eta_{K}^{\rm pred}\) depends on the refinement from the previous step:

• \(h\)-refinement into \(N\) children \(K_s\), \(s=1,...,N\):

  \[ (\eta_{K_s}^{\rm pred})^2 = \frac{1}{S}\gamma_h \frac1{2^{2p_K}} \eta_{K}^2 \]

  where \(p_K\) is the polynomial degree on element $K$, and \(\gamma_h\) is a steering parameter.
• \(p\)-refinement:

  \[ (\eta_{K}^{\rm pred})^2 = \gamma_p \eta_{K}^2 \]

  where \(\gamma_p\) is a steering parameter.
• No refinement:

  \[ (\eta_{K}^{\rm pred})^2 = \gamma_n (\eta_{K}^{\rm pred})^2 \]

  where \(\gamma_n\) is a steering parameter.

\(\eta_{K}^{\rm pred}\) is initialised to either 0 or \(\infty\) to perform \(h\)- or \(p\)-refinement, respectively, at the first iteration.

Usage: An instance of the HPPredictedErrorStrategy should be constructed when the initial mesh and space are constructed, and then the various Adapt* functions should be called to perform adaptation on BOTH the mesh and space:

std::size_t polydeg = 2;
auto mesh = ptems::CreateUniformMesh(comm, ptems::DomainDefinition2D::Square(), 4);
auto Vh = ptems::MakeDGSpace(mesh, polydeg);
auto hpRefinement = ptems::CreateHPPredictedErrorStrategy(Vh, 4, 0.4, 1, polydeg);
for(std::size_t i = 0; i != 20; ++i)
{
    // ... Perform solve
 
    // ... Compute error indicators:
    std::vector<double> indicators(mesh->ElementCount());
 
    // Refine using a marking strategy functor:
    hpRefinement->AdaptWithStrategy<ptems::FixedFractionMarking>(indicators, 0.25);
 
    // Refine using custom functor (or similar for container of flags)
    hpRefinement->Adapt([](std::size_t element)
        {
            // return value from AdaptationType enum
        }, indicators);
}

Note

It is simpler to call CreateHPPredictedErrorStrategy as this automatically deduces template parameters.

Template Parameters

DIM	The dimension of the mesh and spaces to refine
X	The type of the result of the functions (double, std::complex, etc) for each space
N	The size of the resulting vector space (N=1 for scalars) for each space

Constructor & Destructor Documentation

HPPredictedErrorStrategy() [1/2]

template<std::size_t DIM, typename X = double, std::size_t N = 1>

ptems::HPPredictedErrorStrategy< DIM, X, N >::HPPredictedErrorStrategy ( const PDiscreteFunctionSpace< DIM, X, N > &  space, double  gammaH, double  gammaP, double  gammaN = 1, std::size_t  minP = 1, bool  preferP = false  )

inline

Creates an object for performing \(hp\)-adaptive refinement based on the predicted convergence rate of the error estimate.

Parameters

space	The function space to refine (containing the mesh to refine)
gammaH	Steering parameter \(\gamma_h\) specifying the rate of reduction in the error estimator when \(h\)-refinement is performed.
gammaP	Steering parameter \(\gamma_p\) specifying the rate of reduction in the error estimator when \(p\)-refinement is performed.
gammaN	Steering parameter \(\gamma_n\) specifying the rate of reduction in the error estimator when no refinement is performed (default = 1)
minP	Minimum polynomial degree. Coarsen will not occur if the polynomial degree of ANY component will fall below this minimum (default = 1)
preferP	true if the first mesh refinement should be \(p\)-refinement, false if the first mesh refinement should be \(h\)-refinement (default = false)

HPPredictedErrorStrategy() [2/2]

template<std::size_t DIM, typename X = double, std::size_t N = 1>

ptems::HPPredictedErrorStrategy< DIM, X, N >::HPPredictedErrorStrategy ( const PDiscreteFunctionSpace< DIM, X, N > &  space, double  gammaH, double  gammaP, bool  preferP  )

inline

Creates an object for performing \(hp\)-adaptive refinement based on the predicted convergence rate of the error estimate.

Parameters

space	The function space to refine (containing the mesh to refine)
gammaH	Steering parameter \(\gamma_h\) specifying the rate of reduction in the error estimator when \(h\)-refinement is performed.
gammaP	Steering parameter \(\gamma_p\) specifying the rate of reduction in the error estimator when \(p\)-refinement is performed.
preferP	true if the first mesh refinement should be \(p\)-refinement, false if the first mesh refinement should be \(h\)-refinement

Member Function Documentation

Adapt() [1/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( const Container &  flags, const Estimators &  estimators, const DiscreteFuncs &  funcs, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and using a container of flags indicating the refinement to perform.

A container of flags can be one of the following:

• A random access container of AdaptationType (i.e., supports operator[] and size()) containing an AdaptationType for each element
• An associative container (map/unordered_map etc) of element number (std::size_t) to AdaptationType containing an AdaptationType for SOME elements, all other elements are left unrefined
• A container of element numbers to perform refinement on, all other elements are left unrefined

Template Parameters

Container	Container type containing AdaptationType or std::size_t, or map from std::size_t to AdaptationType
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
DiscreteFuncs	Type of the list of functions, must be random access container.

Parameters

flags	Container of AdaptationType or std::size_t, or map from std::size_t to AdaptationType
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
funcs	List of functions defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [2/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( const Container &  flags, const Estimators &  estimators, const DiscreteFunction< DIM, double , N, N > &  func, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and using a container of flags indicating the refinement to perform.

A container of flags can be one of the following:

• A random access container of AdaptationType (i.e., supports operator[] and size()) containing an AdaptationType for each element
• An associative container (map/unordered_map etc) of element number (std::size_t) to AdaptationType containing an AdaptationType for SOME elements, all other elements are left unrefined
• A container of element numbers to perform refinement on, all other elements are left unrefined

Template Parameters

Container	Container type containing AdaptationType or std::size_t, or map from std::size_t to AdaptationType
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh

Parameters

flags	Container of AdaptationType or std::size_t, or map from std::size_t to AdaptationType
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
func	Function defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [3/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( const Container &  flags, const Estimators &  estimators, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and using a container of flags indicating the refinement to perform.

A container of flags can be one of the following:

• A random access container of AdaptationType (i.e., supports operator[] and size()) containing an AdaptationType for each element
• An associative container (map/unordered_map etc) of element number (std::size_t) to AdaptationType containing an AdaptationType for SOME elements, all other elements are left unrefined
• A container of element numbers to perform refinement on, all other elements are left unrefined

Template Parameters

Container	Container type containing AdaptationType or std::size_t, or map from std::size_t to AdaptationType
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh

Parameters

flags	Container of AdaptationType or std::size_t, or map from std::size_t to AdaptationType
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [4/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( const Container &  refine, const Container &  coarsen, const Estimators &  estimators, const DiscreteFuncs &  funcs, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a set of elements to refine and coarsen.

Attention

While the container of element numbers to refine/coarsen can be ANY container time, it is strongly recommended to use a set-like container which can perform fast searching (e.g. std::set or std::unordered_set)

Template Parameters

Container	Container type for refinement and coarsen flags
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
DiscreteFuncs	Type of the list of functions, must be random access container.

Parameters

refine	Container of indices of elements to refine
coarsen	Container of indices of elements to coarsen
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
funcs	List of functions defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [5/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( const Container &  refine, const Container &  coarsen, const Estimators &  estimators, const DiscreteFunction< DIM, double , N, N > &  func, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a set of elements to refine and coarsen.

Attention

While the container of element numbers to refine/coarsen can be ANY container time, it is strongly recommended to use a set-like container which can perform fast searching (e.g. std::set or std::unordered_set)

Template Parameters

Container	Container type for refinement and coarsen flags
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh

Parameters

refine	Container of indices of elements to refine
coarsen	Container of indices of elements to coarsen
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
func	Function defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [6/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( const Container &  refine, const Container &  coarsen, const Estimators &  estimators, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a set of elements to refine and coarsen.

Attention

While the container of element numbers to refine/coarsen can be ANY container time, it is strongly recommended to use a set-like container which can perform fast searching (e.g. std::set or std::unordered_set)

Template Parameters

Container	Container type for refinement and coarsen flags
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh

Parameters

refine	Container of indices of elements to refine
coarsen	Container of indices of elements to coarsen
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [7/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( Func  flagFunction, const Estimators &  estimators, const DiscreteFuncs &  funcs, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a function for deciding which elements to refine.

Template Parameters

Func	A function type which takes a std::size_t, and returns an AdaptionType; e.g., of form AdaptionType operator()(std::size_t idx).
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
DiscreteFuncs	Type of the list of functions, must be random access container.

Parameters

flagFunction	Function which takes an element index in range [0, Mesh()->ElementCount()), and returns an AdaptionType flag value indicating if the element should be refined, coarsened, or left 'as-is'
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
funcs	List of functions defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [8/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( Func  flagFunction, const Estimators &  estimators, const DiscreteFunction< DIM, double , N, N > &  func, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a function for deciding which elements to refine.

Template Parameters

Func	A function type which takes a std::size_t, and returns an AdaptionType; e.g., of form AdaptionType operator()(std::size_t idx).
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh

Parameters

flagFunction	Function which takes an element index in range [0, Mesh()->ElementCount()), and returns an AdaptionType flag value indicating if the element should be refined, coarsened, or left 'as-is'
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
func	Function defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

Adapt() [9/9]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::Adapt ( Func  flagFunction, const Estimators &  estimators, MeshSmoother  smoother = MeshSmoother{}  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a function for deciding which elements to refine.

Template Parameters

Func	A function type which takes a std::size_t, and returns an AdaptionType; e.g., of form AdaptionType operator()(std::size_t idx).
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh

Parameters

flagFunction	Function which takes an element index in range [0, Mesh()->ElementCount()), and returns an AdaptionType flag value indicating if the element should be refined, coarsened, or left 'as-is'
estimators	Error indicators for each element in mesh, necessary for checking convergence against expected
smoother	Specifies options for smoothing the mesh during refinemnt. Default options are as for a default constructed MeshSmoother object

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

AdaptConformingWithStrategy() [1/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptConformingWithStrategy ( const Estimators &  estimators, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor, with mesh smoothing options for conforming meshes (i.e., MeshSmoother::Conforming()).

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, MeshSmoother::Conforming())

Exceptions

std::out_of_range

May be thrown if length of the estimators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::Conforming

AdaptConformingWithStrategy() [2/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptConformingWithStrategy ( const Estimators &  estimators, const DiscreteFuncs &  funcs, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified functions defined on the space with mesh smoothing options for conforming meshes (i.e., MeshSmoother::Conforming()).

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, funcs, MeshSmoother::Conforming())

Exceptions

std::out_of_range

May be thrown if length of the estimators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
DiscreteFuncs	Type of the list of functions, must be random access container.
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
funcs	List of functions defined on the space to use for the refinement strategy
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::Conforming

AdaptConformingWithStrategy() [3/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptConformingWithStrategy ( const Estimators &  estimators, const DiscreteFunction< DIM, double , N, N > &  func, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified function defined on the space with mesh smoothing options for conforming meshes (i.e., MeshSmoother::Conforming()).

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, func, MeshSmoother::Conforming())

Exceptions

std::out_of_range

May be thrown if length of the estimators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
func	Function defined on the space to use for the refinement strategy
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::Conforming

AdaptWithStrategy() [1/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptWithStrategy ( const Estimators &  estimators, const DiscreteFuncs &  funcs, MeshSmoother  smoother, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified functions defined on the space and with the specified mesh smoothing options.

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, funcs, estimators, smoother)

Exceptions

std::out_of_range

May be thrown if length of the esitmators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
DiscreteFuncs	Type of the list of functions, must be random access container.
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
funcs	List of functions defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt.
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

AdaptWithStrategy() [2/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptWithStrategy ( const Estimators &  estimators, const DiscreteFunction< DIM, double , N, N > &  func, MeshSmoother  smoother, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified function defined on the space and with the specified mesh smoothing options.

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, func, estimators, smoother)

Exceptions

std::out_of_range

May be thrown if length of the esitmators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
func	Function defined on the space to use for the refinement strategy
smoother	Specifies options for smoothing the mesh during refinemnt.
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

AdaptWithStrategy() [3/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptWithStrategy ( const Estimators &  estimators, MeshSmoother  smoother, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor and with the specified mesh smoothing options.

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, smoother)

Exceptions

std::out_of_range

May be thrown if length of the esitmators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
smoother	Specifies options for smoothing the mesh during refinemnt.
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

AdaptWithStrategyAndDefaultSmoothing() [1/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptWithStrategyAndDefaultSmoothing ( const Estimators &  estimators, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor, and with default mesh smoothing options (default constructed MeshSmoother).

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, MeshSmoother{})

Exceptions

std::out_of_range

May be thrown if length of the estimators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

AdaptWithStrategyAndDefaultSmoothing() [2/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptWithStrategyAndDefaultSmoothing ( const Estimators &  estimators, const DiscreteFuncs &  funcs, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified functions defined on the space, and with default mesh smoothing options (default constructed MeshSmoother).

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, funcs, MeshSmoother{})

Exceptions

std::out_of_range

May be thrown if length of the estimators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
DiscreteFuncs	Type of the list of functions, must be random access container.
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
funcs	List of functions defined on the space to use for the refinement strategy
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

AdaptWithStrategyAndDefaultSmoothing() [3/3]

FEMesh<DIM>::Modifications ptems::HPRefinementStrategy< DIM, double , N >::AdaptWithStrategyAndDefaultSmoothing ( const Estimators &  estimators, const DiscreteFunction< DIM, double , N, N > &  func, Args...  args  )

inlineinherited

Perform \(hp\)-adaptive refinement on the contained space and mesh using a marking strategy functor object which takes error indicators as the first argument to the constructor with the specified function defined on the space, and with default mesh smoothing options (default constructed MeshSmoother).

Convenience method for call to

Adapt(MarkingStrategy{estimators, args...}, estimators, func, MeshSmoother{})

Exceptions

std::out_of_range

May be thrown if length of the estimators is not number of elements in mesh

Template Parameters

MarkingStrategy	The type of the marking strategy to use. The constructor of this type must take the error indicators as the first argument Must be explicitly specified
Estimators	Type of the list of error indicators, must be random access container of the same length as the number of elements on the mesh
Args	Type of extra arguments to pass to the MarkingStrategy constructor

Parameters

estimators	Error indicators for each element in mesh, passed to first argument of MarkingStrategy constructor.
func	Function defined on the space to use for the refinement strategy
args	Extra arguments to pass to the MarkingStrategy constructor

Returns

Structure denoting changes that occurred to the mesh (but NOT the space polynomial degrees)

See also

MeshSmoother::MeshSmoother

PostProcessMeshRefine() [1/2]

virtual void ptems::HPRefinementStrategy< DIM, double , N >::PostProcessMeshRefine ( [[maybe_unused] ] const HPRefinementData< DIM, double , N > &  data, [[maybe_unused] ] const typename FEMesh< DIM >::Modifications &  changes, [[maybe_unused] ] const std::vector< AdaptationType > &  pRefinements  )

inlineprotectedvirtualinherited

Method called by the adaptation routines after both \(h\)-refinement and \(p\)-refinement.

Can be used to for any post-processing.

Parameters

data	Error indicators and functions defined on the mesh
changes	Modifications performed to the mesh ( \(h\)-refinements)
pRefinements	Vector, with one entry per element, denoting the type of \(p\)-adaptation performed (refinement, coarsening, or none)

PostProcessMeshRefine() [2/2]

template<std::size_t DIM, typename X = double, std::size_t N = 1>

virtual void ptems::HPPredictedErrorStrategy< DIM, X, N >::PostProcessMeshRefine ( const HPRefinementData< DIM, X, N > &  data, const typename FEMesh< DIM >::Modifications &  changes, const std::vector< AdaptationType > &  pRefinements  )

inlineoverrideprotectedvirtual

Method called by the adaptation routines after both \(h\)-refinement and \(p\)-refinement.

Can be used to for any post-processing.

Parameters

data	Error indicators and functions defined on the mesh
changes	Modifications performed to the mesh ( \(h\)-refinements)
pRefinements	Vector, with one entry per element, denoting the type of \(p\)-adaptation performed (refinement, coarsening, or none)

PostProcessSpaceRefine() [1/2]

virtual void ptems::HPRefinementStrategy< DIM, double , N >::PostProcessSpaceRefine ( [[maybe_unused] ] const HPRefinementData< DIM, double , N > &  data, [[maybe_unused] ] const std::vector< AdaptationType > &  pRefinements  )

inlineprotectedvirtualinherited

Method called by the adaptation routines after \(p\)-refinement, but before \(h\)-refinement.

Can be used to for any post-processing.

Parameters

data	Error indicators and functions defined on the mesh
pRefinements	Vector, with one entry per element, denoting the type of \(p\)-adaptation performed (refinement, coarsening, or none)

PostProcessSpaceRefine() [2/2]

template<std::size_t DIM, typename X = double, std::size_t N = 1>

virtual void ptems::HPPredictedErrorStrategy< DIM, X, N >::PostProcessSpaceRefine ( const HPRefinementData< DIM, X, N > &  data, const std::vector< AdaptationType > &  pRefinements  )

inlineoverrideprotectedvirtual

Method called by the adaptation routines after \(p\)-refinement, but before \(h\)-refinement.

Can be used to for any post-processing.

Parameters

data	Error indicators and functions defined on the mesh
pRefinements	Vector, with one entry per element, denoting the type of \(p\)-adaptation performed (refinement, coarsening, or none)

ShouldPolydegAdapt() [1/2]

virtual bool ptems::HPRefinementStrategy< DIM, double , N >::ShouldPolydegAdapt ( const HPRefinementData< DIM, double , N > &  data, std::size_t  element, bool  refine  )

protectedpure virtualinherited

Method called by the adaptation routines to decide if \(p\)-refinement should be performed for an element.

Parameters

data	Error indicators and functions defiend on the mesh
element	Index of the element
refine	true if performing refinement of element, false if performing coarsening

Returns

true to perform \(p\)-refinement (or derefinement); false to perform \(h\)-refinement

ShouldPolydegAdapt() [2/2]

template<std::size_t DIM, typename X = double, std::size_t N = 1>

virtual bool ptems::HPPredictedErrorStrategy< DIM, X, N >::ShouldPolydegAdapt ( const HPRefinementData< DIM, X, N > &  data, std::size_t  element, bool  refine  )

inlineoverrideprotectedvirtual

Method called by the adaptation routines to decide if \(p\)-refinement should be performed for an element.

Parameters

data	Error indicators and functions defiend on the mesh
element	Index of the element
refine	true if performing refinement of element, false if performing coarsening

Returns

true to perform \(p\)-refinement (or derefinement); false to perform \(h\)-refinement

Space()

const PDiscreteFunctionSpace<DIM, double , N>& ptems::HPRefinementStrategy< DIM, double , N >::Space ( )

inlineinherited

Gets the finite element space the refinement strategy is on.

---

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

• ptems/hpstrategies.hpp