Bring module prose in line with flat `dof_indices`, `@DOFSet`, and DOFHandler-era
helpers while tightening compile-time DOF arithmetic.
- Refresh docstrings: drop markdown bold noise; document `element_dofs` /
`field_dof_range` instead of NamedTuple-shaped `dof_indices` accessors.
- Rewrite examples to prefer `@DOFSet`; spell out NamedTuple equivalence and drop
Tuple-based migration snippets incompatible with DOFHandler.
- Implement `field_ndofs(::Type{<:DOF}, Topo)` / `ndofs(::DOFSet, Topo)` using
`quantity_type` / `entity_type` and generator-style sums over `fieldtypes(S)`.
- Extend `quantity_type(::Type{<:DOF})` for raw `Float64`, `Vec`, `Tensor`, and
`SymmetricTensor` fields alongside `AbstractField` wrappers.
- Allow `field_ndofs` on raw-quantity DOFs by sizing `T` directly (pressure on
cells/faces, etc.).
- Remove `single_field` compatibility helper and duplicate element accessors now
canonical in `src/elements/elements.jl`.
- Point LICENSE header at LICENSE.md.
Drop ScalarDOF/VectorDOF/TensorDOF aliases and canned Lagrange-* constants that
duplicated patterns now expressed via `DOF{Q,E}` and `@DOFSet`.
- Eliminates Vec{1}-based scalar alias layering in favor of explicit quantities.
- Removes unused LagrangeHeat/LagrangeElasticity shorthand blocks tied to old tutorials.
Delete the legacy global numbering implementation that stored DOFs in Dicts and
registered Tuple-shaped field specs at runtime.
- Remove `mutable struct DOFManager` with `node_to_dofs`, `field_specs`, mesh
reference, and incremental `next_dof` counters at odds with type-stable layouts.
- Drop `register_fields!`, `allocate_dofs!`, `count_field_dofs`, mesh-local
entity counters, and `_assign_element_dofs!` variants tied to that storage.
- Remove `create_elements!` / `_build_dof_connectivity` definitions superseded by
`dof_handler.jl` (`DOFHandler`, `_make_element_dofs`, `build_dof_connectivity`).
- Element-set helpers and BC-oriented accessors live on `DOFHandler` now; the
`DOFManager` identifier remains only as the backward-compatible alias.
Introduce `DOFHandler{M,S,NF}` with flat `field_starts::NTuple{NF,Vector{Int}}`
per field and entity id, optional `facet_maps` for Edge/Face unknowns, running
`total_dofs`, and a `dof_connectivity` slot populated after element creation.
Reserve `DOFManager` as a backward-compatible alias.
Construction and layout:
- Number DOFs in field-declaration order; within each field walk entities in id
order (nodes, cells, or facet ids) using compile-time `dof_size` widths.
- Auto-build `AbstractFacetConnectivityMaps` for Hex8/Hex20/Tet4/Tet10/Wedge6/Pyr5
when the DOFSet references Edge or Face; error on unsupported mesh/topology pairs.
Mixed-field helpers:
- `global_field_ranges` — contiguous global index ranges per declared field,
checked against `handler.total_dofs`.
- `global_facet_dof` — first global DOF for a Face-owned field given facet gid.
- `saddle_point_blocks` / `saddle_point_matrix_blocks` — named views or CSC
subblocks for two-field `u`/`p`-style matrices using those ranges.
Hot path:
- `@generated _make_element_dofs` emits an `NTuple{N,UInt64}` from handler tables:
Vertex via element connectivity, Cell via element id, Edge/Face via
`elem_edge_gid` / `elem_face_gid`; assert emitted length matches `N`.
- `create_elements!` builds the handler, fills `Vector{Element{K,P,S,N}}`, assigns
DOFs with `_make_element_dofs`, then replaces `handler.dof_connectivity` via
`build_dof_connectivity`. Support `Element{K,P,S}` with inferred `N`, and wrap a
bare single `DOF{Q,E}` into a one-field DOFSet.
Legacy-oriented utilities:
- `get_node_dofs` collects Vertex-field DOFs for one node (allocating helper).
- `get_element_ids` resolves ids from `mesh.element_sets` by name or symbol.
New test file for DOF extraction functionality:
- Tests extract_element_dofs() function
- Tests extract_element_dofs_structured() function
- Single-field and multi-field test cases
- Type stability verification
Provides test coverage for DOF extraction from global solution vectors.
New comparison example demonstrating:
- Generated DOF extraction vs manual implementation
- Performance comparison
- Code generation benefits
- Type stability advantages
Provides comparison example for DOF system code generation.
New example file demonstrating basic DOF system usage:
- Simple single-field and multi-field element creation
- DOFManager usage
- Element creation workflow
- Basic DOF extraction examples
Provides simple usage examples for the DOF system.
New 205-line DOF system documentation:
- Philosophy: multi-field is fundamental, single-field is special case
- Core concept: DOF{T,E} abstract type for type-level specifications
- Field specifications with @DOFSet macro
- Usage examples for single-field and multi-field elements
- DOFManager and element creation workflow
- DOF connectivity for inverse mapping
- Performance notes and design rationale
Provides complete documentation for the unified DOF system architecture.
New 495-line DOF management system:
- DOFManager: manages global DOF numbering across mesh entities
- register_fields!(): register fields from DOFSet specifications
- allocate_dofs!(): allocate DOFs for entities (supports multi-field)
- get_node_dofs(): retrieve DOF indices for nodes
- count_field_dofs(): count total DOFs for specific field
- count_entities(): count mesh entities by type (Vertex, Edge, Face, Cell)
- create_elements!(): create elements with DOF assignment
- Supports heterogeneous multi-field specifications
- Builds DOF connectivity during element creation
- Already integrated in JuliaFEM.jl (line 577)
Provides global DOF numbering and element creation infrastructure.
New 95-line file for mixed/coupled DOF systems:
- MixedDOF{DOFs}: composition of multiple entity-based DOF types
- Helper functions: is_mixed(), get_dof_types(), num_fields(), get_field_dof_type()
- Support for Stokes (velocity+pressure), 3-field formulations, Taylor-Hood
- DOF ordering: concatenated in field order
- Display formatting for mixed DOF types
Enables mixed interpolation methods with different DOF types per field.
New 169-line file with convenience types and helpers:
- ScalarDOF{E}: type alias for scalar DOFs at entities
- VectorDOF{D,E}: type alias for D-dimensional vector DOFs
- TensorDOF{D,E}: type alias for tensor DOFs
- Convenience constructors for common DOF patterns
- Helper functions for entity-based DOF operations
Provides convenient type aliases for common DOF patterns using entity-based system.
New 396-line field specification system:
- @DOFSet macro for clean multi-field syntax
- ndofs(): compute total DOFs for field specifications
- field_ndofs(): count DOFs per field
- field_names(), field_count(), is_single_field(): field queries
- quantity_type(), entity_type(): extract field components
- single_field(): convert single-field DOFSet to DOF type
- Support for single-field and multi-field specifications
- Comprehensive documentation with examples
Implements unified multi-field architecture where single-field is special case.
New 230-line API file defining DOF system foundation:
- AbstractDOF: base type for all field specifications
- DOF{T,E}: abstract type for type-level field specs (never instantiated)
- DOFSet: type alias for multi-field specifications (currently NamedTuple)
- dof_size(): utility for counting DOF components (Float64, Vec, Tensor, etc.)
- @DOFSet macro support for clean multi-field syntax
- Comprehensive documentation with examples
- Type-level, compile-time resolved (no runtime overhead)
Provides foundation for unified multi-field DOF system.
New 40-line main entry point for DOF system:
- Includes api.jl (DOF{T,E} abstract type)
- Includes fields.jl (field specification system)
- Documents multi-field philosophy (single-field is special case)
- Defines module structure and dependencies
- Already integrated in JuliaFEM.jl (line 313)
Provides unified type-level field specification system for finite elements.
Jukka Aho