On 28 November 2011 20:47, Anders E. Johansen <email address hidden> wrote:
> Public bug reported:
>
> FFC uses a considerable amount of time (> 1h) compiling the following
> program. The generated .h-file exceeds 90MB. Running, it uses hours
> assembling a matrix. Using the SFC compiler, compiling is done in no
> more than ten minutes, and then the program finishes in about ten
> seconds.
>
> I have similar problems with FFC and this Fung-type material law in
> other cases, eg computing the second Piola-Kirchhoff stress tensor.
> Then, the SFC compiled code is about 22000 times faster than FFC.
>
> Anders
>
>
> from dolfin import *
>
> mesh = UnitCube(2, 2, 2)
> V = VectorFunctionSpace(mesh, "CG", 1)
> bcl = DirichletBC(V, (0.0, 0.0, 0.0), "near(x[0], 0.0) && on_boundary")
> bcr = DirichletBC(V, (0.1, 0.0, 0.0), "near(x[0], 1.0) && on_boundary")
> bcs = [bcl, bcr]
>
> v  = TestFunction(V)
> u  = Function(V)
> du = TrialFunction(V)
>
> K   = Constant(0.876)
> C   = Constant(10.0)
> bff = Constant(18.48)
> bxx = Constant(3.58)
> bfx = Constant(2.8)
>
> I = Identity(3)
> F = I + grad(u)
>
> a = Expression(("x[0]*DOLFIN_PI/8"))
> R = as_matrix([[cos(a), 0, -sin(a)], [0, 1, 0], [sin(a), 0, cos(a)]])
>
> F = variable(R.T*F*R)
> E = 0.5*(F.T*F - I)
> J = det(F)
>
> f=0; s=1; n=2
> W = (bff*E[f,f]**2
>     + bxx*(E[n,n]**2 + E[s,s]**2 + E[n,s]**2)
>     + bfx*(E[f,n]**2 + E[n,f]**2 + E[f,s]**2 + E[s,f]**2))
> psi = 0.5*K*(exp(W) - 1) + C*(J*ln(J) - J + 1)
>
> P = diff(psi, F)
> P = R*P*R.T
>
> L = inner(P, grad(v))*dx
> a = derivative(L, u, du)
> solve(L==0, u, bcs, J=a)
> plot(u, mode="displacement", interactive=True)
>
> ** Affects: ffc
>     Importance: Undecided
>         Status: New
>
> --
> You received this bug notification because you are a member of FFC Core
> Team, which is subscribed to FFC.
> https://bugs.launchpad.net/bugs/897372
>
> Title:
>  FFC is extremely slow compared to SFC for this Fung-type material law
>
> Status in FEniCS Form Compiler:
>  New
>
> Bug description:
>  FFC uses a considerable amount of time (> 1h) compiling the following
>  program. The generated .h-file exceeds 90MB. Running, it uses hours
>  assembling a matrix. Using the SFC compiler, compiling is done in no
>  more than ten minutes, and then the program finishes in about ten
>  seconds.
>
>  I have similar problems with FFC and this Fung-type material law in
>  other cases, eg computing the second Piola-Kirchhoff stress tensor.
>  Then, the SFC compiled code is about 22000 times faster than FFC.
>
>  Anders
>
>
>  from dolfin import *
>
>  mesh = UnitCube(2, 2, 2)
>  V = VectorFunctionSpace(mesh, "CG", 1)
>  bcl = DirichletBC(V, (0.0, 0.0, 0.0), "near(x[0], 0.0) && on_boundary")
>  bcr = DirichletBC(V, (0.1, 0.0, 0.0), "near(x[0], 1.0) && on_boundary")
>  bcs = [bcl, bcr]
>
>  v  = TestFunction(V)
>  u  = Function(V)
>  du = TrialFunction(V)
>
>  K   = Constant(0.876)
>  C   = Constant(10.0)
>  bff = Constant(18.48)
>  bxx = Constant(3.58)
>  bfx = Constant(2.8)
>
>  I = Identity(3)
>  F = I + grad(u)
>
>  a = Expression(("x[0]*DOLFIN_PI/8"))
>  R = as_matrix([[cos(a), 0, -sin(a)], [0, 1, 0], [sin(a), 0, cos(a)]])
>
>  F = variable(R.T*F*R)
>  E = 0.5*(F.T*F - I)
>  J = det(F)
>
>  f=0; s=1; n=2
>  W = (bff*E[f,f]**2
>       + bxx*(E[n,n]**2 + E[s,s]**2 + E[n,s]**2)
>       + bfx*(E[f,n]**2 + E[n,f]**2 + E[f,s]**2 + E[s,f]**2))
>  psi = 0.5*K*(exp(W) - 1) + C*(J*ln(J) - J + 1)
>
>  P = diff(psi, F)
>  P = R*P*R.T
>
>  L = inner(P, grad(v))*dx
>  a = derivative(L, u, du)
>  solve(L==0, u, bcs, J=a)
>  plot(u, mode="displacement", interactive=True)
>
> To manage notifications about this bug go to:
> https://bugs.launchpad.net/ffc/+bug/897372/+subscriptions

I tested the above solver on my system with:

parameters["form_compiler"]["cpp_optimize"] = True

For SFC
parameters["form_compiler"]["name"] = "sfc"
The total time to reach the plot command was
1. run 4m38s
2. run       1.8s
For the given problem, SFC will use 4 integration points per cell.


For FFC (running instant-clean first) without adding any additional
options I didn't bother to wait for the solver to complete, the
solution step took too long.
This is because FFC uses 97336 integration points per cell for the
given problem,
this is roughly a factor 24000 more than SFC and also explains why the
generated code is so big.

To ensure a fair comparison, adding the ffc_options dict:

ffc_options = {"quadrature_degree": 2}

to the solve function will result in 4 integration points being used
for FFC too.

The total time to reach the plot command was:
1. run 3m55s
2. run       3.2s

and if FFC optimisation is switched on:

ffc_options = {"quadrature_degree": 2, \
               "optimize": True, \
               "eliminate_zeros": True, \
               "precompute_basis_const": True}

The total time to reach the plot command was:
1. run 9m37s
2. run       1.8s (identical to SFC)

Can you perhaps confirm these trends? If so, I'll mark the bug as invalid.