TopOptProblems

abstract type StiffnessTopOptProblem{dim, T} <: AbstractTopOptProblem end

An abstract stiffness topology optimization problem. All subtypes must have the following fields:

• ch: a Ferrite.ConstraintHandler struct
• metadata: Metadata having various cell-node-dof relationships

///**********************************
///*                                *
///*                                * |
///*                                * |
///********************************** v


struct PointLoadCantilever{dim, T, N, M} <: StiffnessTopOptProblem{dim, T}
    rect_grid::RectilinearGrid{dim, T, N, M}
    E::T
    ν::T
    ch::ConstraintHandler{<:DofHandler, T}
    force::T
    force_dof::Integer
    metadata::Metadata
end

• dim: dimension of the problem
• T: number type for computations and coordinates
• N: number of nodes in a cell of the grid
• M: number of faces in a cell of the grid
• rect_grid: a RectilinearGrid struct
• E: Young's modulus
• ν: Poisson's ration
• force: force at the center right of the cantilever beam (positive is downward)
• force_dof: dof number at which the force is applied
• ch: a Ferrite.ConstraintHandler struct
• metadata: Metadata having various cell-node-dof relationships

 |
 |
 v
O*********************************
O*                               *
O*                               *
O*                               *
O*********************************
                                 O


struct HalfMBB{dim, T, N, M} <: StiffnessTopOptProblem{dim, T}
    rect_grid::RectilinearGrid{dim, T, N, M}
    E::T
    ν::T
    ch::ConstraintHandler{<:DofHandler, T}
    force::T
    force_dof::Integer
    metadata::Metadata
end

• dim: dimension of the problem
• T: number type for computations and coordinates
• N: number of nodes in a cell of the grid
• M: number of faces in a cell of the grid
• rect_grid: a RectilinearGrid struct
• E: Young's modulus
• ν: Poisson's ration
• force: force at the top left of half the MBB (positive is downward)
• force_dof: dof number at which the force is applied
• ch: a Ferrite.ConstraintHandler struct
• metadata: Metadata having various cell-node-dof relationships

////////////
............
.          .
.          .
.          . 
.          .                    
.          ......................
.                               .
.                               . 
.                               . |
................................. v
                                force

struct LBeam{T, N, M} <: StiffnessTopOptProblem{2, T}
    E::T
    ν::T
    ch::ConstraintHandler{<:DofHandler, T}
    force::T
    force_dof::Integer
    metadata::Metadata
end

• T: number type for computations and coordinates
• N: number of nodes in a cell of the grid
• M: number of faces in a cell of the grid
• E: Young's modulus
• ν: Poisson's ration
• force: force at the center right of the cantilever beam (positive is downward)
• force_dof: dof number at which the force is applied
• ch: a Ferrite.ConstraintHandler struct
• metadata: Metadata having various cell-node-dof relationships

                                                               1
                                                               
                                                              OOO
                                                              ...
                                                              . .
                                                           4  . . 
                                30                            . .   
/ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . <-
/ .                                                                 . <- 2 f 
/ .    3                                                            . <- 
/ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . <-
                                                              ^^^
                                                              |||
                                                              1 f

struct TieBeam{T, N, M} <: StiffnessTopOptProblem{2, T}
    E::T
    ν::T
    force::T
    ch::ConstraintHandler{<:DofHandler, T}
    metadata::Metadata
end

• T: number type for computations and coordinates
• N: number of nodes in a cell of the grid
• M: number of faces in a cell of the grid
• E: Young's modulus
• ν: Poisson's ration
• force: force at the center right of the cantilever beam (positive is downward)
• ch: a Ferrite.ConstraintHandler struct
• metadata: Metadata having various cell-node-dof relationships

struct InpStiffness{dim, N, TF, TI, Tch <: ConstraintHandler, GO, TInds <: AbstractVector{TI}, TMeta<:Metadata} <: StiffnessTopOptProblem{dim, TF}
    inp_content::InpContent{dim, TF, N, TI}
    geom_order::Type{Val{GO}}
    ch::Tch
    metadata::TMeta
end

• dim: dimension of the problem
• TF: number type for computations and coordinates
• N: number of nodes in a cell of the grid
• inp_content: an instance of Parser.InpContent which stores all the information from the `.inp file.
• geom_order: a field equal to Val{GO} where GO is an integer representing the order of the finite elements. Linear elements have a geom_order of Val{1} and quadratic elements have a geom_order of Val{2}.
• metadata: Metadata having various cell-node-dof relationships

abstract type HeatTransferTopOptProblem{dim, T} <: AbstractTopOptProblem end

An abstract heat transfer topology optimization problem for steady-state heat conduction.

Governing equation: -∇·(k(ρ)∇T) = q in Ω T = TD on ΓD (Dirichlet BC) k∇T·n = qN on ΓN (Neumann BC)

SIMP interpolation: k(ρ) = kmin + ρ^p (k0 - k_min) Heat source q is NOT penalized (external input, not a material property).

Mathematical note: For thermal compliance J = Q^T T, the gradient is: dJ/dxe = -Te^T Ke Te · dρe/dx_e This is the same form as structural compliance because Q doesn't depend on x.

See [1] §1.3 and §4.1 for thermal topology optimization, and [2] for SIMP-based heat conduction.

All subtypes must have:

• ch: ConstraintHandler with temperature DOFs (1 DOF per node)
• metadata: Metadata with cell-node-dof relationships
• k: thermal conductivity
• heatfluxdict: surface heat flux on boundaries (Dict{String,Float64})

struct HeatConductionProblem{dim, T, N, M} <: HeatTransferTopOptProblem{dim, T}

  T = T_left                         T = T_right  ┌────────────────────────────────────────┐  │                                        │  │                                        │  │          k(ρ)∇²T = 0                   │  │         (heat conduction)              │  │                                        │  │                                        │  └────────────────────────────────────────┘            ▲ q (heat flux on boundary)            │  ┌────────────────────────────────────────┐  │    ρ = design density (0 to 1)         │  │    k(ρ) = penalized conductivity       │  │    q = heat flux (NOT penalized)       │  └────────────────────────────────────────┘

A steady-state heat conduction problem with:

• Temperature BCs: T = T_left on left boundary, T = T_right on right boundary
• Heat flux BCs: q on specified boundaries (facesets)
• Objective: minimize thermal compliance J = ∫ q·T dΓ

Constructor arguments:

• nels: tuple of number of elements in each dimension
• sizes: tuple of element sizes
• k: thermal conductivity (W/m·K)
• Tleft: temperature on left boundary
• Tright: temperature on right boundary
• heatflux: Dict mapping faceset names to heat flux values (W/m²)
  • Positive values = heat entering the domain (heat source on boundary)
  • Negative values = heat leaving the domain (heat sink on boundary)
• cload: Dict mapping a node index to a concentrated heat source value (W). Positive values inject heat at that node; negative values remove heat. This is the point-source analogue of the distributed heatflux and is the setup that produces the classic branching "conductivity tree" topology.
• Tfix: Dict mapping a node index to a prescribed temperature (K), applied as a point Dirichlet BC. Use it to pin the temperature at individual nodes (e.g. a point cold sink) instead of along a whole boundary face.

Note: Heat flux q and concentrated heat sources are NOT penalized in the assembly. Only conductivity k(ρ) is penalized.

HeatTree(::Type{Val{CellType}}, nels, sizes, k=1.0; q=1.0)

Convenience constructor for the classic heat-conduction topology-optimization benchmark ([1] §1.3, Fig. 1.4): distributed heat flux q enters through the full top edge, the full bottom edge is held at T = 0 (cold sink), and the left/right sides are insulated (free). Minimizing thermal compliance with this setup produces the branching "conductivity tree" — a root structure at the cold bottom that branches and tapers toward the hot top.

Arguments:

• nels: tuple of number of elements per dimension
• sizes: tuple of element sizes
• k: thermal conductivity
• q: heat flux on the top boundary (W/m², positive = into the domain)

MultiLoad(problem, scenarios)

Multi-load-case wrapper that generates stochastic load scenarios for robust topology optimization. scenarios is the number of random load cases to draw. Use with MeanComplianceFun or BlockComplianceFun.

Usage example:

using Distributions, LinearAlgebra, TopOptf1 = RandomMagnitudeFun([0, -1], Uniform(0.5, 1.5))f2 = RandomMagnitudeFun(normalize([1, -1]), Uniform(0.5, 1.5))f3 = RandomMagnitudeFun(normalize([-1, -1]), Uniform(0.5, 1.5))base_problem = PointLoadCantilever(Val{:Linear}, (160, 40), (1.0, 1.0), 1.0, 0.3, 1.0)problem = MultiLoad(base_problem, [(160, 20) => f1, (80, 40) => f2, (120, 0) => f3], 10000)

RandomMagnitudeFun

Random load-magnitude sampler used inside MultiLoad.

struct RectilinearGrid{dim, T, N, M, TG<:Ferrite.Grid{dim, <:Ferrite.Cell{dim,N,M}, T}} <: AbstractGrid{dim, T}
    grid::TG
    nels::NTuple{dim, Int}
    sizes::NTuple{dim, T}
    corners::NTuple{2, Vec{dim, T}}
end

A type that represents a rectilinear grid with corner points corners.

• dim: dimension of the problem
• T: number type for computations and coordinates
• N: number of nodes in a cell of the grid
• M: number of faces in a cell of the grid
• grid: a Ferrite.Grid struct
• nels: number of elements in every dimension
• sizes: dimensions of each rectilinear cell
• corners: 2 corner points of the rectilinear grid

LGrid(::Type{Val{CellType}}, ::Type{T}; length = 100, height = 100, upperslab = 50, lowerslab = 50) where {T, CellType}
LGrid(::Type{Val{CellType}}, nel1::NTuple{2,Int}, nel2::NTuple{2,Int}, LL::Vec{2,T}, UR::Vec{2,T}, MR::Vec{2,T}) where {CellType, T}

Constructs a Ferrite.Grid that represents the following L-shaped grid.

        upperslab   UR       ............       .          .       .          .       .          . height .          .                     MR       .          ......................       .                               .       .                               . lowerslab       .                               .       .................................     LL             length

Examples:

LGrid(upperslab = 30, lowerslab = 70)LGrid(Val{:Linear}, (2, 4), (2, 2), Vec{2,Float64}((0.0,0.0)), Vec{2,Float64}((2.0, 4.0)), Vec{2,Float64}((4.0, 2.0)))

struct ElementFEAInfo{dim, T}
    Kes::AbstractVector{<:AbstractMatrix{T}}
    fes::AbstractVector{<:AbstractVector{T}}
    fixedload::AbstractVector{T}
    cellvolumes::AbstractVector{T}
    cellvalues::CellValues{dim, T}
    facevalues::FacetValues{<:Any, T}
    metadata::Metadata
    cells
end

An instance of the ElementFEAInfo type stores element information such as:

• Kes: the element stiffness matrices,
• fes: the element load vectors,
• cellvolumes: the element volumes,
• cellvalues and facevalues: two Ferrite types that facilitate cell and face iteration and queries.
• metadata: that stores degree of freedom (dof) to node mapping, dof to cell mapping, etc.
• cells: the cell connectivities.

struct GlobalFEAInfo{T, TK<:AbstractMatrix{T}, Tf<:AbstractVector{T}, Tchol, Tqr}
    K::TK
    f::Tf
    cholK::Tchol
    qrK::Tqr
end

An instance of GlobalFEAInfo hosts the global stiffness matrix K, the load vector f and the cholesky decomposition of the K, cholK.