Hessians for embedded elements

[henrij22]

This should be ready for a first review.

This implements two things:

1. Compute Hessians for embedded elements
2. Apply geometry mapping to second derivatives.

I have used the same approach as was used for jacobians, i.e. overloading functions like dothelper, etc. This might not be the prettiest and could possibly be implemented a bit better. Maybe someone has a better idea, on how to implement some of the new helper methods.

Linking also for reference : Ferrite-FEM/Tensors.jl#188

[codecov]

Codecov Report

❌ Patch coverage is 98.41270% with 1 line in your changes missing coverage. Please review.
✅ Project coverage is 94.19%. Comparing base (f99e206) to head (7260a95).

Files with missing lines	Patch %	Lines
src/FEValues/FunctionValues.jl	98.11%	1 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##           master    #1257      +/-   ##
==========================================
- Coverage   94.19%   94.19%   -0.01%     
==========================================
  Files          40       40              
  Lines        6662     6679      +17     
==========================================
+ Hits         6275     6291      +16     
- Misses        387      388       +1     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

[lijas]

Nice!

Can you also add the hessian equation (for embeded elements) to the docs, similar to how we do it here: https://ferrite-fem.github.io/Ferrite.jl/stable/topics/FEValues/#Identity-mapping

And add a reference to where it is taken from (or perhaps show the derivation :) )

[lijas]

where did the computation of the hessian go?

[henrij22]

Aha, I only added it in above. This code then might not be tested atm. Also, what is the difference between calculate_mapping(gip::ScalarInterpolation) and calculate_mapping(geo_mapping::GeometryMapping). They seem quite similar.

[lijas]

I think we can add tests for the function_hessian also, as we do here:

                coords_nl = [x + rand(x) * 0.01 for x in coords] # add some displacement to nodes
                reinit!(cv, coords_nl)

                _ue_nl = [u_funk(coords_nl[i], V, G, H) for i in 1:n_basefunc_base]
                ue_nl = reinterpret(Float64, _ue_nl)

                for i in 1:getnquadpoints(cv)
                    xqp = spatial_coordinate(cv, i, coords_nl)
                    Hqp, Gqp, Vqp = Tensors.hessian(x -> function_value_from_physical_coord(func_interpol, coords_nl, x, ue_nl), xqp, :all)
                    @test function_value(cv, i, ue_nl) ≈ Vqp
                    @test function_gradient(cv, i, ue_nl) ≈ Gqp
                    if update_hessians
                        @test Ferrite.function_hessian(cv, i, ue_nl) ≈ Hqp
                    end
                end

Can you add a similar test in this @testset for hessians? (I am not sure if function_value_from_physical_coord works with embedded elements)

[lijas]

This might be more difficult than i first thought. For the embedded case, the function_value_from_physical_coord would need some signed distance search to find the parametric coord on the surface

[lijas]

I think this type of construction of SArrays is fine, but I dont know how efficiently the compiler can optimize it, maybe someone else can review this part :)

[henrij22]

You were right, there are a lot of calls in there.
This implementation takes 24 ns on my system, I found a better version which only takes about 2 ns

[henrij22]

Thanks @lijas for the review. I will adress the rest of your points when I have more time :)

[lijas]

I compared the results from function_hessian from the hessian computed with AD:

ip = Lagrange{RefQuadrilateral, 2}()
qr = QuadratureRule{RefQuadrilateral}(2)
cv = CellValues(qr, ip, ip^3; update_hessians = true)

coords = [Vec{3}((2x[1], 0.5x[2], rand())) for x in Ferrite.reference_coordinates(ip)]
coords_nl = [x + rand(x) * 0.01 for x in coords] # Create non-linear geometry
reinit!(cv, coords_nl)
ue = [rand()*0.01 for i in 1:getnbasefunctions(cv)]

for i in 1:getnquadpoints(cv)
    ξqp = cv.qr.points[i]
    xqp = spatial_coordinate(cv, i, coords_nl)
    Hqp, Gqp, Vqp = Tensors.hessian(x -> function_value_from_physical_coord(ip, coords_nl, x, ue_nl), xqp, :all)
    @test function_value(cv, i, ue_nl) ≈ Vqp
    @test function_gradient(cv, i, ue_nl) ≈ Gqp
    @test Ferrite.function_hessian(cv, i, ue_nl) ≈ Hqp
end

The function value and gradient test passes, but the hessian does not. So I suspect that there is some error in you hessian computation.

For this test to work, I needed to change this function to

_solve_helper(A::SMatrix{idim, odim}, b::Vec{idim, T}) where {odim, idim, T} = Vec{odim, T}( inv(A'*A)*(A'*b)) ## pinv(A) * b does not work with ForwardDiff

[henrij22]

@lijas Thanks, okay then I have to take a second look. It's a bit tricky to see where the error could be, its either in the computation of the Hessian (of the geometry) or in the apply_mapping() function.
I think we should have the AD test also somewhere in the test suite.

Edit: I think the error should be in apply_mapping()