[v1.0.1] Tune import time

[adtzlr]

Guess: if numba is installed, felupe compiles the parallel version of the integrate method of a form on import - even if it is not used. This should be handled in a better way in the future.

[adtzlr]

A possible solution would be to update globals with felupe.use_numba() or something similar. For example, the __init__.py file contains an import statement for a function fun.

from ._python import fun

If form.assemble(parallel=True) is called, the functions should be replaced by numba-accelerated functions

def use_numba():
    from ._numba import fun
    globals().update(fun=fun)

[adtzlr]

equivalent to globals()["fun"] = fun or globals().update(fun=fun) is also import sys; fe = sys.modules[__name__]; fe.fun=fun

[adtzlr]

In the past (alpha versions) this was complicated but now that everything is organized in folders/files this should be an easy task.

[adtzlr]

see branch https://github.com/adtzlr/felupe/tree/improve-numba-jit

[adtzlr]

okay, it seems this commit slows down import time even more.

[adtzlr]

Inspecting __init__.py gives:

from .__about__ import __version__

import time 
t = []

t.append(time.time())
from . import math
t.append(time.time())
from . import mesh
t.append(time.time())
from . import quadrature
t.append(time.time())
from . import dof
t.append(time.time())
from . import element
t.append(time.time())
from . import tools
t.append(time.time())
from . import constitution
t.append(time.time())
from . import solve
t.append(time.time())
from . import region
t.append(time.time())

import numpy as np
print(np.diff(np.array(t)))
# ...

produces

In [1]: import felupe
[0.00519323 0.01053238 2.14523649 0.87573862 0.05784726 0.38405085
 0.00819564 0.         0.00375438]

[adtzlr]

It seems most of the time is spent on importing quadrature due to quadpy followed by dof due to `sparse´.

[adtzlr]

As we only use Legendre-Gauss rules quadpy could be removed - NumPy has them built-in. See https://numpy.org/doc/stable/reference/routines.polynomials.legendre.html

points, weights = numpy.polynomial.legendre.leggauss(deg)

[adtzlr]

x, y = np.polynomial.legendre.leggauss(3)
w, v, u = np.meshgrid(x, x, x, indexing="ij")
points = np.vstack((u.ravel(), v.ravel(), w.ravel())).T
weights = np.einsum("i,j,k",y,y,y).ravel()