+ ${display_result} +
+Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
The method of topological optimization of binary structures (TOBS) was originally developed in the context of optimal distribution of material in mechanical components. In its core, is a heuristic to solve binary optimization problems by first linearizing the objective and constraints. Then, a binary nonlinear program is solved (default solver is Cbc) to determine which binary variables must be flipped in the current iteration.
using NonconvexTOBS, TopOpt
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+rmin = 6.0 # filter radius
+xmin = 0.001 # minimum density
+V = 0.5 # maximum volume fraction
+p = 3.0 # topological optimization penalty3.0problem_size = (160, 100); # size of rectangular mesh
+x0 = fill(1.0, prod(problem_size)); # initial design
+problem = PointLoadCantilever(Val{:Linear}, problem_size, (1.0, 1.0), E, v, f);FEA solver and auxiliary functions need to be defined as well:
solver = FEASolver(Direct, problem; xmin=xmin);
+cheqfilter = DensityFilter(solver; rmin=rmin); # filter function
+comp = TopOpt.Compliance(solver); # compliance functionThe usual topology optimization problem adresses compliance minimization under volume restriction. Therefore, the objective and the constraint are:
obj(x) = comp(cheqfilter(PseudoDensities(x))); # compliance objective
+constr(x) = sum(cheqfilter(PseudoDensities(x))) / length(x) - V; # volume fraction constraintFinally, the optimization problem is defined and solved:
m = Model(obj); # create optimization model
+addvar!(m, zeros(length(x0)), ones(length(x0))); # setup optimization variables
+Nonconvex.add_ineq_constraint!(m, constr); # setup volume inequality constraint
+options = TOBSOptions(); # optimization options with default values
+TopOpt.setpenalty!(solver, p);Perform TOBS optimization
@time r = Nonconvex.optimize(m, TOBSAlg(), x0; options=options)NonconvexTOBS.TOBSResult{Vector{Float64}, Float64, Float64}([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 40.65043198662879, 0.0005001390738640084)@show obj(r.minimizer)
+@show constr(r.minimizer)
+topology = r.minimizer;obj(r.minimizer) = 40.65043198662879
+constr(r.minimizer) = -5.5392031406142905e-8This page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
This example is also available as a Jupyter notebook: beso.ipynb
What follows is a program spliced with comments. The full program, without comments, can be found in the next section.
using TopOptE = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0; # downward force
+
+nels = (160, 40)
+problem = HalfMBB(Val{:Linear}, nels, (1.0, 1.0), E, v, f)solver = FEASolver(Direct, problem; xmin=0.01, penalty=TopOpt.PowerPenalty(3.0))comp = Compliance(solver)
+volfrac = Volume(solver)
+sensfilter = SensFilter(solver; rmin=4.0)
+beso = BESO(comp, volfrac, 0.5, sensfilter)x0 = ones(length(solver.vars))
+result = beso(x0)TopOpt.Algorithms.BESOResult{Float64, Vector{Float64}}([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 347.57452308620924, 9.602487566045443e-5, true, 117)Need to run using Pkg; Pkg.add(["Makie", "GLMakie"]) first
using Makie, GLMakie
+using TopOpt.TopOptProblems.Visualization: visualize
+fig = visualize(problem; topology = result.topology)
+Makie.display(fig)Below follows a version of the program without any comments. The file is also available here: beso.jl
using TopOpt
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0; # downward force
+
+nels = (160, 40)
+problem = HalfMBB(Val{:Linear}, nels, (1.0, 1.0), E, v, f)
+
+solver = FEASolver(Direct, problem; xmin=0.01, penalty=TopOpt.PowerPenalty(3.0))
+
+comp = Compliance(solver)
+volfrac = Volume(solver)
+sensfilter = SensFilter(solver; rmin=4.0)
+beso = BESO(comp, volfrac, 0.5, sensfilter)
+
+x0 = ones(length(solver.vars))
+result = beso(x0)
+
+# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jlThis page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
This example is also available as a Jupyter notebook: csimp.ipynb
What follows is a program spliced with comments. The full program, without comments, can be found in the next section.
using TopOptE = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+
+problems = Any[
+ PointLoadCantilever(Val{:Linear}, (60, 20, 20), (1.0, 1.0, 1.0), E, v, f),
+ PointLoadCantilever(Val{:Linear}, (160, 40), (1.0, 1.0), E, v, f),
+ HalfMBB(Val{:Linear}, (60, 20), (1.0, 1.0), E, v, f),
+ LBeam(Val{:Linear}, Float64; force=f),
+ TieBeam(Val{:Quadratic}, Float64),
+]
+problem_names = [
+ "3d cantilever beam", "cantilever beam", "half MBB beam", "L-beam", "tie-beam"
+]
+
+i = 2
+println(problem_names[i])
+problem = problems[i]V = 0.5 # volume fraction
+xmin = 0.001 # minimum density
+rmin = 3.0
+
+convcriteria = Nonconvex.KKTCriteria()
+x0 = fill(V, TopOpt.getncells(problem))
+penalty = TopOpt.PowerPenalty(1.0)
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)
+comp = Compliance(solver)
+filter = if problem isa TopOptProblems.TieBeam
+ identity
+else
+ DensityFilter(solver; rmin=rmin)
+end
+obj = x -> comp(filter(PseudoDensities(x)))#1 (generic function with 1 method)Define volume constraint
volfrac = Volume(solver)
+constr = x -> volfrac(filter(PseudoDensities(x))) - V
+model = Model(obj)
+addvar!(model, zeros(length(x0)), ones(length(x0)))
+add_ineq_constraint!(model, constr)
+alg = MMA87()
+
+nsteps = 4
+ps = range(1.0, 5.0; length=nsteps + 1)1.0:1.0:5.0exponentially decaying tolerance from 10^-2 to 10^-4
tols = exp10.(range(-2, -4; length=nsteps + 1))
+x = x0
+for j in 1:(nsteps + 1)
+ global convcriteria
+ p = ps[j]
+ tol = tols[j]
+ TopOpt.setpenalty!(solver, p)
+ options = MMAOptions(; tol=Tolerance(; kkt=tol), maxiter=1000, convcriteria)
+ res = optimize(model, alg, x; options)
+ global x = res.minimizer
+end
+
+@show obj(x)
+@show constr(x)-7.087833098218255e-10Need to run using Pkg; Pkg.add(["Makie", "GLMakie"]) first
using Makie, GLMakie
+using TopOpt.TopOptProblems.Visualization: visualize
+fig = visualize(problem; topology = x, default_exagg_scale = 0.07,
+ scale_range = 10.0, vector_linewidth = 3, vector_arrowsize = 0.5,
+)
+Makie.display(fig)Below follows a version of the program without any comments. The file is also available here: csimp.jl
using TopOpt
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+
+problems = Any[
+ PointLoadCantilever(Val{:Linear}, (60, 20, 20), (1.0, 1.0, 1.0), E, v, f),
+ PointLoadCantilever(Val{:Linear}, (160, 40), (1.0, 1.0), E, v, f),
+ HalfMBB(Val{:Linear}, (60, 20), (1.0, 1.0), E, v, f),
+ LBeam(Val{:Linear}, Float64; force=f),
+ TieBeam(Val{:Quadratic}, Float64),
+]
+problem_names = [
+ "3d cantilever beam", "cantilever beam", "half MBB beam", "L-beam", "tie-beam"
+]
+
+i = 2
+println(problem_names[i])
+problem = problems[i]
+
+V = 0.5 # volume fraction
+xmin = 0.001 # minimum density
+rmin = 3.0
+
+convcriteria = Nonconvex.KKTCriteria()
+x0 = fill(V, TopOpt.getncells(problem))
+penalty = TopOpt.PowerPenalty(1.0)
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)
+comp = Compliance(solver)
+filter = if problem isa TopOptProblems.TieBeam
+ identity
+else
+ DensityFilter(solver; rmin=rmin)
+end
+obj = x -> comp(filter(PseudoDensities(x)))
+
+volfrac = Volume(solver)
+constr = x -> volfrac(filter(PseudoDensities(x))) - V
+model = Model(obj)
+addvar!(model, zeros(length(x0)), ones(length(x0)))
+add_ineq_constraint!(model, constr)
+alg = MMA87()
+
+nsteps = 4
+ps = range(1.0, 5.0; length=nsteps + 1)
+
+tols = exp10.(range(-2, -4; length=nsteps + 1))
+x = x0
+for j in 1:(nsteps + 1)
+ global convcriteria
+ p = ps[j]
+ tol = tols[j]
+ TopOpt.setpenalty!(solver, p)
+ options = MMAOptions(; tol=Tolerance(; kkt=tol), maxiter=1000, convcriteria)
+ res = optimize(model, alg, x; options)
+ global x = res.minimizer
+end
+
+@show obj(x)
+@show constr(x)
+
+# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jlThis page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
This example is also available as a Jupyter notebook: geso.ipynb
What follows is a program spliced with comments. The full program, without comments, can be found in the next section.
using TopOptE = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0; # downward force
+
+nels = (160, 40)
+problem = HalfMBB(Val{:Linear}, nels, (1.0, 1.0), E, v, f)solver = FEASolver(Direct, problem; xmin=0.01, penalty=TopOpt.PowerPenalty(3.0))comp = Compliance(solver)
+volfrac = Volume(solver)
+sensfilter = SensFilter(solver; rmin=4.0)
+geso = GESO(comp, volfrac, 0.5, sensfilter)x0 = ones(length(solver.vars))
+result = geso(x0)TopOpt.Algorithms.GESOResult{Float64, Vector{Float64}}([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 369.7967915599027, 0.0009543123395089087, true, 173)Need to run using Pkg; Pkg.add(["Makie", "GLMakie"]) first
using Makie, GLMakie
+using TopOpt.TopOptProblems.Visualization: visualize
+fig = visualize(problem; topology = result.topology)
+Makie.display(fig)Below follows a version of the program without any comments. The file is also available here: geso.jl
using TopOpt
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0; # downward force
+
+nels = (160, 40)
+problem = HalfMBB(Val{:Linear}, nels, (1.0, 1.0), E, v, f)
+
+solver = FEASolver(Direct, problem; xmin=0.01, penalty=TopOpt.PowerPenalty(3.0))
+
+comp = Compliance(solver)
+volfrac = Volume(solver)
+sensfilter = SensFilter(solver; rmin=4.0)
+geso = GESO(comp, volfrac, 0.5, sensfilter)
+
+x0 = ones(length(solver.vars))
+result = geso(x0)
+
+# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jlThis page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
This example is also available as a Jupyter notebook: global_stress.ipynb
What follows is a program spliced with comments. The full program, without comments, can be found in the next section.
using TopOpt, LinearAlgebraE = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+rmin = 3.0 # filter radius
+
+problems = Any[
+ PointLoadCantilever(Val{:Linear}, (60, 20), (1.0, 1.0), E, v, f),
+ HalfMBB(Val{:Linear}, (60, 20), (1.0, 1.0), E, v, f),
+]
+problem_names = ["Cantilever beam", "Half MBB beam", "L-beam", "Tie-beam"]
+
+i = 1
+println(problem_names[i])
+problem = problems[i]V = 0.5 # volume fraction
+xmin = 0.001 # minimum density
+steps = 40 # maximum number of penalty steps, delta_p0 = 0.1
+convcriteria = Nonconvex.KKTCriteria()
+penalty = TopOpt.PowerPenalty(1.0)PowerPenalty{Float64}(1.0)solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)Notice that gradient is derived automatically by automatic differentiation (Zygote.jl)!
stress = TopOpt.von_mises_stress_function(solver)
+filter = if problem isa TopOptProblems.TieBeam
+ identity
+else
+ DensityFilter(solver; rmin=rmin)
+end
+volfrac = TopOpt.Volume(solver)
+
+x0 = ones(length(solver.vars))
+threshold = 3 * maximum(stress(filter(PseudoDensities(x0))))
+
+obj = x -> volfrac(filter(PseudoDensities(x)))
+constr = x -> norm(stress(filter(PseudoDensities(x))), 5) - threshold#3 (generic function with 1 method)N = length(solver.vars)
+x0 = fill(0.5, N)
+
+options = MMAOptions(; maxiter=2000, tol=Nonconvex.Tolerance(; kkt=1e-4), convcriteria)
+model = Model(obj)
+addvar!(model, zeros(N), ones(N))
+add_ineq_constraint!(model, constr)
+alg = MMA87()
+r = optimize(model, alg, x0; options)
+
+@show obj(r.minimizer)
+@show constr(r.minimizer)1654.3571582678276Need to run using Pkg; Pkg.add(["Makie", "GLMakie"]) first
using Makie, GLMakie
+using TopOpt.TopOptProblems.Visualization: visualize
+fig = visualize(problem; topology = r.minimizer)
+Makie.display(fig)Below follows a version of the program without any comments. The file is also available here: global-stress.jl
using TopOpt, LinearAlgebra
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+rmin = 3.0 # filter radius
+
+problems = Any[
+ PointLoadCantilever(Val{:Linear}, (60, 20), (1.0, 1.0), E, v, f),
+ HalfMBB(Val{:Linear}, (60, 20), (1.0, 1.0), E, v, f),
+]
+problem_names = ["Cantilever beam", "Half MBB beam", "L-beam", "Tie-beam"]
+
+i = 1
+println(problem_names[i])
+problem = problems[i]
+
+V = 0.5 # volume fraction
+xmin = 0.001 # minimum density
+steps = 40 # maximum number of penalty steps, delta_p0 = 0.1
+convcriteria = Nonconvex.KKTCriteria()
+penalty = TopOpt.PowerPenalty(1.0)
+
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)
+
+stress = TopOpt.von_mises_stress_function(solver)
+filter = if problem isa TopOptProblems.TieBeam
+ identity
+else
+ DensityFilter(solver; rmin=rmin)
+end
+volfrac = TopOpt.Volume(solver)
+
+x0 = ones(length(solver.vars))
+threshold = 3 * maximum(stress(filter(PseudoDensities(x0))))
+
+obj = x -> volfrac(filter(PseudoDensities(x)))
+constr = x -> norm(stress(filter(PseudoDensities(x))), 5) - threshold
+
+N = length(solver.vars)
+x0 = fill(0.5, N)
+
+options = MMAOptions(; maxiter=2000, tol=Nonconvex.Tolerance(; kkt=1e-4), convcriteria)
+model = Model(obj)
+addvar!(model, zeros(N), ones(N))
+add_ineq_constraint!(model, constr)
+alg = MMA87()
+r = optimize(model, alg, x0; options)
+
+@show obj(r.minimizer)
+@show constr(r.minimizer)
+
+# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jlThis page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
using Revise
using TopOpt, LinearAlgebra, StatsFuns
+using StatsFuns: logsumexp
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+rmin = 3.03.0problem = PointLoadCantilever(Val{:Linear}, (160, 40), (1.0, 1.0), E, v, f)V = 0.5 # volume fraction
+xmin = 0.0001 # minimum density
+steps = 40 # maximum number of penalty steps, delta_p0 = 0.140x0 = fill(0.5, 160 * 40) # initial design
+N = length(x0)
+penalty = TopOpt.PowerPenalty(1.0)
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)
+stress = TopOpt.von_mises_stress_function(solver)
+filter = DensityFilter(solver; rmin=rmin)
+volfrac = TopOpt.Volume(solver)
+
+obj = x -> volfrac(filter(PseudoDensities(x))) - V
+thr = 150 # stress threshold
+constr = x -> begin
+ s = stress(filter(PseudoDensities(x)))
+ return (s .- thr) / length(s)
+end
+alg = PercivalAlg()
+options = PercivalOptions()
+model = Model(obj)
+addvar!(model, zeros(N), ones(N))
+add_ineq_constraint!(model, constr)
+
+x = copy(x0)
+for p in [1.0, 2.0, 3.0]
+ TopOpt.setpenalty!(solver, p)
+ global r = optimize(model, alg, x; options)
+ global x = r.minimizer
+end
+
+maximum(stress(filter(PseudoDensities(x0))))
+maximum(stress(filter(PseudoDensities(x))))151.7884771703217Need to run using Pkg; Pkg.add(["Makie", "GLMakie"]) first
using Makie, GLMakie
+using TopOpt.TopOptProblems.Visualization: visualize
+fig = visualize(
+ problem; topology = r.minimizer, default_exagg_scale = 0.07,
+ scale_range = 10.0, vector_linewidth = 3, vector_arrowsize = 0.5,
+)
+Makie.display(fig)Below follows a version of the program without any comments. The file is also available here: local-stress.jl
using TopOpt, LinearAlgebra, StatsFuns
+using StatsFuns: logsumexp
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0 # downward force
+rmin = 3.0
+
+problem = PointLoadCantilever(Val{:Linear}, (160, 40), (1.0, 1.0), E, v, f)
+
+V = 0.5 # volume fraction
+xmin = 0.0001 # minimum density
+steps = 40 # maximum number of penalty steps, delta_p0 = 0.1
+
+x0 = fill(0.5, 160 * 40) # initial design
+N = length(x0)
+penalty = TopOpt.PowerPenalty(1.0)
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)
+stress = TopOpt.von_mises_stress_function(solver)
+filter = DensityFilter(solver; rmin=rmin)
+volfrac = TopOpt.Volume(solver)
+
+obj = x -> volfrac(filter(PseudoDensities(x))) - V
+thr = 150 # stress threshold
+constr = x -> begin
+ s = stress(filter(PseudoDensities(x)))
+ return (s .- thr) / length(s)
+end
+alg = PercivalAlg()
+options = PercivalOptions()
+model = Model(obj)
+addvar!(model, zeros(N), ones(N))
+add_ineq_constraint!(model, constr)
+
+x = copy(x0)
+for p in [1.0, 2.0, 3.0]
+ TopOpt.setpenalty!(solver, p)
+ global r = optimize(model, alg, x; options)
+ global x = r.minimizer
+end
+
+maximum(stress(filter(PseudoDensities(x0))))
+maximum(stress(filter(PseudoDensities(x))))
+
+# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jlThis page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
In this section, the syntax to construct multiple problem types will be shown. In TopOpt.jl, there are a number of standard topology optimization problem domains that can be defined using a few lines of code. This is for the convenience of testing and comparing algorithms and formulations on standard testing problems.
In this problem, the domain is divided into equally sized rectangular, quadrilateral elements. The number of elements (nels) and element sizes (elsizes) can be used to control the resolution of the problem's domain as well as its dimension. For instance, using nels = (160, 40) and elsizes = (1.0, 1.0) constructs a 2D problem domain of size 160 mm x 40 mm problem domain where each element is 1 mm x 1 mm. While nels = (160, 40, 40) and elsizes = (1.0, 1.0, 2.0) constructs a 3D problem domain of size 160 mm x 40 mm x 40 mm where each element is 1 mm x 1 mm x 2 mm.
Additionally, the Young’s modulus, Poisson’s ratio and downward force magnitude. Finally, the order of the geometric and field shape functions can be specified using either :Linear or :Quadratic as shown below.
using TopOpt
+
+E = 1.0 # Young’s modulus in MPa
+ν = 0.3 # Poisson’s ratio
+f = 1.0 # downward force in N - negative is upward
+nels = (160, 40) # number of elements
+elsizes = (1.0, 1.0) # the size of each element in mm
+order = :Linear # shape function order
+problem = PointLoadCantilever(Val{order}, nels, elsizes, E, ν, f)
A similar problem type exists for the well known half MBB problem shown above. The constructor and parameters are similar to that of the point load cantilever beam. Also 2D and 3D variants exist by changing the lengths of nels and elsizes.
E = 1.0 # Young’s modulus in MPa
+ν = 0.3 # Poisson’s ratio
+f = 1.0 # downward force in N - negative is upward
+nels = (60, 20) # number of elements
+elsizes = (1.0, 1.0) # the size of each element in mm
+order = :Quadratic # shape function order
+problem = HalfMBB(Val{order}, nels, elsizes, E, ν, f)
The L-beam is another well known testing problem in topology optimization available in TopOpt.jl. To construct an L-beam problem, you can use the following constructor. The L-beam problem is only a 2D problem.
E = 1.0 # Young’s modulus in MPa
+ν = 0.3 # Poisson’s ratio
+f = 1.0 # downward force in N - negative is upward
+order = :Quadratic # shape function order
+problem = LBeam(
+ Val{order}; length=100, height=100, upperslab=50, lowerslab=50, E=1.0, ν=0.3, force=1.0
+)where E, ν and force are the Young's modulus, Poisson's ratio and downward force respectively. The definition of length, height, upperslab and lowerslab are shown below. Each element is assumed to be a 1 mm x 1 mm element. The load is always applied at the midpoint of the "lowerslab" side. A positive value for the force is downward and a negative value is upward.
upperslab
+ ............
+ . .
+ . .
+ . .
+height . .
+ . ......................
+ . .
+ . . lowerslab
+ . .
+ .................................
+ length
+
The tie-beam problem shown above is a well-known problem in topology optimization literature. A distributed load of 1 N/mm is applied on the elements specified in the figure. To construct an instance of the tie-beam problem for a certain order of shape functions, you can use:
order = :Quadratic # shape function order
+problem = TieBeam(Val{order})The tie-beam problem only exists as a 2D problem.
Instead of defining a problem type programmatically, one can also use CAD/CAE software to define a 2D/3D problem domain using a graphical user interface and then export a .inp file from the CAD/CAE software. The .inp file can then be read into TopOpt.jl using:
filename = "../data/problem.inp" # path to inp file
+problem = InpStiffness(filename);For example, the following problem with fixed load, distributed loads and tetrahedral elements was defined usign FreeCAD and imported into TopOpt.jl to perform topology optimization. More information on how to specify the supports and loads in FreeCAD can be found in the webpage of FreeCAD's FEM Workbench.
Data for constructing a 2D/3D truss problems can be imported from a json file:
path_to_file = "../data/tim_2d.json" # path to json file
+mats = TrussFEAMaterial(10.0, 0.3) # Young’s modulus and Poisson’s ratio
+crossecs = TrussFEACrossSec(800.0) # Cross-sectional area
+node_points, elements, _, _, fixities, load_cases = load_truss_json(path_to_file)
+loads = load_cases["0"]
+problem = TrussProblem(Val{:Linear}, node_points, elements, loads, fixities, mats, crossecs);The structure of the JSON file can be parsed to a dictionary using the code below.
using JSON
+f = JSON.parsefile(path_to_file)Dict{String, Any} with 15 entries:
+ "node_num" => 19
+ "elements" => Any[Dict{String, Any}("end_node_inds"=>Any[0, 2], "elem_ta…
+ "materials" => Any[Dict{String, Any}("family"=>"DummyMaterial", "E_unit"=…
+ "loadcases" => Dict{String, Any}("1"=>Dict{String, Any}("lc_ind"=>1, "plo…
+ "cross_secs" => Any[Dict{String, Any}("name"=>"", "A"=>1.0, "family"=>"Dum…
+ "element_num" => 42
+ "supports" => Any[Dict{String, Any}("condition"=>Any[1, 1], "node_ind"=>…
+ "_info" => "TTObuckling example used in PENLAB."
+ "TO_model_type" => "ground_mesh"
+ "dimension" => 2
+ "nodes" => Any[Dict{String, Any}("point"=>Any[0, 0], "node_ind"=>0), …
+ "unit" => "meter"
+ "generate_time" => "05/21/2019 07:40:59"
+ "model_name" => "tim"
+ "model_type" => "truss"The JSON file contains important information for nodal geometry, element connectivity, supports, materials, and cross sections, where every key is a string, and the corresponding value can be a single number, dictionary of values, or a list of dictionary.
⚠️ Be careful that unlike the normal one-indexed convention used in Julia, all the index information in the JSON file starts from ZERO. This is just a choice out of convenience, because some of the developers use python in their CAD software to generate these JSONs.
The MUST-HAVE key-value pairs of the JSON are:
"dimension" : model dimension (2 or 3)
+ "node_num" : total number of nodes (::Int)
+ "element_num : total number of elements (::Int)
+ "nodes" : a list of dictionaries, where each dict is structured as followed
+ {
+ "node_ind" : index of a node, starts from 0.
+ "points" : a list of x,y,z coordinate of the node (Float)
+ [x , y , z] (or [x, y] if dimension=2)
+ }
+ "elements" : a list of dictionaries, where each dict is structured as followed
+ {
+ "end_node_inds" : [
+ start node index, end node index in Int (zero-indexed!)
+ ],
+ "elem_tag" : tag of your element in string to link
+ to its corresponding material and cross section, e.g. `steel_set1`
+ }
+ "supports" : a list of dictionaries, where each dict is structured as followed
+ {
+ "node_ind": 0,
+ "condition": a boolean list marking the fixed dofs, [tx,ty] for 2D,
+ [tx,ty,tz] for 3D
+ }
+ "loadcases" : a dictionary of load cases that maps a load case index to a dictionary
+ { "0":
+ {
+ "lc_ind" : 0, #(same as the load case index 0)
+ "ploads" : [#a list of dictionaries for each load
+ {
+ "node_ind" : node index where the point load is applied
+ "force" : a list of force magitude along x y z axis
+ [x,y,z] (or [x,y] for 2D)
+ "loadcase" : 0 (same as lc_ind)
+ }
+ }
+ }
+ "materials" : a list of dictionaries, where each dict is structured as followed
+ {
+ "name": material name in string,
+ "elem_tags": a list of element tags to which the material is applied, e.g. `steel_set1`,
+ "E": Young's modulus
+ "G12": in-plane shear modulus, not used for truss models now
+ "density": material density, not used now
+ }
+ "cross_secs" : a list of dictionaries, where each dict is structured as followed
+ {
+ "name": cross section name in string,
+ "elem_tags": [],
+ "A": 1.0, # cross section area
+ }When parsed by the load_truss_json function, materials and cross sections with element_tags = [] will be treated as the fallback material or cross section for elements with an empty elem_tag ("")
The following entries are optional for providing additional information about the model:
"unit" : "meter"
+ "model_type" : "truss"
+ "generate_time" : generated date-time in string
+ "TO_model_type" : "ground_mesh"
+ "model_name" : "NameOfYourModel"
+ "_info" : "AdditionalInfo"
Much like the continuum 2D/3D point load cantilever beam, you can also create a 2D/3D truss-based cantilever beam with a point load as shown above using the following syntax.
E = 1.0 # Young’s modulus in MPa
+ν = 0.3 # Poisson’s ratio
+nels = (60, 20) # number of boundary trusses
+elsizes = (1.0, 1.0) # the length of each boundary truss in mm
+force = 1.0 # upward force in N - negative is downward
+problem = PointLoadCantileverTruss(nels, elsizes, E, ν, force; k_connect=1);nels, elsizes, E and ν have an analagous intepretation to the continuum cantilever beam. force is the upward concentrated force in Newton (downward is negative). k_connect is the k-ring of each node defining the connectivity of the nodes in the graph, default is 1. For a 2D domain, a node will be connected to 8 neighboring nodes if k_connect = 1, and 8 + 16 = 24 neighboring nodes if k_connect = 2.
This page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
This example is also available as a Jupyter notebook: simp.ipynb
What follows is a program spliced with comments. The full program, without comments, can be found in the next section.
using TopOptE = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0; # downward force
+
+nels = (30, 10, 10)
+problem = PointLoadCantilever(Val{:Linear}, nels, (1.0, 1.0, 1.0), E, v, f);See also the detailed API of PointLoadCantilever:
TopOpt.TopOptProblems.PointLoadCantilever — Type///**********************************
+///* *
+///* * |
+///* * |
+///********************************** v
+
+
+struct PointLoadCantilever{dim, T, N, M} <: StiffnessTopOptProblem{dim, T}
+ rect_grid::RectilinearGrid{dim, T, N, M}
+ E::T
+ ν::T
+ ch::ConstraintHandler{<:DofHandler{dim, <:Cell{dim,N,M}, T}, T}
+ force::T
+ force_dof::Integer
+ black::AbstractVector
+ white::AbstractVector
+ varind::AbstractVector{Int}
+ metadata::Metadata
+enddim: dimension of the problemT: number type for computations and coordinatesN: number of nodes in a cell of the gridM: number of faces in a cell of the gridrect_grid: a RectilinearGrid structE: Young's modulusν: Poisson's rationforce: force at the center right of the cantilever beam (positive is downward)force_dof: dof number at which the force is appliedch: a Ferrite.ConstraintHandler structmetadata: Metadata having various cell-node-dof relationshipsblack: a BitVector of length equal to the number of elements where black[e] is 1 iff the e^th element must be part of the final designwhite: a BitVector of length equal to the number of elements where white[e] is 1 iff the e^th element must not be part of the final designvarind: an AbstractVector{Int} of length equal to the number of elements where varind[e] gives the index of the decision variable corresponding to element e. Because some elements can be fixed to be black or white, not every element has a decision variable associated.V = 0.3 # volume fraction
+xmin = 1e-6 # minimum density
+rmin = 2.0; # density filter radiuspenalty = TopOpt.PowerPenalty(3.0)
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)comp = TopOpt.Compliance(solver)
+filter = DensityFilter(solver; rmin=rmin)
+obj = x -> comp(filter(PseudoDensities(x)))#1 (generic function with 1 method)volfrac = TopOpt.Volume(solver)
+constr = x -> volfrac(filter(PseudoDensities(x))) - V#3 (generic function with 1 method)x0 = fill(V, length(solver.vars))
+model = Model(obj)
+addvar!(model, zeros(length(x0)), ones(length(x0)))
+add_ineq_constraint!(model, constr)
+alg = MMA87()
+convcriteria = Nonconvex.KKTCriteria()
+options = MMAOptions(;
+ maxiter=3000, tol=Nonconvex.Tolerance(; x=1e-3, f=1e-3, kkt=0.001), convcriteria
+)
+r = optimize(model, alg, x0; options)
+
+@show obj(r.minimizer)42.23812907385913Need to run using Pkg; Pkg.add(["Makie", "GLMakie"]) first
using Makie, GLMakie
+using TopOpt.TopOptProblems.Visualization: visualize
+fig = visualize(
+ problem; topology = r.minimizer,
+ default_exagg_scale = 0.07, scale_range = 10.0,
+ vector_linewidth = 3, vector_arrowsize = 0.5,
+)
+Makie.display(fig)or convert it to a Mesh Need to run using Pkg; Pkg.add(GeometryBasics) first
import Makie, GeometryBasics
+result_mesh = GeometryBasics.Mesh(problem, r.minimizer);
+Makie.mesh(result_mesh)Below follows a version of the program without any comments. The file is also available here: simp.jl
using TopOpt
+
+E = 1.0 # Young’s modulus
+v = 0.3 # Poisson’s ratio
+f = 1.0; # downward force
+
+nels = (30, 10, 10)
+problem = PointLoadCantilever(Val{:Linear}, nels, (1.0, 1.0, 1.0), E, v, f);
+
+V = 0.3 # volume fraction
+xmin = 1e-6 # minimum density
+rmin = 2.0; # density filter radius
+
+penalty = TopOpt.PowerPenalty(3.0)
+solver = FEASolver(Direct, problem; xmin=xmin, penalty=penalty)
+
+comp = TopOpt.Compliance(solver)
+filter = DensityFilter(solver; rmin=rmin)
+obj = x -> comp(filter(PseudoDensities(x)))
+
+volfrac = TopOpt.Volume(solver)
+constr = x -> volfrac(filter(PseudoDensities(x))) - V
+
+x0 = fill(V, length(solver.vars))
+model = Model(obj)
+addvar!(model, zeros(length(x0)), ones(length(x0)))
+add_ineq_constraint!(model, constr)
+alg = MMA87()
+convcriteria = Nonconvex.KKTCriteria()
+options = MMAOptions(;
+ maxiter=3000, tol=Nonconvex.Tolerance(; x=1e-3, f=1e-3, kkt=0.001), convcriteria
+)
+r = optimize(model, alg, x0; options)
+
+@show obj(r.minimizer)
+
+# This file was generated using Literate.jl, https://github.com/fredrikekre/Literate.jlThis page was generated using Literate.jl.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
All the following functions are defined in a differentiable way and you can use them in the objectives or constraints in topology optimization formulation. In TopOpt.jl, you can build arbitrarily complex objective and constraint functions using the following building blocks as lego pieces chaining them in any arbitrary way. The gradient and jacobian of the aggregate Julia function defined is then obtained using automatic differentiation. Beside the following specific functions, arbitrary differentiable Julia functions such as LinearAlgebra.norm and StatsFuns.logsumexp are also supported which can for example be used in aggregating constraints.
DensityFilterrminx::Vector{<:Real}y::Vector{<:Real}flt = DensityFilter(solver, rmin = 3.0)y = flt(x)SensFilterrminx::Vector{<:Real}y::Vector{<:Real}flt = SensFilter(solver, rmin = 3.0)y = flt(x)HeavisideProjectionβ for producing near binary designsx::Vector{<:Real}y::Vector{<:Real}proj = HeavisideProjection(5.0)y = proj(x)Compliancex::Vector{<:Real}comp::Realcompf = Compliance(solver)comp = compf(x)Volumefraction (default is true)x::Vector{<:Real}vol::Realcompf = Compliance(solver)comp = compf(x)Displacementx::Vector{<:Real}u::Vector{<:Real}disp = Displacement(solver)u = disp(x)StressTensoru::Vector{<:Real}. This could be computed by the Displacement function above.σ::Vector{<:Matrix{<:Real}}. This is a vector of symmetric matrices, one matrix for each element.σf = StressTensor(solver)σ = σf(u)von_mises_stress_functionx::Vector{<:Realσv::Vector{<:Real}σvf = von_mises_stress_function(solver)σv = σvf(x)ElementKx::Vector{<:Real}Kes::Vector{<:Matrix{<:Real}}. This is a vector of symmetric positive (semi-)definite matrices, one matrix for each element.Kesf = ElementK(solver)Kes = Kesf(x)AssembleKKes::Vector{<:Matrix{<:Real}}. This is a vector of symmetric matrices, one matrix for each element.K::SparseMatrixCSC{<:Real}.assemble = AssembleK(problem)K = assemble(Kes)apply_boundary_with_zerodiag!Kin::SparseMatrixCSC{<:Real} without boundary conditions applied.Kout::SparseMatrixCSC{<:Real} with the boundary conditions applied.Kout = apply_boundary_with_zerodiag!(Kin, problem.ch)apply_boundary_with_meandiag!Kin::SparseMatrixCSC{<:Real} without boundary conditions applied.Kout::SparseMatrixCSC{<:Real} with the boundary conditions applied.Kout = apply_boundary_with_meandiag!(Kin, problem.ch)TrussElementKσu::Vector{<:Real} computed from the Displacement function, and (2) the filtered, penalized, optionally projected and interpolated design ρ::Vector{<:Real}.Kσs::Vector{<:Matrix{<:Real}}. This is a vector of symmetric matrices, one matrix for each element.Kσsf = TrussElementKσ(problem, solver)Kσs = Kσsf(u, ρ)NeuralNetworkVolume, DensityFilter, etc. In the constructor example below, nn can be an almost arbitrary Flux.jl neural network model, train_func is what needs to be used to define the objective or constraints in the re-parameterized topology optimization formulation and p0 is a vector of the neural network's initial weights and biases which can be used to initialize the optimization. The neural netowrk nn used must be one that can take 2 (or 3) input coordinates in the first layer for 2D (or 3D) problems and returns a scalar between 0 and 1 from the last layer. In prediction mode, this model will be called on each element using the centroid's coordinates as the input to neural network's first layer to compute the element's design variable. train_func below takes the vector of neural network weights and biases, p::Vector{<:Real}, as input.train_func below returns the vector of element-wise design variables, x::Vector{<:Real}, as outputs.nn_model = NeuralNetwork(nn, problem) train_func = TrainFunction(nn_model) p0 = nn_model.init_params
x = train_func(p)Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
TopOpt is a topology optimization package written in Julia.
TopOpt is still under development. If you find a bug, or have ideas for improvements, feel free to open an issue or make a pull request on the TopOpt GitHub page.
To install TopOpt.jl, run:
using Pkg
+pkg"add TopOpt"To additionally load the visualization submodule of TopOpt, you will need to install Makie.jl using:
pkg"add Makie, GLMakie"To load the package, use:
using TopOptand to optionally load the visualization sub-module as part of TopOpt, use:
using TopOpt, Makie, GLMakieSettings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
AlgorithmsThis sub-module of TopOpt defines a number of standard topology optimization algorithms.
TODO.
TopOpt.Algorithms.BESO — TypeThe BESO algorithm, see [1].
TopOpt.Algorithms.GESO — TypeThe GESO algorithm, see [2].
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.
TopOptProblemsThis sub-module of TopOpt defines a number of standard topology optimization problems for the convenient testing of algorithms.
StiffnessTopOptProblem is an abstract type that a number of linear elasticity, quasi-static, topology optimization problems subtype.
TopOpt.TopOptProblems.StiffnessTopOptProblem — Typeabstract type StiffnessTopOptProblem{dim, T} <: AbstractTopOptProblem endAn abstract stiffness topology optimization problem. All subtypes must have the following fields:
ch: a Ferrite.ConstraintHandler structmetadata: Metadata having various cell-node-dof relationshipsblack: a BitVector of length equal to the number of elements where black[e] is 1 iff the e^th element must be part of the final designwhite: a BitVector of length equal to the number of elements where white[e] is 1 iff the e^th element must not be part of the final designvarind: an AbstractVector{Int} of length equal to the number of elements where varind[e] gives the index of the decision variable corresponding to element e. Because some elements can be fixed to be black or white, not every element has a decision variable associated.The following types are all concrete subtypes of StiffnessTopOptProblem. PointLoadCantilever is a cantilever beam problem with a point load as shown below. HalfMBB is the half Messerschmitt-Bölkow-Blohm (MBB) beam problem commonly used in topology optimization literature. LBeam and TieBeam are the common L-beam and tie-beam test problem used in topology optimization literature. The PointLoadCantilever and HalfMBB problems can be either 2D or 3D depending on the type of the inputs to the constructor. If the number of elements and sizes of elements are 2-tuples, the problem constructed will be 2D. And if they are 3-tuples, the problem constructed will be 3D. For the 3D versions, the point loads are applied at approximately the mid-depth point. The TieBeam and LBeam problems are always 2D.
Missing docstring for PointLoadCantilever. Check Documenter's build log for details.
TopOpt.TopOptProblems.PointLoadCantilever — MethodPointLoadCantilever(::Type{Val{CellType}}, nels::NTuple{dim,Int}, sizes::NTuple{dim}, E, ν, force) where {dim, CellType}dim: dimension of the problemE: Young's modulusν: Poisson's rationforce: force at the center right of the cantilever beam (positive is downward)nels: number of elements in each direction, a 2-tuple for 2D problems and a 3-tuple for 3D problemssizes: the size of each element in each direction, a 2-tuple for 2D problems and a 3-tuple for 3D problemsCellType: can be either :Linear or :Quadratic to determine the order of the geometric and field basis functions and element type. Only isoparametric elements are supported for now.Example:
nels = (60,20);
+sizes = (1.0,1.0);
+E = 1.0;
+ν = 0.3;
+force = 1.0;
+
+# Linear elements and linear basis functions
+celltype = :Linear
+
+# Quadratic elements and quadratic basis functions
+#celltype = :Quadratic
+
+problem = PointLoadCantilever(Val{celltype}, nels, sizes, E, ν, force)TopOpt.TopOptProblems.HalfMBB — Type |
+ |
+ 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{dim, <:Cell{dim,N,M}, T}, T}
+ force::T
+ force_dof::Integer
+ black::AbstractVector
+ white::AbstractVector
+ varind::AbstractVector{Int}
+ metadata::Metadata
+enddim: dimension of the problemT: number type for computations and coordinatesN: number of nodes in a cell of the gridM: number of faces in a cell of the gridrect_grid: a RectilinearGrid structE: Young's modulusν: Poisson's rationforce: force at the top left of half the MBB (positive is downward)force_dof: dof number at which the force is appliedch: a Ferrite.ConstraintHandler structmetadata: Metadata having various cell-node-dof relationshipsblack: a BitVector of length equal to the number of elements where black[e] is 1 iff the e^th element must be part of the final designwhite: a BitVector of length equal to the number of elements where white[e] is 1 iff the e^th element must not be part of the final designvarind: an AbstractVector{Int} of length equal to the number of elements where varind[e] gives the index of the decision variable corresponding to element e. Because some elements can be fixed to be black or white, not every element has a decision variable associated.TopOpt.TopOptProblems.HalfMBB — MethodHalfMBB(::Type{Val{CellType}}, nels::NTuple{dim,Int}, sizes::NTuple{dim}, E, ν, force) where {dim, CellType}dim: dimension of the problemE: Young's modulusν: Poisson's rationforce: force at the top left of half the MBB (positive is downward)nels: number of elements in each direction, a 2-tuple for 2D problems and a 3-tuple for 3D problemssizes: the size of each element in each direction, a 2-tuple for 2D problems and a 3-tuple for 3D problemsCellType: can be either :Linear or :Quadratic to determine the order of the geometric and field basis functions and element type. Only isoparametric elements are supported for now.Example:
nels = (60,20);
+sizes = (1.0,1.0);
+E = 1.0;
+ν = 0.3;
+force = -1.0;
+
+# Linear elements and linear basis functions
+celltype = :Linear
+
+# Quadratic elements and quadratic basis functions
+#celltype = :Quadratic
+
+problem = HalfMBB(Val{celltype}, nels, sizes, E, ν, force)TopOpt.TopOptProblems.LBeam — Type////////////
+............
+. .
+. .
+. .
+. .
+. ......................
+. .
+. .
+. . |
+................................. v
+ force
+
+struct LBeam{T, N, M} <: StiffnessTopOptProblem{2, T}
+ E::T
+ ν::T
+ ch::ConstraintHandler{<:DofHandler{2, <:Cell{2,N,M}, T}, T}
+ force::T
+ force_dof::Integer
+ black::AbstractVector
+ white::AbstractVector
+ varind::AbstractVector{Int}
+ metadata::Metadata
+endT: number type for computations and coordinatesN: number of nodes in a cell of the gridM: number of faces in a cell of the gridE: Young's modulusν: Poisson's rationforce: force at the center right of the cantilever beam (positive is downward)force_dof: dof number at which the force is appliedch: a Ferrite.ConstraintHandler structmetadata: Metadata having various cell-node-dof relationshipsblack: a BitVector of length equal to the number of elements where black[e] is 1 iff the e^th element must be part of the final designwhite: a BitVector of length equal to the number of elements where white[e] is 1 iff the e^th element must not be part of the final designvarind: an AbstractVector{Int} of length equal to the number of elements where varind[e] gives the index of the decision variable corresponding to element e. Because some elements can be fixed to be black or white, not every element has a decision variable associated.TopOpt.TopOptProblems.LBeam — MethodLBeam(::Type{Val{CellType}}, ::Type{T}=Float64; length = 100, height = 100, upperslab = 50, lowerslab = 50, E = 1.0, ν = 0.3, force = 1.0) where {T, CellType}T: number type for computations and coordinatesE: Young's modulusν: Poisson's rationforce: force at the center right of the cantilever beam (positive is downward)length, height, upperslab and lowerslab are explained in LGrid.CellType: can be either :Linear or :Quadratic to determine the order of the geometric and field basis functions and element type. Only isoparametric elements are supported for now.Example:
E = 1.0;
+ν = 0.3;
+force = 1.0;
+
+# Linear elements and linear basis functions
+celltype = :Linear
+
+# Quadratic elements and quadratic basis functions
+#celltype = :Quadratic
+
+problem = LBeam(Val{celltype}, E = E, ν = ν, force = force)TopOpt.TopOptProblems.TieBeam — Type 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{2, N, T, M}, T}
+ black::AbstractVector
+ white::AbstractVector
+ varind::AbstractVector{Int}
+ metadata::Metadata
+endT: number type for computations and coordinatesN: number of nodes in a cell of the gridM: number of faces in a cell of the gridE: Young's modulusν: Poisson's rationforce: force at the center right of the cantilever beam (positive is downward)ch: a Ferrite.ConstraintHandler structmetadata: Metadata having various cell-node-dof relationshipsblack: a BitVector of length equal to the number of elements where black[e] is 1 iff the e^th element must be part of the final designwhite: a BitVector of length equal to the number of elements where white[e] is 1 iff the e^th element must not be part of the final designvarind: an AbstractVector{Int} of length equal to the number of elements where varind[e] gives the index of the decision variable corresponding to element e. Because some elements can be fixed to be black or white, not every element has a decision variable associated.TopOpt.TopOptProblems.TieBeam — MethodTieBeam(::Type{Val{CellType}}, ::Type{T} = Float64, refine = 1, force = T(1); E = T(1), ν = T(0.3)) where {T, CellType}T: number type for computations and coordinatesE: Young's modulusν: Poisson's rationforce: force at the center right of the cantilever beam (positive is downward)refine: an integer value of 1 or greater that specifies the mesh refinement extent. A value of 1 gives the standard tie-beam problem in literature.CellType: can be either :Linear or :Quadratic to determine the order of the geometric and field basis functions and element type. Only isoparametric elements are supported for now.In TopOpt.jl, you can import a .inp file to an instance of the problem struct InpStiffness. This can be used to construct problems with arbitrary unstructured ground meshes, complex boundary condition domains and load specifications. The .inp file can be exported from a number of common finite element software such as: FreeCAD or ABAQUS.
TopOpt.TopOptProblems.InputOutput.INP.InpStiffness — Typestruct InpStiffness{dim, N, TF, TI, TBool, 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
+ black::TBool
+ white::TBool
+ varind::TInds
+ metadata::TMeta
+enddim: dimension of the problemTF: number type for computations and coordinatesN: number of nodes in a cell of the gridinp_content: an instance of 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 relationshipsblack: a BitVector of length equal to the number of elements where black[e] is 1 iff the e^th element must be part of the final designwhite: a BitVector of length equal to the number of elements where white[e] is 1 iff the e^th element must not be part of the final designvarind: an AbstractVector{Int} of length equal to the number of elements where varind[e] gives the index of the decision variable corresponding to element e. Because some elements can be fixed to be black or white, not every element has a decision variable associated.TopOpt.TopOptProblems.InputOutput.INP.InpStiffness — MethodInpStiffness(filepath::AbstractString; keep_load_cells = false)Imports stiffness problem from a .inp file, e.g. InpStiffness("example.inp"). The keep_load_cells keyword argument will enforce that any cell with a load applied on it is to be part of the final optimal design generated by topology optimization algorithms.
Missing docstring for IO.INP.Parser.InpContent. Check Documenter's build log for details.
Grid types are defined in TopOptProblems because a number of topology optimization problems share the same underlying grid but apply the loads and boundary conditions at different locations. For example, the PointLoadCantilever and HalfMBB problems use the same rectilinear grid type, RectilinearGrid, under the hood. The LBeam problem uses the LGrid function under the hood to construct an L-shaped Ferrite.Grid. New problem types can be defined using the same grids but different loads or boundary conditions.
TopOpt.TopOptProblems.RectilinearGrid — Typestruct 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}}
+ white_cells::BitVector
+ black_cells::BitVector
+ constant_cells::BitVector
+endA type that represents a rectilinear grid with corner points corners.
dim: dimension of the problemT: number type for computations and coordinatesN: number of nodes in a cell of the gridM: number of faces in a cell of the gridgrid: a Ferrite.Grid structnels: number of elements in every dimensionsizes: dimensions of each rectilinear cellcorners: 2 corner points of the rectilinear gridwhite_cells: cells fixed to be void during optimizationblack_cells: cells fixed to have material during optimizationconstant_cells: cells fixed to be either void or have material during optimizationTopOpt.TopOptProblems.RectilinearGrid — MethodRectilinearGrid(::Type{Val{CellType}}, nels::NTuple{dim,Int}, sizes::NTuple{dim,T}) where {dim, T, CellType}Constructs an instance of RectilinearGrid.
dim: dimension of the problemT: number type for coordinatesnels: number of elements in every dimensionsizes: dimensions of each rectilinear cellExample:
rectgrid = RectilinearGrid((60,20), (1.0,1.0))TopOpt.TopOptProblems.LGrid — FunctionLGrid(::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)))Currently, TopOpt uses Ferrite.jl for FEA-related modeling. This means that all the problems above are described in the language and types of Ferrite.
ElementFEAInfoTopOpt.TopOptProblems.ElementFEAInfo — Typestruct ElementFEAInfo{dim, T}
+ Kes::AbstractVector{<:AbstractMatrix{T}}
+ fes::AbstractVector{<:AbstractVector{T}}
+ fixedload::AbstractVector{T}
+ cellvolumes::AbstractVector{T}
+ cellvalues::CellValues{dim, T}
+ facevalues::FaceValues{<:Any, T}
+ metadata::Metadata
+ black::AbstractVector
+ white::AbstractVector
+ varind::AbstractVector{Int}
+ cells
+endAn 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.black: a BitVector such that black[i] is 1 iff element i must be part of any feasible design.white: a BitVector such that white[i] is 1 iff element i must never be part of any feasible design.varind: a vector such that varind[i] gives the decision variable index of element i.cells: the cell connectivities.TopOpt.TopOptProblems.ElementFEAInfo — MethodElementFEAInfo(sp, quad_order=2, ::Type{Val{mat_type}}=Val{:Static}) where {mat_type}Constructs an instance of ElementFEAInfo from a stiffness problem sp using a Gaussian quadrature order of quad_order. The element matrix and vector types will be:
SMatrix and SVector if mat_type is :SMatrix or :Static, the default,MMatrix and MVector if mat_type is :MMatrix, orMatrix and Vector otherwise.The static matrices and vectors are more performant and GPU-compatible therefore they are used by default.
GlobalFEAInfoTopOpt.TopOptProblems.GlobalFEAInfo — Typestruct GlobalFEAInfo{T, TK<:AbstractMatrix{T}, Tf<:AbstractVector{T}, Tchol}
+ K::TK
+ f::Tf
+ cholK::Tchol
+endAn instance of GlobalFEAInfo hosts the global stiffness matrix K, the load vector f and the cholesky decomposition of the K, cholK.
TopOpt.TopOptProblems.GlobalFEAInfo — MethodGlobalFEAInfo(::Type{T}=Float64) where {T}Constructs an empty instance of GlobalFEAInfo where the field K is an empty sparse matrix of element type T and the field f is an empty dense vector of element type T.
TopOpt.TopOptProblems.GlobalFEAInfo — MethodGlobalFEAInfo(sp::StiffnessTopOptProblem)Constructs an instance of GlobalFEAInfo where the field K is a sparse matrix with the correct size and sparsity pattern for the problem instance sp. The field f is a dense vector of the appropriate size. The values in K and f are meaningless though and require calling the function assemble! to update.
Settings
This document was generated with Documenter.jl version 1.7.0 on Sunday 6 October 2024. Using Julia version 1.10.5.