Gridap.Helpers

This module provides a set of helper macros and helper functions

The exported macros are:

• GridapType
• @abstractmethod
• @check
• first_and_tail
• get_val_parameter
• @notimplemented
• @notimplementedif
• set_debug_mode
• set_performance_mode
• tfill
• @unreachable

abstract type GridapType end

first_and_tail(a::Tuple)

Equivalent to (first(a), Base.tail(a)).

get_val_parameter(::Val{T}) where T
get_val_parameter(::Type{Val{T}}) where T

Returns T.

set_debug_mode()

Equivalent to set_execution_mode("debug").

set_execution_mode(new_mode::String)

Sets the execution mode to either "debug" or "performance", which controls the behavior of the @check macro within the Gridap package.

• Debug mode (default): The @check macro will be active, which activates consistency checks within the library. This mode is recommended for development and debugging purposes.

• Performance mode: The @check macro will be deactivated. This mode is recommended for production runs, where no errors are expected.

Pre-defined functions set_debug_mode and set_performance_mode are also available. Feature only available in Julia 1.6 and later due to restrictions from Preferences.jl.

set_performance_mode()

Equivalent to set_execution_mode("performance").

tfill(v, ::Val{D}) where D

Returns a tuple of length D that contains D times the object v. In contrast to tuple(fill(v,D)...) which returns the same result, this function is type-stable.

@abstractmethod

Macro used in generic functions that must be overloaded by derived types.

@check condition @check condition "Error message"

Macro used to make sure that condition is fulfilled, like @assert but the check gets deactivated when running Gridap in performance mode.

@notimplemented
@notimplemented "Error message"

Macro used to raise an error, when something is not implemented.

@notimplementedif condition
@notimplementedif condition "Error message"

Macro used to raise an error if the condition is true

@unreachable
@unreachable "Error message"

Macro used to make sure that a line of code is never reached.