Fix show method avoiding stats print

examples/linear_extension/linear_extension.jl

@@ -9,25 +9,25 @@ include("linear_extension_mesh.jl")
 
 "Return problem parameters"
 function parameters()
-    E = 2.0             # Young modulus in Pa
-    ν = 0.4             # Poisson's ratio
+    E = 2.0                             # Young modulus in Pa
+    ν = 0.4                             # Poisson's ratio
     λ = E * ν / ((1 + ν) * (1 - 2 * ν)) # First Lamé parameter
-    G = E / (2 * (1 + ν)) # Second Lamé parameter
-    tension(t) = p * t  # Tension load function
-    p = 3               # Tension load in Pa
-    Lx = 2.0            # Dimension in x of the box in m
-    Ly = 1.0            # Dimension in y of the box in m
-    Lz = 1.0            # Dimension in z of the box in m
-    RTOL = 1e-4         # Relative tolerance for tests
-    ATOL = 1e-6         # Absolute tolerance for tests
-    NSTEPS = 9          # νmber of steps for the test
-    ms = 0.5            # Refinement factor
-    (; Lx, Ly, Lz, E, ν, λ, G, tension, RTOL, ATOL, NSTEPS, ms)
+    G = E / (2 * (1 + ν))               # Second Lamé parameter
+    tension_load(t) = p * t             # Tension load function
+    p = 3                               # Tension load in Pa
+    Lx = 2.0                            # Dimension in x of the box in m
+    Ly = 1.0                            # Dimension in y of the box in m
+    Lz = 1.0                            # Dimension in z of the box in m
+    RTOL = 1e-4                         # Relative tolerance for tests
+    ATOL = 1e-6                         # Absolute tolerance for tests
+    NSTEPS = 9                          # number of steps for the test
+    ms = 0.5                            # Refinement factor
+    (; Lx, Ly, Lz, E, ν, λ, G, tension_load, RTOL, ATOL, NSTEPS, ms)
 end;
 
 "Return the problem structural model"
 function structure()
-    (; Lx, Ly, Lz, E, ν, tension, ms) = parameters()
+    (; Lx, Ly, Lz, E, ν, tension_load, ms) = parameters()
     # -------------------------------
     # Materials
     # -------------------------------
@@ -46,7 +46,7 @@ function structure()
     bc3 = FixedDof(:u, [3], bc3_label)
     # Load
     bc4_label = "tension"
-    bc4 = GlobalLoad(:u, t -> [tension(t), 0, 0], bc4_label)
+    bc4 = GlobalLoad(:u, t -> [tension_load(t), 0, 0], bc4_label)
     # Get bc labels for the mesh
     bc_labels = [bc1_label, bc2_label, bc3_label, bc4_label]
     boundary_conditions = StructuralBoundaryCondition(bc1, bc2, bc3, bc4)
@@ -70,13 +70,9 @@ function structure()
     end
     gmsh_println(output)
     msh_file = MshFile(mesh_path)
-    mesh = Mesh(msh_file, entities)
     # -------------------------------
     # Structure
     # -------------------------------
-    apply!(materials, mesh)
-    apply!(boundary_conditions, mesh)
-
     Structure(msh_file, materials, boundary_conditions, entities)
 end;
 
@@ -91,7 +87,7 @@ function solve()
     # -------------------------------
     # Numerical solution
     # -------------------------------
-    solve!(sa)
+    sol = solve!(sa)
 end;
 
 "Return random points to evaluate the solution"
@@ -143,14 +139,14 @@ end;
 "Return analytical results for testing"
 function analytic_solution(sol::AbstractSolution, p1::Point{dim}, p2::Point{dim},
                            e::AbstractElement{dim}) where {dim}
-    (; E, ν, λ, G, tension) = parameters()
+    (; E, ν, λ, G, tension_load) = parameters()
     sa = analysis(sol)
     ## Displacements
     "Compute displacements νmeric solution ui, uj and uk for analytic validation."
     function u_ijk_analytic(λv::Vector{<:Real},
                             x0::Real, y0::Real, z0::Real,
                             ν::Real=ν, E::Real=E)
-        C(t) = tension(t) * (1 - ν - 2ν^2) / (1 - ν)
+        C(t) = tension_load(t) * (1 - ν - 2ν^2) / (1 - ν)
 
         ui(t) = C(t) / E * x0
         uj(t) = 0.0
@@ -172,7 +168,7 @@ function analytic_solution(sol::AbstractSolution, p1::Point{dim}, p2::Point{dim}
     "Compute strains νmeric solution ϵi, ϵj and ϵk for analytic validation."
     function ϵ_ijk_analytic(λv::Vector{<:Real}, x0::Real, y0::Real, z0::Real, ν::Real=ν,
                             E::Real=E)
-        C(t) = tension(t) * (1 - ν - 2ν^2) / (1 - ν)
+        C(t) = tension_load(t) * (1 - ν - 2ν^2) / (1 - ν)
 
         ϵi(t) = C(t) / E
         ϵj(t) = 0.0
@@ -183,7 +179,7 @@ function analytic_solution(sol::AbstractSolution, p1::Point{dim}, p2::Point{dim}
     ## Stresses
     "Compute strains νmeric solution ϵi, ϵj and ϵk for analytic validation."
     function σ_ijk_analytic(λv::Vector{<:Real}, x0::Real, y0::Real, z0::Real, λ::Real, G::Real)
-        C(t) = tension(t) * (1 - ν - 2ν^2) / (1 - ν)
+        C(t) = tension_load(t) * (1 - ν - 2ν^2) / (1 - ν)
 
         ϵi(t) = C(t) / E
         ϵj(t) = 0.0
@@ -260,7 +256,7 @@ function test(sol::AbstractSolution)
         @test σj_num ≈ σj_analy rtol = RTOL skip = true
         @test σk_num ≈ σk_analy rtol = RTOL skip = true
     end
-end
+end;
 
 "Run the example"
 function run()

src/StructuralAnalyses/LinearStaticAnalyses.jl

@@ -73,12 +73,12 @@ function Base.show(io::IO, sa::LinearStaticAnalysis)
 end
 
 "Solves a linear analysis problem mutating the state."
-function _solve!(sa::LinearStaticAnalysis, alg::Nothing,
+function _solve!(sa::LinearStaticAnalysis, ::Nothing,
                  linear_solver::SciMLBase.AbstractLinearAlgorithm)
     s = structure(sa)
 
     # Initialize solution.
-    solution = Solution(sa, alg)
+    solution = Solution(sa, linear_solver)
 
     # Load factors iteration.
     while !is_done(sa)
@@ -97,7 +97,7 @@ function _solve!(sa::LinearStaticAnalysis, alg::Nothing,
         @debugtime "Step" step!(sa, linear_solver)
 
         # Recompute σ and ε for the assembler
-        @debugtime "Update internal forces, stres and strains" assemble!(s, sa)
+        @debugtime "Update internal forces, stresses and strains" assemble!(s, sa)
 
         # Save current state
         store!(solution, current_state(sa), step)

src/StructuralAnalyses/NonLinearStaticAnalyses.jl

@@ -136,4 +136,23 @@ function step!(sa::NonLinearStaticAnalysis, ::NewtonRaphson,
     update!(current_iteration(sa), norm_ΔU, rel_norm_ΔU, norm_r, rel_norm_r)
 end
 
+"Show the solution when solved with an in-house algorithm."
+function Base.show(io::IO, ::MIME"text/plain",
+                   solution::Solution{<:FullStaticState})
+    show(io, solution)
+
+    println("\nStats:")
+    println("----------")
+    # Check convergence
+    is_any_step_not_converged = any([criterion_step isa Union{NotConvergedYet,MaxIterCriterion}
+                                     for criterion_step in criterion(solution)])
+
+    num_iterations = reduce(+, iterations(solution))
+    avg_iterations = round(num_iterations / length(states(solution)); digits=1)
+    println("• Number of linear systems solved: $num_iterations")
+    println("• Average of iterations per step : $avg_iterations")
+    println("• Convergence success            : $(!is_any_step_not_converged)")
+    _print_table(solution)
+end
+
 end # module

src/StructuralSolvers/Solutions.jl

@@ -8,7 +8,7 @@ Of course the solution contains on the analysis and solver used to solve the pro
 """
 module Solutions
 
-using Reexport, PrettyTables, Dictionaries
+using Reexport, PrettyTables, Dictionaries, LinearSolve
 
 using ..Utils
 using ..Entities
@@ -55,7 +55,7 @@ solver(sol::AbstractSolution) = sol.solver
 Solution that stores all intermediate arrays during the analysis.
 """
 struct Solution{ST<:AbstractStaticState,A<:AbstractStructuralAnalysis,
-                SS<:Union{AbstractSolver,Nothing}} <: AbstractSolution
+                SS<:Union{AbstractSolver,SciMLBase.AbstractLinearAlgorithm}} <: AbstractSolution
     "Vector containing the converged structural states at each step."
     states::Vector{ST}
     "Analysis solved."
@@ -67,7 +67,7 @@ end
 "Constructor with empty `AbstractStructuralState`s `Vector` and type `S`."
 function Solution(analysis::A,
                   solver::SS) where {A<:AbstractStructuralAnalysis,
-                                     SS<:Union{AbstractSolver,Nothing}}
+                                     SS<:Union{AbstractSolver,SciMLBase.AbstractLinearAlgorithm}}
 
     # TODO Use concrete types.
     state = current_state(analysis)
@@ -88,28 +88,16 @@ function Solution(analysis::A,
     Solution{StaticState,A,SS}(states, analysis, solver)
 end
 
-"Show the states solution."
-function Base.show(io::IO, ::MIME"text/plain", solution::Solution)
+"Generic minimal show method for a generic `solution`"
+function Base.show(io::IO, ::MIME"text/plain",
+                   solution::Solution)
     println("Analysis solved:")
     println("----------------\n")
     show(io, analysis(solution))
 
     println("\nSolver employed:")
     println("----------------\n")
     show(io, solver(solution))
-
-    println("\nStats:")
-    println("----------")
-    # Check convergence
-    is_any_step_not_converged = any([criterion_step isa Union{NotConvergedYet,MaxIterCriterion}
-                                     for criterion_step in criterion(solution)])
-
-    num_iterations = reduce(+, iterations(solution))
-    avg_iterations = round(num_iterations / length(states(solution)); digits=1)
-    println("• Number of linear systems solved: $num_iterations")
-    println("• Average of iterations per step : $avg_iterations")
-    println("• Convergence success            : $(!is_any_step_not_converged)")
-    _print_table(solution)
 end
 
 "Print the solution table"

src/StructuralSolvers/StructuralSolvers.jl

@@ -63,8 +63,10 @@ struct ResidualForceCriterion <: AbstractConvergenceCriterion end
 """ `ΔUCriterion` indicates displacements increment convergence criterion. """
 struct ΔUCriterion <: AbstractConvergenceCriterion end
 
-""" `ΔU_and_ResidualForce_Criteria` convergence criterion indicates that both ΔU and residual forces
-converged . """
+"""
+`ΔU_and_ResidualForce_Criteria` convergence criterion indicates that both
+ΔU and residual forces converged .
+"""
 struct ΔU_and_ResidualForce_Criteria <: AbstractConvergenceCriterion end
 
 """ `MaxIterCriterion` criteria indicates that the maximum number of iterations has been reached. """
@@ -198,8 +200,9 @@ which holds the result and the algorithm used to obtain it.
 
 This function mutates the state defined in the analysis problem.
 Use [`solve`](@ref) to avoid mutation.
-For linear analysis problems, the algorithm doesn't need to be provided.
-Also a linar solver form the LinearSolve.jl package can by provided. By default the wrapper to IterativeSolvers Conjugatge Gradient is being used.
+For linear analysis problems, the algorithm doesn't need to be provided since `linear_solve` is used.
+Also a linear solver form the LinearSolve.jl package can by provided. By default the wrapper
+to IterativeSolvers Conjugatge Gradient is being used.
 """
 function solve!(problem::AbstractStructuralAnalysis, solver::Union{AbstractSolver,Nothing}=nothing,
                 linear_solve::SciMLBase.AbstractLinearAlgorithm=DEFAULT_LINEAR_SOLVER())