Geometry

struct CartesianProduct{D, T}

A type representing the cartesian product of D closed intervals in a space with element type T.

Fields

• box: a tuple of D pairs, where each pair represents the bounds (min, max) of an interval

• collapsed: a tuple of D boolean values indicating whether each dimension is collapsed (i.e., min = max)

(X::CartesianProduct)(i)

Returns the i-th interval (or point) in the CartesianProduct.

Example

julia> Y = cartesian_product(((0.0, 1.0), (4.0, 5.0)));
	   Y(2)
(4.0, 5.0)

eltype(X::CartesianProduct)

Returns the element type of a CartesianProduct. Can be applied directly to the type of the CartesianProduct.

Example

julia> X = cartesian_product(0, 1);
	   eltype(X)
Float64

first(X::CartesianProduct{1})
last(X::CartesianProduct{1})

Return the first and last elements of a one-dimensional CartesianProduct, respectively. These methods extend Base.first and Base.last for CartesianProduct{1}` types.

cartesian_product(x, y)
cartesian_product(box)

Returns a CartesianProduct.

• If D tuples are provided in box, it returns a D-dimensional CartesianProduct.
• If two values x and y are provided, it returns a 1-dimensional CartesianProduct to represent the interval [x,y].

is_collapsed(a::T, b::T)
is_collapsed(X::CartesianProduct{1})

Checks if a 1D CartesianProduct or two numbers are "collapsed" (i.e., degenerate).

• For two numbers a and b, it returns true if they are approximately equal using isapprox.
• For a 1-dimensional CartesianProduct, it returns the pre-computed collapse status stored in X.collapsed[1].

point(x)

Creates a collapsed 1D CartesianProduct representing the point $[x, x]$.

point_type(X::CartesianProduct)

Determines the type of a coordinate point within a CartesianProduct space. Returns T for 1D spaces and NTuple{D,T} for D-dimensional spaces.

projection(X::CartesianProduct, i)

Returns the i-th component interval of X` as a new 1D CartesianProduct.

set(X::CartesianProduct)

Returns the CartesianProduct itself. This can be useful for functions that expect a domain object and might receive either the object or a wrapper.

tails(X::CartesianProduct, i)

Returns the i-th component interval of the CartesianProduct X as a Tuple. This is an alias for X(i).

tails(X::CartesianProduct)

Returns the component sets of a CartesianProduct:

• for a one-dimensional CartesianProduct (D=1), returns the single component set.
• for a D-dimensional CartesianProduct, returns a tuple containing all component sets.

struct DomainMarkers{BFType}

A container that categorizes and stores all markers for a given domain.

See markers for construction and get_boundary_symbols for available predefined boundary symbols.

Fields

• symbols: markers identified by a single predefined Symbol (e.g., :left).

• tuples: markers identified by a collection of predefined Symbols (e.g., (:top, :right)).

• conditions: markers identified by a boolean function f(x) or f(x, t).

(dm::DomainMarkers)(t::Number)

Evaluates a time-dependent DomainMarkers object at a specific time t. This function returns a new, time-independent DomainMarkers object.

Example

julia> time_dep_markers = markers(space_domain, time_domain, :moving_front => (x, t) -> x[1] > t);
	   markers_at_0_5 = time_dep_markers(0.5)# Symbol and Tuple markers are time-agnostic, so they are preserved.

struct EvaluatedDomainMarkers{M<:Bramble.DomainMarkers, T<:Number}

A lazy, view-like wrapper that represents a DomainMarkers object evaluated at a specific time t.

This struct avoids allocating a new collection for time-evaluated functions. Instead, it generates the time-independent functions on-the-fly when the conditions are iterated over. It shares the symbols and tuples directly from the original object.

Fields

• original_markers

• evaluation_time

struct Marker{F}

Represents a labeled region or boundary of a domain.

Each Marker consists of a label (a Symbol) and an identifier. The identifier specifies how to locate the marked region. It can be:

• A Symbol for predefined boundaries (e.g., :left, :top).
• A Set{Symbol} for collections of predefined boundaries.
• A function (wrapped in a BrambleFunction) that acts as a level-set, returning true for points inside the marked region.

Fields

• label: A Symbol used to name the marked region (e.g., :inlet, :wall).

• identifier: The object that identifies the region (Symbol, Set{Symbol}, or BrambleFunction).

MarkerPair{F}

A type alias for Pair{Symbol, F}, representing a convenient way to define a marker. For example: :boundary => :left.

conditions(domain_markers::DomainMarkers)

Gets the set of function-based markers from a DomainMarkers object.

conditions(edm::EvaluatedDomainMarkers)

Returns a lazy generator that yields time-evaluated markers.

This is the core of the lazy evaluation. It iterates over the original conditions and yields new Marker objects with their functions evaluated at edm.evaluation_time, but only when requested.

identifier(m::Marker)
identifier(m::MarkerPair)

Returns the identifier (Symbol, Set, or function) of a Marker or MarkerPair.

label(m::Marker)
label(m::MarkerPair)

Returns the Symbol label of a Marker or MarkerPair.

label_conditions(domain_markers::DomainMarkers)

Returns a generator that yields the labels from the function-based markers.

label_identifiers(domain_markers::DomainMarkers)

Returns a generator that yields the label of every marker in the DomainMarkers collection.

label_symbols(domain_markers::DomainMarkers)

Returns a generator that yields the labels from the single-symbol markers.

label_tuples(domain_markers::DomainMarkers)

Returns a generator that yields the labels from the symbol-tuple markers.

symbols(domain_markers::DomainMarkers)

Gets the set of single-symbol markers from a DomainMarkers object.

tuples(domain_markers::DomainMarkers)

Gets the set of symbol-tuple markers from a DomainMarkers object.

struct Domain{SetType, MarkersType} <: Bramble.DomainBaseType

Represents a computational domain, which combines a geometric set with a collection of labeled markers.

This struct is a fundamental building block, bundling a geometric entity (a CartesianProduct) with a DomainMarkers object that defines named regions (like boundaries or subdomains).

Fields

• set: the geometric set defining the domain's extent (e.g., a CartesianProduct).

• markers: a DomainMarkers object containing all labeled regions for this domain.

eltype(Ω::Domain)

Returns the type of the bounds defining Domain Ω. It can also be applied to the type of the domain. It can be applied also to the type of the domain.

Example

julia> I = interval(0.0, 1.0);
	   eltype(domain(I × I))
Float64

get_boundary_symbols(X::CartesianProduct)

Returns a tuple of default boundary symbols for a CartesianProduct.

• in 1D [x₁,x₂], :left (x=x₁), :right (x=x₂)
• in 2D [x₁,x₂] × [y₁,y₂], :left (x=x₁), :right (x=x₂), :top (y=y₂), :bottom (y=y₁)
• in 3D [x₁,x₂] × [y₁,y₂] × [z₁,z₂], :front (x=x₂), :back (x=x₁), :left (y=y₁), :right (y=y₂), :top (z=z₃), :bottom (z=z₁)

label_conditions(Ω::Domain)

Returns a generator with the labels of the conditions on DomainMarkers.

label_identifiers(Ω::Domain)

Returns a generator with all labels on DomainMarkers.

label_symbols(Ω::Domain)

Returns a generator with the labels of the symbols on DomainMarkers.

label_tuples(Ω::Domain)

Returns a generator with the labels of the tuples on DomainMarkers.

marker_conditions(Ω::Domain)

Returns a generator yielding the identifiers (functions) of condition-based markers.

marker_identifiers(Ω::Domain)

Returns a generator that yields the identifiers (Symbol, Set{Symbol}, or BrambleFunction) of all markers associated with the Domain Ω.

marker_symbols(Ω::Domain)

Returns a generator yielding the identifiers of single-symbol markers.

marker_tuples(Ω::Domain)

Returns a generator yielding the identifiers of symbol-tuple markers.

projection(Ω::Domain, i)

Returns the i-th CartesianProduct of the set associated with Domain Ω.

For example, projection(domain(I × I), 1) will return I.

set(Ω::Domain)

Returns the CartesianProduct associated with the Domain Ω.