Speed up repeated evaluation, derivative (and assembly) of form

[dokken]

@vincent_scholz

for i in range(some_large_number):
    # calculate new values for my functions (here: just random)
    # case a) some functions remain constant (e.g. v, k), and some change (e.g. u), as shown in this minimal example
    # case b) all functions (u, v, k) change
    u.vector().set_local(np.random.rand(V.dim()))

    # evaluate my formula res(u, v, k), which returns a scalar (!) residual
    # >>> first call: 3e-4 s, successive calls: 2e-4 s
    res_form = k * df.inner(df.grad(u), df.grad(v)) * df.dx - f_load * v * df.dx
    # >>> first call: 1e-3 s, successive calls: 4e-4 s
    res = df.assemble(res_form)

    # calculate the respective derivatives (here: just u for clarity)
    # >>> first call: 1e-3 s, successive calls: 7e-4 s
    dres__du = np.asarray(df.assemble(df.derivative(res_form, u)))

This could be rewritten as:

res_form = k * df.inner(df.grad(u), df.grad(v)) * df.dx - f_load * v * df.dx
dres_du = df.derivative(res_form, u)
for i in range(some_large_number):
    u.vector().set_local(np.random.rand(V.dim()))
    res = df.assemble(res_form)
    dres__du = np.asarray(df.assemble(dres_du))

A second thing that could speed up your code is to move to DOLFINx, as there the compiled form can be stored outside of the loop, saving you some time looking up cached code.