Skip to content

v12.0.0

Choose a tag to compare

@adtzlr adtzlr released this 30 Oct 13:10
· 36 commits to main since this release
01bdd1b

FElupe 12.0.0 is a major release. Plots can be drawn by selectable plotting backends, among them a dependency-free WebGL viewer and matplotlib, and jobs can be followed in a live dashboard in Jupyter. A tuned SuperLU solver is the new, faster default, the time is an input of time-dependent materials and the mixed-field formulations of several solid bodies can be merged. The deprecated callbacks are removed in favour of plugins and the minimum version of Python is 3.11. The migration of existing scripts is described in Breaking changes below.

✨ Highlights

Plotting backends. The plot-methods, e.g. Mesh.plot(), FieldContainer.plot(), SolidBody.plot() and the plots of boundary conditions or rigid contacts, are drawn by a selectable plotting backend. PyVista stays the default, its plots are unchanged.

fem.set_plotting_backend("webgl")  # "pyvista" (default), "webgl" or "matplotlib"
solid.plot("Principal Values of Cauchy Stress").show()
  • "webgl": a dependency-free WebGL viewer in the web browser. A plot is a self-contained HTML page, which works offline and may be shared as a file by view.WebGLPlotter.export_html(). In a notebook it is shown in the output of the cell, or as a Jupyter widget by widget() (felupe[web]).
  • "matplotlib": the plots are drawn on the axes of a matplotlib figure, without PyVista. Screenshots are taken off-screen in raster and vector formats (PNG, PDF, SVG, EPS), and a model can be drawn next to other plots in one figure, e.g. solid.plot(..., plotter=ax).
  • Custom plotting backends are subclasses of view.PlottingBackend, registered by view.register_plotting_backend().

Live dashboard of a job. DashboardWidgetPlugin shows a compact live dashboard of a job in a Jupyter widget (JupyterLab, Jupyter Notebook or the interactive window of VS Code): the deformed model of the latest converged substep, the load path including cutbacks, the solver figures, the properties of the model and performance statistics. snapshot() returns a static, self-contained HTML page of the dashboard, and DashboardWidgetPlugin(filename="job.html") writes a live HTML file, which updates itself in the web browser without a server, also without Jupyter. The widget requires felupe[dashboard].

job = fem.Job(steps=[step], plugins=[fem.DashboardWidgetPlugin()]).evaluate()

Faster default linear solver. solve.SuperLUSolver() is the new default solver of newtonraphson(), Job.evaluate(), CharacteristicCurve.evaluate(), solve.solve() and project(). It uses SuperLU of SciPy (no new dependency) with options tuned for the structurally symmetric matrices of the finite element method: the symmetric mode, no pivoting by default (with a check of the backward error and a fallback with pivoting) and the static pivoting of the zero diagonal entries of saddle point problems. Compared to scipy.sparse.linalg.spsolve(), the factorization is about twice as fast for meshes with hexahedrons. Mixed-field formulations and penalty-based items profit most, e.g. a ThreeFieldVariation with 14,293 degrees of freedom is factorized in 0.8 s instead of 115 s with a pivot threshold of 0.1.

The time as input of time-dependent materials. The time increment is an input of a time-dependent material, like the deformation gradient, e.g. umat.gradient(x, dtime=0.1). A material is time-dependent if its function has an argument dtime without a default value which is not given as material parameter. A TimeStep item ramps the (absolute) time in a Step, i.e. a hold step only ramps the time, the CutbackPlugin interpolates the time of subdivided substeps and Job.evaluate(time=time) writes the time to XDMF result files. A constant dtime=... as material parameter still works.

umat = fem.Hyperelastic(fem.finite_strain_viscoelastic, mu=1.0, eta=1.0, nstatevars=6)
solid = fem.SolidBodyNearlyIncompressible(umat, field, bulk=5000)
time = fem.TimeStep(items=[solid])

# a loading with a constant stretch rate, followed by a holding time
loading = fem.Step(
    items=[solid],
    ramp={
        boundaries["move"]: fem.math.linsteps([0, 1], num=10),
        time: fem.math.linsteps([0, 1], num=10),
    },
    boundaries=boundaries,
)
holding = fem.Step(
    items=[solid],
    ramp={time: fem.math.linsteps([1, 11], num=10)},
    boundaries=boundaries,
)

The volumetric part of the strain energy density function. NeoHooke, Volumetric, NearlyIncompressible and SolidBodyNearlyIncompressible take the argument volumetric: "volume-ratio" (default, as before), "stretch", "log" or a custom VolumetricStrainEnergy, e.g. fem.NeoHooke(mu=1, bulk=5000, volumetric="log").

Several solid bodies with mixed-field formulations. field.merge() merges mixed field containers, e.g. a displacement field next to FieldsMixed of other bodies with different formulations (Q1/P0, Q2/P0, Taylor-Hood, MINI) or the fields of ThirdMediumContactMixed. The first fields, e.g. the displacements, are merged, all other fields belong to their body (#809).

Single precision. The default tolerance of newtonraphson() depends on the data types, i.e. models with fields in single precision (float32) converge without a relaxed tolerance. For float64 the tolerance is unchanged.

Documentation. New how-to guides Use Plugins, Choose a Plotting Backend and Define Time-Dependent Materials. The how-to guides are grouped by topic.

⚠️ Breaking changes

Python 3.11 or newer is required (Python 3.10 reaches its end of life in October 2026).

The callbacks are removed (deprecated since 11.3.0). Use plugins instead, they get the same values:

# FElupe 11
job = fem.Job(steps, callback=callback, a=1)

# FElupe 12: a callable plugin, called after each completed substep
job = fem.Job(
    steps,
    plugins=[
        lambda context, state: callback(
            state.stepnumber, state.substepnumber, context.substep, a=1
        )
    ],
)
# FElupe 11: newtonraphson(..., callback=callback) or Job.evaluate(callback=callback)
# FElupe 12: a plugin with the hook after_iteration
class NewtonCallback(fem.Plugin):
    def after_iteration(self, context, state):
        callback(state.dx, state.x, state.iteration, state.xnorm, state.fnorm, state.success)


job = fem.Job(steps, plugins=[NewtonCallback()])

The argument plugins of Job and CharacteristicCurve is keyword-only, unknown keyword-arguments of a job raise a TypeError (before, they were passed to the callback). The unused arguments progress_bar and callback_kwargs of newtonraphson() are removed.

The loadcases return only the boundaries. The default value of return_loadcase of dof.uniaxial(), dof.biaxial() and dof.shear() is False. Unpacking the result raises a TypeError with a hint.

boundaries = fem.dof.uniaxial(field, clamped=True)
boundaries, loadcase = fem.dof.uniaxial(field, clamped=True, return_loadcase=True)

NearlyIncompressible(dUdJ=..., d2UdJdJ=...) is replaced by volumetric, a kind or a subclass of VolumetricStrainEnergy. The attributes dUdJ and d2UdJdJ are removed, the volumetric part is the attribute volumetric.

class MyVolumetric(fem.VolumetricStrainEnergy):
    def __init__(self, bulk):
        self.bulk = bulk

    def __call__(self, J):
        return self.bulk / 4 * (J**2 - 1 - 2 * np.log(J))

    def dUdJ(self, J):
        return self.bulk / 2 * (J - 1 / J)

    def d2UdJdJ(self, J):
        return self.bulk / 2 * (1 + 1 / J**2)


umat = fem.NearlyIncompressible(fem.NeoHooke(mu=1), volumetric=MyVolumetric(bulk=5000))

Removed functions and arguments: newtonrhapson() and tools.newtonrhapson() (use newtonraphson()) and the argument bounds of dof.symmetry() (use boundaries).

finite_strain_viscoelastic() gives different results. Its stress and tangent are fixed: before, the stress was scaled by approximately 1 / (1 + mu * dtime / eta). Its state variables are now the deviation of the inelastic right Cauchy-Green deformation tensor from the identity, i.e. they are initially zero. State variables or checkpoints of FElupe 11 are not compatible. The second argument is renamed from Cin to statevars.

linear_elastic_viscoelastic() takes dtime instead of Δt. A material parameter Δt of MaterialStrain is still accepted, with a DeprecationWarning (see below).

🔄 Other changes of the behaviour

  • The results of the new default solver are equal to spsolve() up to round-off errors. solver=scipy.sparse.linalg.spsolve restores the previous default solver, e.g. in Job.evaluate(). Note that spsolve() uses UMFPACK if scikit-umfpack is installed, solve.SuperLUSolver() does not.
  • CutbackPlugin also catches a RuntimeError by default, i.e. a failed factorization of a nearly singular matrix leads to a cutback instead of a failed job.
  • thermal.TimeStep is moved to the mechanics module, fem.TimeStep (thermal.TimeStep is the same class). It updates any item and doesn't have to be the first item of a step.
  • The attribute mesh of ViewMesh, ViewField and ViewSolid, the pyvista.UnstructuredGrid, is created on first access, i.e. a view is created without PyVista.
  • felupe[autodiff] requires tensortrax>=0.30.0.
  • Private attributes and aliases are removed: FieldDual.__args__ and __kwargs__, mesh._cube_hexa, mesh._line_line and mesh._rectangle_quad.

🗑️ Deprecated

  • The material parameter Δt of MaterialStrain, the former name of the time increment of linear_elastic_viscoelastic(). It will be removed in 13.0.0. Use dtime instead.

🐞 Fixes

  • finite_strain_viscoelastic(): the stress and the tangent (see Breaking changes).
  • ConstitutiveMaterial.optimize(): the predicted and the observed forces are paired in the order of the load cases (before, planar shear data was ignored or compared to biaxial data) and the fitted parameters are set (before, the fit had no effect, e.g. for NeoHooke, LinearElastic, OgdenRoxburgh and composite materials).
  • FreeVibration: the shift sigma (raised a TypeError), the default field container of merged field containers, the multiplier of an item also scales its mass matrix and assembled matrices with too many degrees of freedom raise an error instead of being trimmed.
  • project(..., solver=...): the solver was ignored.
  • revolve() of solid bodies with state variables.
  • XDMFWriterPlugin without the argument kwargs.
  • Scheme.plot(weighted=True) of quadrature schemes with negative weights.
  • math.solve_nd() and math.solve_2d() broadcast the trailing axes.
  • The viscoelastic templates in the docstrings of the materials of tensortrax and JAX.

📦 Installation

pip install --upgrade "felupe[all]"

New optional dependencies: felupe[web] (anywidget, for the Jupyter widget of the WebGL viewer) and felupe[dashboard] (the dashboard), both included in felupe[all].

The complete list of changes follows below.


[12.0.0] - 2026-10-30

Added

  • Add DashboardWidgetPlugin(title=None, interval=0.1), a job plugin with a compact live dashboard of a job in a Jupyter widget, e.g. in JupyterLab, Jupyter Notebook or the interactive window of VS Code. It shows the model of the latest converged substep with banded contours of the norm of the first field of the unknowns (e.g. displacements or temperature), deformed by this field if it has as many components as the points, the load path with one cell per substep including the load factors of the increments of a CutbackPlugin, the solver figures (residual norm, tolerance, the residual norms of the attempts of the current substep, iterations, cutbacks, failed attempts), the properties of the model (points, cells and cell type of the mesh, finite element and quadrature of the region, degrees of freedom) and performance statistics (assembly, linear solve, residual and update, time per iteration, peak memory). The model is drawn from the cells of the regions of all items (without boundary regions), e.g. of several solid bodies on the meshes of a MeshContainer, and the values are taken from the first field of the unknowns x0 of the job (the other fields may be defined on other meshes). The widget is updated while the cell is running and all controls (scale, mesh lines, view) work in the frontend. The default view of a 3d-model is the default view of the plots of FElupe, e.g. of SolidBody.plot(), with the z-axis upwards. Only the field values of the latest converged substep are kept. Only the points of the outer surface and their values are transferred to the frontend, the limits of the legend are evaluated by the values at all points. It requires the new optional dependency anywidget (pip install felupe[dashboard], also included in felupe[all]). Without a Jupyter frontend, e.g. in a script in a terminal or in the IPython terminal, a warning is raised once and the dashboard is not displayed (the state of the job is collected anyway). A static snapshot of the dashboard after the job, DashboardWidgetPlugin.snapshot(), is a self-contained HTML page, which is shown in the output of a cell (in an iframe, whose height and theme follow the dashboard and the parent page), e.g. in the examples of the documentation which are executed by sphinx-gallery without a Jupyter kernel, or saved as a HTML file by snapshot.save("job.html"). With DashboardWidgetPlugin(filename="job.html", file_interval=2.0), a live HTML file of the dashboard is written (also without a Jupyter frontend and without anywidget), which is opened in the web browser without a Jupyter frontend. The state is written to a script next to the page at most every file_interval seconds (only if it has changed, each file is replaced atomically) and the page polls the scripts and updates itself without a reload (no server is required).
  • Enhance SolidBodyNearlyIncompressible with the new argument SolidBodyNearlyIncompressible(..., volumetric="volume-ratio") for the volumetric part of the strain energy density function, given by a kind with the bulk modulus or by an instance of VolumetricStrainEnergy (then, without the bulk modulus). The built-in kinds are quadratic in the Seth-Hill strain E_m = (λ^m - 1) / m of the volumetric stretch λ = J^(1/3), i.e. U(J) = 9K/2 E_m^2: "volume-ratio" for U(J) = K (J - 1)^2 / 2 (m=3, default, as before), "stretch" for U(J) = 9K (J^(1/3) - 1)^2 / 2 (m=1) and "log" for U(J) = K ln(J)^2 / 2 (limit m → 0). The argument bulk=None is optional now and it is only required for the kinds. A missing bulk modulus, an unknown kind or a bulk modulus together with an instance raise a ValueError.
  • Add VolumetricStrainEnergy(bulk, kind="volume-ratio"), the volumetric part of the strain energy density function as a function of the volume ratio. An instance U is callable, i.e. U(J), U.dUdJ(J) and U.d2UdJdJ(J) return the function and its first and second derivatives, for the kinds "volume-ratio", "stretch" and "log". Unlike a ConstitutiveMaterial, it is evaluated by the volume ratio J, not by the deformation gradient. A custom volumetric part is a subclass which implements __call__(J), dUdJ(J) and d2UdJdJ(J). It is used by NeoHooke, Volumetric, NearlyIncompressible and SolidBodyNearlyIncompressible, which provide it by the attribute volumetric.
  • Add the argument volumetric="volume-ratio" to NeoHooke(mu=None, bulk=None, parallel=False, volumetric="volume-ratio") and Volumetric(bulk=None, parallel=False, volumetric="volume-ratio") for the volumetric part of the strain energy density function, given by a kind with the bulk modulus or by an instance of VolumetricStrainEnergy (then, without the bulk modulus), e.g. NeoHooke(mu=1, bulk=5000, volumetric="stretch"). The default results are bit-identical. Without the bulk modulus, NeoHooke has no volumetric part (as before). The argument bulk of Volumetric is optional now (it is required for the kinds).
  • Add solve.SuperLUSolver(permc_spec="MMD_AT_PLUS_A", diag_pivot_thresh=0.0, diag_perturbation=None, symmetric_mode=True, relax=2, panel_size=20, options=None, refine=True, tol=None, fallback_pivot_thresh=0.1), a sparse direct solver by scipy.sparse.linalg.splu() with options tuned for the (structurally) symmetric matrices of the finite element method. An instance is a solver function x = solver(A, b), e.g. Job.evaluate(solver=fem.solve.SuperLUSolver()). The symmetric mode of SuperLU with the minimum degree ordering of the structure of A^T + A requires only a symmetric structure of the matrix, i.e. it is also used for non-symmetric values, e.g. of follower loads or of frictional contacts, and no check of the symmetry is required. By default, the diagonal entries are taken as pivots (no pivoting), i.e. the fill-reducing ordering of the columns is kept. The large off-diagonal entries of penalty-based items, e.g. of a MultiPointConstraint or a ContactRigidPlane, do not lead to pivoting, which would increase the fill-in and the time of the factorization by orders of magnitude, e.g. a ThreeFieldVariation of a mesh with hexahedrons and 14,293 degrees of freedom is factorized in 0.8 s instead of 115 s with a pivot threshold of 0.1. However, SuperLU never takes a diagonal entry of zero as pivot. The zero diagonal entries of saddle point problems, e.g. of the pressure fields of ThreeFieldVariation and NearlyIncompressible (on FieldsMixed) or of a mixed weak form by Form, lead to an exchange of rows if they are eliminated before they are filled by the elimination of one of their neighbours. Hence, the zero diagonal entries A_ii = 0 are perturbed before the factorization (static pivoting, like PARDISO) by -ε Σ_j A_ji² / |A_jj| (sum over the rows j with non-zero diagonal entries), i.e. by the relative perturbation ε (the argument diag_perturbation, if None, the square root of the machine epsilon of the precision of the matrix) of an estimate of their pivots (the diagonal entries of the Schur complement with the inverse of the diagonal of the other block). The perturbation is invariant to the scaling of the unknowns, e.g. by the units of the displacements and the pressure, and its sign is the sign of the pivots of a symmetric saddle point problem with a positive definite block. The matrix with the perturbed zero diagonal entries is returned by SuperLUSolver.perturb(A). The solution of the perturbed matrix is improved by iterative refinement with the original matrix until the relative correction (maximum norms) is below the tolerance (at most ten steps, stopped if the correction is not reduced by at least a factor of two), usually by one or two steps. If the iterative refinement does not converge or if the backward error exceeds the tolerance, the original matrix is factorized again with the pivot threshold fallback_pivot_thresh, e.g. for an exactly singular matrix. With diag_perturbation=0 or refine=False, the zero diagonal entries are not perturbed. E.g., an incompressible mixed u/p-formulation by Form with a constant pressure per cell on a mesh with 512 quadratic hexahedrons and 7,215 degrees of freedom is solved in 1.5 s instead of 20 s without perturbation (with 2,221 exchanges of rows, the fill-in of the factors is increased by a factor of about seven). Without pivoting, the factorization is not guaranteed to be stable. Hence, the normwise backward error of the solution ||b - A x|| / (||A|| ||x|| + ||b||) (maximum norms) is evaluated by SuperLUSolver.backward_error(A, x, b, r=None), which requires one sparse matrix-vector product and which does not depend on the condition number of the matrix. If the backward error exceeds the tolerance tol (if None, the square root of the machine epsilon of the lowest precision of the matrix and the right-hand side) or if the first factorization fails, the matrix is factorized again with the pivot threshold fallback_pivot_thresh. With fallback_pivot_thresh=None, the matrix is factorized only once and the backward error is not evaluated (except for the iterative refinement of a perturbed matrix). Before the evaluation of the backward error, the solution is improved by one step of iterative refinement (refine=True), which re-uses the factors of the matrix. The evaluation of the backward error and the refinement take less than 1% of the time of the factorization for models with more than a few thousand degrees of freedom. Compared to scipy.sparse.linalg.spsolve(), the factorization is faster, e.g. by a factor of about two for meshes with hexahedrons and of about 1.5 for meshes with quads, and the fill-in of the factors is lower. Small relaxed supernodes (relax=2, the default of SuperLU is 10) are as fast as larger ones for meshes with linear cells and in 2d, but faster for meshes with quadratic cells and for mixed field formulations in 3d, e.g. by a factor of up to four compared to relax=20. The size of the panels (panel_size=20, the default of SuperLU) has no significant influence. Like spsolve(), a single right-hand side returns a 1d-array and an exactly singular matrix emits a MatrixRankWarning and returns NaN values. Multiple right-hand sides and sparse right-hand sides are supported. The LU decomposition is available by SuperLUSolver.factorize(A, diag_pivot_thresh=None) (if None, the pivot threshold of the solver).
  • Add the how-to guide Use Plugins, which introduces the plugins of a Job and the built-in plugins (ProgressPlugin, XDMFWriterPlugin, CharacteristicCurvePlugin, AnimationWriterPlugin, DashboardWidgetPlugin, LinesearchPlugin and CutbackPlugin), how plugins are combined and how a custom plugin is written by a subclass of Plugin or by a callable.
  • Add selectable plotting backends for the scenes of the plot-methods, e.g. of Mesh.plot(), FieldContainer.plot() and SolidBody.plot(). set_plotting_backend(name) sets the current plotting backend by its name and get_plotting_backend() returns its name. The only built-in plotting backend is "pyvista" (default), i.e. the plots are unchanged. A custom plotting backend is a subclass of view.PlottingBackend, which implements is_plotter(plotter), prepare_plotter(plotter=None, **kwargs) and add_view(plotter, scene, **kwargs), registered by view.register_plotting_backend(name, backend). A plot without a given plotter is drawn by the current plotting backend. A plot with a given plotter, e.g. mesh.plot(plotter=other_mesh.plot()), is drawn by the plotting backend which recognizes the given plotter, i.e. a pyvista.Plotter is always drawn by PyVista. An unknown plotter is drawn by the current plotting backend (as before). The screenshots of the plot-methods, e.g. Mesh.screenshot() and Mesh.imshow(), are taken by PlottingBackend.screenshot(), which is supported by PyVista. A plotting backend without screenshots raises a NotImplementedError with a hint to the plotting backend "pyvista", before the scene is plotted. MeshContainer.screenshot() accepts a given plotter.
  • Add the optional primitives PlottingBackend.add_points(plotter, points, color=None, point_size=None, **kwargs), PlottingBackend.add_lines(plotter, lines, color=None, line_width=None, **kwargs) and PlottingBackend.add_arrows(plotter, points, directions, scale=1.0, color=None, **kwargs) of the plotting backends, which draw the decorations of a model. The points are given with up to three coordinates and the lines as start and end points of the line segments, lines.shape = (nlines, 2, dim). A plotting backend without a primitive raises a NotImplementedError with a hint to the plotting backend "pyvista". The plots of PointLoad, CylindricalConstraint, MultiPointConstraint, Boundary, the quadrature schemes (e.g. GaussLegendre) and the points of CartesianConstraint are drawn by the primitives of the plotting backend of the plotter. The lines of the plotting backend of PyVista have the properties of pyvista.Plotter.add_lines() (not lit, with edges in the color of the lines), also for the lines of MultiPointConstraint and the axis of CylindricalConstraint (before, these were lit). The lines of MultiPointConstraint are added as one mesh (before, one mesh per line). The images are unchanged, except for single pixels where the lines of a MultiPointConstraint overlap.
  • Add the optional primitives PlottingBackend.add_shape(plotter, shape, color=None, opacity=None, show_edges=None, **kwargs) and PlottingBackend.add_legend(plotter, entries=None, size=None, background_color=None, **kwargs) and the method PlottingBackend.default_color() (default: None) of the plotting backends. A shape is a plane, a rectangle, a cylinder or a cone of the internal module view._shapes, optionally clipped at the planes x[axis] = 0, whose method shape.triangulate() returns the points and the triangles of its (clipped) surface, independent of the plotting backend. The plotting backend of PyVista creates the shapes by its sources, e.g. pyvista.Cylinder, and clips them by PyVista (as before). The legend takes the given entries (label, color) or the labels of the primitives. The plots of ContactRigidPlane, ContactRigidCylinder, MultiPointContact, the symbols of the supports of CartesianConstraint and the legends of BoundaryDict.plot() and MeshContainer.plot() are drawn by the primitives of the plotting backend of the plotter. The default color of the first mesh of MeshContainer.plot() and MeshContainer.screenshot() is the default color of the plotting backend (the color of the theme of PyVista, as before). The lines of the rigid contact surfaces (in 2d) and of their axes or normals have the properties of the lines of the plotting backend of PyVista (not lit, with edges in the color of the lines). A fully clipped shape is not shown (before, PyVista raised a ValueError for an empty mesh). Element.plot() and Region.plot() require the plotting backend of PyVista, another plotting backend raises a NotImplementedError. AnimationWriterPlugin writes the frames by a plotter of PyVista, independent of the current plotting backend. The images are unchanged, except for four pixels at the end of the line of a clipped ContactRigidPlane in 2d.
  • Add the internal function view._surface.triangulate_surface(meshes, subdivisions=None), which returns the triangulated outer surface of one or more meshes with its edges, independent of PyVista, for the plotting backends, the dashboard and the web app. The values at the points of the meshes, e.g. the coordinates or the displacements, are interpolated to the points of the surface by a sparse matrix, i.e. surface.interpolate(values), with the shape functions of the finite elements of the cell types. Hence, the faces of quadratic and Lagrange cells are curved with more subdivisions (the number of segments per edge of a face, default: the polynomial order of the cells). The error of the area of a curved surface is of second order in the number of subdivisions. Each point of the surface exists only once, i.e. the corner points and the points on the edges are shared by the faces. The outer faces of three-dimensional cells (also at the interface of meshes with shared points), all two-dimensional cells and the line cells are supported for all cell types of FElupe and for wedges (interpolated linearly by their corner points). The triangles are oriented outwards and the cells of the triangles are given for the cell-data. The model of the dashboard is drawn by the same surface. The edges of the line cells are marked by the mask Surface.line_edges. Meshes with equal (but not the same) points-arrays share their points.
  • Add the plotting backend "webgl", which draws the plots by a dependency-free WebGL2 viewer in the web browser, without PyVista, e.g. fem.set_plotting_backend("webgl"). Its plotter view.WebGLPlotter() has the methods show(filename=None) and export_html(filename) and the property html, the self-contained HTML page of the viewer. Like with PyVista, the plotter is shown by show(): in a notebook, the self-contained HTML page of the viewer (the module, the styles and the scene with the binary arrays encoded by base64, i.e. it also works offline) is shown in the output of the cell (in an iframe), otherwise it is written to a file, which is opened in the web browser (without a given filename, a temporary file in the folder felupe of the temporary directory, where the pages older than a day are removed by the next temporary page). The viewer draws the outer surface of the meshes by view._surface.triangulate_surface() (with nonlinear_subdivision=k, the edges of the faces of quadratic and Lagrange cells are subdivided into order * 2 ** (k - 1) segments, i.e. the faces are curved for k > 1, with smooth shading and sharp edges), the deformed model with an undeformed model, point- and cell-data with a colormap of matplotlib (or the built-in colormap turbo) and a scalar bar, the edges of the faces, the decorations (points, lines, arrows, shapes and legends) and the axes. The faces of linear cells are shaded by a common normal (like polygons). Drag to rotate, shift-drag (or right-drag) to pan, scroll to zoom and double-click to reset the view. The colors follow the light or dark color scheme of the page. Screenshots and the plots of finite elements and regions are not supported. The options which are specific to PyVista, e.g. theme, scalar_bar_args, show_logo or other keyword-arguments of pyvista.Plotter.add_mesh() (except color, opacity, style and show_scalar_bar), raise a warning once and they are ignored. Add view._surface.polynomial_order(meshes) and the faces of the triangles Surface.faces and fix triangulate_surface() for meshes without cells.
  • Add the Jupyter widget of the WebGL viewer of the plotting backend "webgl", which is returned by view.WebGLPlotter.widget(height="480px"), e.g. to show it in a layout of widgets. The arrays of the scene are transferred as binary buffers (instead of base64-encoded in the HTML page). view.WebGLPlotter.show() still shows the self-contained HTML page in an iframe, which works in all frontends (also without a manager of widgets, e.g. in the interactive window of VS Code). The widget follows the theme of JupyterLab or VS Code. It requires the optional dependency anywidget by the new extra felupe[web] (also included in felupe[dashboard] and felupe[all]).
  • Draw the model of the DashboardWidgetPlugin by the WebGL viewer of the plotting backend "webgl" (before, by a canvas of its own), i.e. the plots and the dashboard share one viewer. The faces of quadratic and Lagrange cells are triangulated by all their points (e.g. by the mid-edge points) and they are shaded smoothly, the line cells (e.g. of a truss) are drawn as lines with the colors of their values. The view (rotation, zoom and pan) is kept for the next substeps and for a changed scale of the deformation. The wheel zooms only after a click into the view, otherwise it scrolls the page. The viewer supports values at the points of lines and points, colors in bands (the dashboard uses ten bands), an update of the scene with a kept view and the views of the buttons of the dashboard.
  • Add the plotting backend "matplotlib", which draws the plots on the axes of a figure of matplotlib, without PyVista, e.g. fem.set_plotting_backend("matplotlib"). Its plotter view.MatplotlibPlotter(ax=None, off_screen=False) has the methods show(), screenshot(filename=None, transparent_background=None, scale=None), savefig(), render(), enable_parallel_projection() and close() and the attributes figure and ax. The screenshots of the plot-methods, e.g. Mesh.screenshot(), SolidBody.screenshot() and BoundaryDict.screenshot(), are taken off-screen, i.e. without a display and without a figure of pyplot, and they return the image data like with PyVista. The format of the file is given by the suffix of its filename, i.e. a raster format (PNG) or a vector format (PDF, SVG or EPS) with a polygon for each visible face. Given (two-dimensional) axes of matplotlib are accepted as plotter, e.g. mesh.plot(plotter=ax) or boundaries.plot(plotter=ax), i.e. models may be combined with other plots in a figure with subplots; the scene on given axes is drawn whenever an object is added, i.e. the figure may be saved by fig.savefig(). The equal aspect ratio is kept by the box of the axes, i.e. a layout of the figure, e.g. by fig.tight_layout(), keeps the limits of the drawn scene. The outer surface of the meshes is triangulated by view._surface.triangulate_surface() and the (subdivided) faces are drawn as polygons with a flat color each (the two triangles of a quad are merged into a quad), in the order of their depths (painter's algorithm), with the same views, the same default view and the same lighting as the WebGL viewer (without specular highlights and normalized, i.e. faces towards the camera are drawn in their colors). The faces on the back of the closed surfaces of opaque solid bodies are not drawn (back-face culling) and the undeformed model is drawn behind (nearly) coincident faces of the deformed model. With nonlinear_subdivision=k, the edges of the faces are subdivided into order * 2 ** (k - 1) segments, also of linear cells (e.g. for smoother colors of point-data), and the faces of quadratic and Lagrange cells are curved for k > 1. The edges of the faces, the scalar bars (supported items of scalar_bar_args are "title", "vertical", "n_labels" and "fmt"), the decorations (points, lines, arrows, shapes and legends) and the axes are drawn. Planar models are drawn by a parallel projection, other models by a perspective projection. The plots of finite elements and regions are not supported. The options which are specific to PyVista, e.g. theme, show_logo or other keyword-arguments of pyvista.Plotter.add_mesh() (except color, opacity, style, lighting and show_scalar_bar), raise a warning once and they are ignored. The helpers of the WebGL backend which are independent of the plotting backend are moved to the internal modules view._shapes (outline(), arrow() and arrows()), view._scalars (surface_scalars()) and view._backends._notebook (in_kernel()).
  • Add the how-to guide Choose a Plotting Backend, which compares the plotting backends "pyvista", "webgl" and "matplotlib" (how they draw, interactivity, screenshots and optional dependencies), shows their usage, e.g. off-screen screenshots in vector formats and a model together with its force-displacement curve in one figure of matplotlib, how plots are combined by a given plotter and how a custom plotting backend is registered.
  • Add the attribute FieldContainer.slots=None, the indices of the fields of a top-level field container which belong to the fields of the field container, e.g. set by field.merge() if the fields of a field container are not the first fields of the top-level field container in the same order. FieldContainer.link() links the fields of a field container with slots to these fields of a top-level field container.
  • Add tools.embed(a, shape, field=None, x=None) to embed an assembled sparse vector or matrix of an item into the global degrees of freedom. It maps the degrees of freedom of a field container with slots and resizes the vector or matrix otherwise (like before). It is used by newtonraphson() (for the items) and by FreeVibration.
  • Add the time increment as an input of time-dependent materials, like the deformation gradient: umat.gradient(x, dtime=0.1) and umat.hessian(x, dtime=0.1). A material with a function (Material, Hyperelastic, MaterialAD, MaterialStrain and the materials of the JAX backend) is time-dependent if the function has an argument dtime without a default value which is not given as material parameter, e.g. Hyperelastic(finite_strain_viscoelastic, mu=1.0, eta=1.0, nstatevars=6), see the new attribute ConstitutiveMaterial.time_dependent. Materials which wrap other materials (NearlyIncompressible, ThreeFieldVariation, ThirdMediumContactMixed and composite materials) pass the time increment to their time-dependent materials. Materials of other packages are time-dependent by an attribute time_dependent=True. A missing time increment raises a ValueError, a time increment for a material which is not time-dependent a TypeError. A time increment which is given as material parameter, e.g. dtime=1.0, is still a constant, i.e. existing material definitions are unchanged.
  • Pass the time increment of SolidBody, SolidBodyNearlyIncompressible and TrussBody (new argument and attribute time_step=None) to their time-dependent materials. It is updated by a TimeStep with the (absolute) time in the ramp of a step, e.g. ramp={time: times, ...} with time = TimeStep(items=[solid]). Hence, the time drives viscoelastic materials, e.g. a hold step with a ramp of the time only, and the CutbackPlugin interpolates the time of subdivided substeps (before, each increment took the full constant time increment). The CutbackPlugin warns once if it subdivides a substep with a material with a constant time increment, e.g. dtime=1.0.
  • Add the (absolute) times to the load cases of time-dependent materials in view(), plot() and screenshot(), e.g. ux=[stretches, times], and in optimize(), e.g. ux=[stretches, forces, times], where the time increment is not fitted. A constant time increment of the material parameters, e.g. dtime=1.0, is not fitted by optimize() either (before, it was fitted like a material parameter).
  • Add the argument time=None to Job.evaluate() and XDMFWriterPlugin. With a time step item, e.g. job.evaluate(filename="result.xdmf", time=time), its (absolute) time is written as the time of the XDMF result file instead of the index of the substep, e.g. in Ex. 22. A time which is not greater than the time of the previous substep is written with a warning (once).
  • Add the how-to guide Define Time-Dependent Materials.

Changed

  • Add RuntimeError to the default exceptions of CutbackPlugin, i.e. exceptions=(NewtonConvergenceError, ArithmeticError, numpy.linalg.LinAlgError, RuntimeError). Hence, a failed factorization of a nearly singular matrix by solve.SuperLUSolver (default) or scipy.sparse.linalg.spsolve(), e.g. RuntimeError: failed to factorize matrix, leads to a cutback instead of a failed job. The subclasses NotImplementedError and RecursionError of RuntimeError are programming errors, which are still raised without a cutback (unless they are given explicitly).
  • Replace the arguments dUdJ and d2UdJdJ of NearlyIncompressible by the argument volumetric="volume-ratio" for the volumetric part of the strain energy density function, given by a kind with the bulk modulus or by an instance of VolumetricStrainEnergy (then, without the bulk modulus), i.e. NearlyIncompressible(material, bulk=None, parallel=None, volumetric="volume-ratio"). The attributes dUdJ and d2UdJdJ are removed, the volumetric part is provided by the attribute volumetric. The argument bulk is optional now (it is required for the kinds). The default results are bit-identical.
  • The default value of the argument return_loadcase of the loadcases dof.uniaxial(), dof.biaxial() and dof.shear() is False (before: None, deprecated since v10.0.0, which returned the loadcase dict), i.e. only the dict of boundaries is returned by default. Use boundaries, loadcase = fem.dof.uniaxial(field, return_loadcase=True) to get the loadcase dict. Unpacking the dict of boundaries raises a TypeError with a hint, e.g. boundaries, loadcase = fem.dof.uniaxial(field).
  • The argument plugins of Job and CharacteristicCurve is keyword-only, e.g. Job(steps, plugins=[...]). Before, it was the third positional argument of Job, after the removed callback.
  • Evaluate the in-plane values, gradients and Hessians of FieldPlaneStrain and FieldAxisymmetric by the methods of the base class Field, instead of copies of them (the private methods _interpolate_2d(), _grad_2d() and _hess_2d() are removed). The results are bit-identical. The argument out of the methods interpolate(), grad() and hess() of these fields is supported now: the in-plane components are evaluated into a view of the given output array and its out-of-plane components are overwritten. Before, out was ignored and a new array was returned. Hence, the kinematics of the solid bodies with plane strain or axisymmetric fields are evaluated into the arrays of the previous evaluation, like for three-dimensional fields.
  • The default tolerance of newtonraphson(..., tol=None) depends on the data types of the linear equation system and of the unknowns (before: tol=1.490e-8 for all data types). If None, the tolerance is the square root of the machine epsilon of the lowest precision of the linear equation system (the common data type of the Jacobian and the objective function) and of the unknowns (the data types of the values of all fields of a field container or the data type of an array), evaluated after the assembly of the Jacobian in the first iteration, e.g. 1.490e-8 for float64 (unchanged) and 3.453e-4 if the linear equation system or the unknowns are float32. Hence, a model with fields in single-precision (dtype=numpy.float32), on a region cast by Region.astype(numpy.float32) or on a region in double-precision, converges without a relaxed tolerance (before, the tolerance was not attainable in single-precision). The data type of the solution of the linear solver is not considered, i.e. a linear solver in single-precision for an equation system and unknowns in double-precision uses the tolerance of double-precision. A lower precision within the evaluation of the objective function, e.g. of a JAX-based material in single-precision, is not detected. The default tolerance also applies to Job.evaluate() and CharacteristicCurve.evaluate() without a given tolerance. If no tolerance is given, IterationState.tol is None in the hooks before_newton and before_iteration of the first iteration.
  • The default solver of newtonraphson(), Job.evaluate(), CharacteristicCurve.evaluate(), solve.solve() and project() is solve.SuperLUSolver() (before: scipy.sparse.linalg.spsolve()). The results are equal up to the round-off errors of the solutions of the linear equation systems. Use solver=scipy.sparse.linalg.spsolve to get the previous default solver. Note that spsolve() uses UMFPACK if scikit-umfpack is installed, solve.SuperLUSolver() does not.
  • Separate the data of the views from their plots by PyVista, as a first step towards plotting backends. ViewMesh, ViewField and ViewSolid keep the mesh and the results by the new attributes points, cells, cell_type, point_data and cell_data. Their attribute mesh, the pyvista.UnstructuredGrid with the point- and cell-data, is created on first access (before, by the constructor), i.e. a view is created without PyVista, e.g. to evaluate the point- and cell-data. A given grid may still be assigned to mesh. The PyVista-related code of Scene.plot() is moved to the internal class view._backends.PyVistaBackend and the labels of the scalar bar are created by the internal module view._scalars, which are independent of PyVista. The plots are unchanged, i.e. the rendered images of the tests are pixel-identical. Like before, the grid references the arrays of the point- and cell-data. The points of the mesh are taken on first access of mesh (before, at the creation of the view), which matters only if the points of the mesh are modified in-between. Mesh.as_unstructured_grid() uses the same internal conversion of the points and cells.
  • Merge mixed field containers by field.merge(fields) and FieldContainer.merge(), e.g. a displacement field of one body and FieldsMixed of other bodies, also with different mixed formulations (e.g. Q1/P0, Q2/P0, Taylor-Hood or MINI), a different number of fields per body or the fields of ThirdMediumContactMixed of third media next to ThreeFieldVariation or SolidBodyNearlyIncompressible bodies. The first fields (e.g. the displacements) of all field containers are merged (their points are merged), they must be of the same type and dimension. All other fields belong to their field container (body), e.g. dual fields or the tensor-valued field of a third medium: they are appended to the top-level field container (as vertex fields), i.e. they are not coupled across the bodies, and their regions and meshes are not modified. The offsets and the number of points of the dual meshes (FieldsMixed(..., offset, npoints, mesh)) and a top-level mixed field container are no longer created manually. The values of all fields are linked to the top-level field container, i.e. its initial values are taken from the given fields (e.g. a volume ratio of one). Before, field containers with more than one field raised a TypeError.
  • Group the how-to guides of the documentation by topic (build a model, define materials, evaluate a job, process results and extend FElupe) and rename their titles to consistent imperatives, e.g. Set up Mixed-Field Problems or Define Strain-Based Materials. The URLs of the guides are unchanged.
  • Set up the solid bodies of the how-to guide Combine Multiple Solid Bodies by field.merge() (before, by a manually merged mesh container, a top-level field on its points and x0=field in Job.evaluate()), i.e. the displacement fields and the mixed-field formulations of the guide are merged in the same way.
  • Move thermal.TimeStep to the mechanics module, also available as fem.TimeStep (thermal.TimeStep is the same class). It updates the attribute time_step of any item and it doesn't have to be the first item of a step.
  • Change the state variables of finite_strain_viscoelastic() to initially all-zero values (the deviation of the inelastic right Cauchy-Green deformation tensor from the identity), which supports a time increment of zero. Its second argument is renamed from Cin to statevars.
  • Change Ex. 18 to the time increment as input, which supports time increments of zero and fixes the time increment of the unloading path, and to the consistent tangent (the linearization of the internal variable by the implicit function theorem; before, the Newton-Raphson iterations converged only linearly).
  • Require tensortrax>=0.30.0 for felupe[autodiff], which provides tensortrax.math.no_variation() for finite_strain_viscoelastic(), ogden_roxburgh() (unchanged results) and Ex. 18.
  • Rename the argument Δt of linear_elastic_viscoelastic() to dtime (a material parameter Δt of MaterialStrain is still taken as dtime, but it is deprecated, see below). A time increment of zero takes the limit b_i = 2 G_i of the effective shear moduli (before: NaN).
  • Update the actions of the workflows to their current major versions, which run on Node.js 24 (actions/checkout@v7, actions/setup-python@v7, actions/cache@v6 and codecov/codecov-action@v7). The versions before ran on Node.js 20, which is deprecated on the runners of GitHub Actions.

Deprecated

  • Deprecate the material parameter Δt of MaterialStrain, the former name of the time increment dtime of linear_elastic_viscoelastic(). It is still taken as dtime (for a material model formulation with an argument dtime and without an argument Δt), but it emits a DeprecationWarning, which is attributed to the line of the code of the user. It will be removed in v13.0.0. Use dtime instead, e.g. MaterialStrain(linear_elastic_viscoelastic, λ=λ, μ=μ, G=G, τ=τ, dtime=0.5, statevars=...) instead of MaterialStrain(linear_elastic_viscoelastic, λ=λ, μ=μ, G=G, τ=τ, Δt=0.5, statevars=...). Without a material parameter dtime, the material is time-dependent, i.e. the time increment is an input of the material.

Removed

  • Remove the argument callback of Job and CharacteristicCurve and its keyword-arguments **kwargs (deprecated since v11.3.0). Use a callable plugin instead, which is called after each completed substep with the same arguments, e.g. Job(steps, callback=callback, a=1) is replaced by Job(steps, plugins=[lambda context, state: callback(state.stepnumber, state.substepnumber, context.substep, a=1)]), see the notes of Job. Unknown keyword-arguments of a job, e.g. a typo of plugins, raise a TypeError (before, they were passed to the callback).
  • Remove the argument callback of newtonraphson() (deprecated since v11.3.0), which was also passed by Job.evaluate(callback=callback). Use a plugin with the hook after_iteration instead, e.g. newtonraphson(..., plugins=[NewtonCallback()]) or Job(steps, plugins=[NewtonCallback()]) with class NewtonCallback(Plugin): def after_iteration(self, context, state): callback(state.dx, state.x, state.iteration, state.xnorm, state.fnorm, state.success), see the notes of newtonraphson().
  • Remove the unused arguments progress_bar and callback_kwargs of newtonraphson() (deprecated since v11.3.0).
  • Remove newtonrhapson() and tools.newtonrhapson() (deprecated since v10.2.0). Use newtonraphson() and tools.newtonraphson().
  • Remove the argument bounds of dof.symmetry() (deprecated since v10.0.0). Use boundaries.
  • Remove the support of Python 3.10, which reaches its end of life in October 2026. The minimum version of Python is 3.11. The tests run on Python 3.11 and 3.14.
  • Remove the private aliases mesh._cube_hexa, mesh._line_line and mesh._rectangle_quad from the namespace of felupe.mesh (they were listed in __all__, i.e. exported by from felupe.mesh import *). They were not used. The public meshes are Line, Rectangle and Cube.
  • Remove the private attributes FieldDual.__args__ and FieldDual.__kwargs__, which stored the arguments of a dual field to re-create it in a former version of FieldContainer.merge(). They are not used anymore, i.e. a dual field doesn't keep a reference to the region of the primary field anymore.

Fixed

  • Fix the plot of a quadrature scheme with negative weights, e.g. of TriangleQuadrature(order=3) or TetrahedronQuadrature(order=3), by Scheme.plot(weighted=True), which failed with a negative point size. The size of a point is scaled by the magnitude of its weight (relative to the largest magnitude of the weights) and the points with negative weights are drawn in red.
  • Fix the argument solver of project(), which was ignored. The linear equation system of the projection was always solved by scipy.sparse.linalg.spsolve().
  • Don't trim the assembled matrices of the items in FreeVibration, which have more degrees of freedom than the global field container. A ValueError is raised instead, like in newtonraphson().
  • Fix FreeVibration.evaluate(sigma=...), which raised a TypeError because the shift sigma was passed twice to the solver. The default shift is still sigma=0.
  • Fix the default field container of FreeVibration.evaluate(x0=None): like in Job, the top-level field container x0 of the field container of the first item is used, e.g. of merged field containers (before, the field container of the first item, which raised an IndexError for merged mixed field containers). FreeVibration.extract(x0=None) uses the field container of FreeVibration.evaluate() by default.
  • Fix the stress and the tangent of finite_strain_viscoelastic(): the updated state variables are constant in the variation but not in the linearization (tensortrax.math.no_variation()). Before, the stress also included the dependence of the updated state variables, i.e. it was scaled by approximately 1 / (1 + mu * dtime / eta).
  • Broadcast the trailing (batch) axes of the left- and the right-hand side in math.solve_nd() and math.solve_2d(), e.g. a right-hand side with additional axes for the dual values of a linearization (before, trailing axes of different shapes raised an error).
  • Scale the mass matrix of an item by its multiplier in FreeVibration, e.g. of SolidBody(..., multiplier=2.0) (before, only the stiffness matrix was scaled), i.e. the multiplier scales the contribution of the item.
  • Fix revolve() of SolidBody and SolidBodyNearlyIncompressible for state variables, e.g. of a viscoelastic material (before, a ValueError for state variables with a non-zero first dimension).
  • Fix the viscoelastic templates in the docstrings of the materials of tensortrax and JAX: the second Piola-Kirchhoff stress is S = mu * inv(C) @ dev(Cu @ inv(Ci)) (before, dev(Cu @ inv(Ci)) @ inv(C), which is only correct if C and Ci commute), the state variables are initially zero and the template of jax.Hyperelastic returns the incremental potential, i.e. its gradient is the stress at fixed state variables.
  • Fix ConstitutiveMaterial.optimize(): the predicted and the observed forces are paired in the same order of the load cases (before, planar shear data was ignored or compared to biaxial data and ps alone failed) and the material parameters are also set on the attributes and on the materials of a material (before, the fit had no effect, e.g. for NeoHooke, LinearElastic, OgdenRoxburgh and composite materials).
  • Fix the XDMFWriterPlugin as plugin of a job without the argument kwargs (before, an AttributeError was raised).

What's Changed

  • Set the version to 12.0.0-dev and remove the deprecated features by @adtzlr in #1186
  • Evaluate the plane strain and axisymmetric fields by the methods of Field by @adtzlr in #1187
  • Set the minimum version of Python to 3.11 by @adtzlr in #1188
  • Replace the license notices by SPDX license identifiers by @adtzlr in #1189
  • Write the result files of the tests to temporary directories by @adtzlr in #1190
  • Run the tests in parallel and cache the compiled functions of JAX by @adtzlr in #1191
  • Don't run the examples in the docs builds of pull requests by @adtzlr in #1192
  • Shorten two slow tests without changing the coverage by @adtzlr in #1193
  • Coarsen the example of CylindricalConstraint by @adtzlr in #1194
  • Add SolidBodyNearlyIncompressible(..., volumetric_kind="linear") by @adtzlr in #1195
  • Rename the volumetric kinds and add SolidBodyNearlyIncompressible(..., volumetric_kind="stretch") by @adtzlr in #1196
  • Add VolumetricStrainEnergy and use it in SolidBodyNearlyIncompressible by @adtzlr in #1197
  • Add the argument volumetric to NeoHooke, Volumetric and SolidBodyNearlyIncompressible by @adtzlr in #1198
  • Replace the callables of NearlyIncompressible by the argument volumetric by @adtzlr in #1199
  • Derive the default tolerance of newtonraphson() from the data types by @adtzlr in #1201
  • Add solve.SuperLUSolver and use it as the default solver by @adtzlr in #1202
  • Add RuntimeError to the default exceptions of CutbackPlugin by @adtzlr in #1203
  • Add DashboardWidgetPlugin, a live dashboard of a job in a Jupyter widget by @adtzlr in #1204
  • Add a static snapshot of the dashboard and show it in example 06 by @adtzlr in #1205
  • Show 3d-models in the dashboard with the z-axis upwards by @adtzlr in #1206
  • Add the how-to guide "Use Plugins" by @adtzlr in #1207
  • Separate the data of the views from their plots by PyVista by @adtzlr in #1208
  • Add selectable plotting backends by @adtzlr in #1209
  • Draw the decorations by the primitives of the plotting backends by @adtzlr in #1210
  • Draw shapes and legends by the plotting backends by @adtzlr in #1211
  • Add a triangulated outer surface of meshes independent of PyVista by @adtzlr in #1212
  • Add the plotting backend "webgl" by @adtzlr in #1213
  • Show the WebGL viewer as a Jupyter widget by @adtzlr in #1214
  • Draw the model of the dashboard by the WebGL viewer by @adtzlr in #1215
  • Fix the weighted plot of quadratures with negative weights by @adtzlr in #1216
  • Add the plotting backend "matplotlib" by @adtzlr in #1217
  • Add the how-to guide "Choose a Plotting Backend" by @adtzlr in #1218
  • Merge mixed field containers in field.merge() by @adtzlr in #1219
  • Remove the private attributes FieldDual.__args__ and __kwargs__ by @adtzlr in #1221
  • Fix sigma, the default x0 and the multiplier of FreeVibration by @adtzlr in #1222
  • Group the how-to guides by topic by @adtzlr in #1223
  • Use field.merge() in the how-to guide of multiple solid bodies by @adtzlr in #1224
  • Factorize without pivoting by default in SuperLUSolver, with a check of the backward error and a fallback by @adtzlr in #1225
  • Perturb the zero diagonal entries of saddle point problems in SuperLUSolver (static pivoting) by @adtzlr in #1226
  • Use small relaxed supernodes by default in SuperLUSolver (relax=2) by @adtzlr in #1227
  • Move TimeStep to the mechanics module by @adtzlr in #1228
  • Add the time increment dtime as an input of time-dependent materials by @adtzlr in #1229
  • Pass the time increment through wrapper materials by @adtzlr in #1230
  • Pass the time increment of the solid bodies to time-dependent materials by @adtzlr in #1231
  • Fix time=0 for time-dependent material models by @adtzlr in #1233
  • Fix revolve() of solid bodies with state variables by @adtzlr in #1234
  • Add the time increment dtime as an input of JAX materials by @adtzlr in #1235
  • Add the time increment dtime as an input of strain-based materials by @adtzlr in #1236
  • Add the times of the load cases of time-dependent materials by @adtzlr in #1237
  • Fix the load cases and the material parameters of optimize() by @adtzlr in #1238
  • Document time-dependent materials with the time as input by @adtzlr in #1239
  • Keep a constant dtime out of optimize() and warn on cutbacks by @adtzlr in #1240
  • Write the time of a TimeStep to XDMF result files by @adtzlr in #1241
  • Remove unused files by @adtzlr in #1242
  • Drop the default argument return_loadcase=False of the loadcases by @adtzlr in #1243
  • Fix stale references to the removed callback and to old PyVista versions by @adtzlr in #1244
  • Remove the private aliases of the meshes from felupe.mesh by @adtzlr in #1245
  • Update the actions of the workflows to Node.js 24 by @adtzlr in #1246
  • Deprecate the material parameter Δt of MaterialStrain by @adtzlr in #1247
  • Document the plotter of the plotting backend "webgl" by @adtzlr in #1248
  • Release 12.0.0 by @adtzlr in #1249

Full Changelog: v11.3.0...v12.0.0