Repository navigation
v12.0.0
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 byview.WebGLPlotter.export_html(). In a notebook it is shown in the output of the cell, or as a Jupyter widget bywidget()(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 byview.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.spsolverestores the previous default solver, e.g. inJob.evaluate(). Note thatspsolve()uses UMFPACK ifscikit-umfpackis installed,solve.SuperLUSolver()does not. CutbackPluginalso catches aRuntimeErrorby default, i.e. a failed factorization of a nearly singular matrix leads to a cutback instead of a failed job.thermal.TimeStepis moved to the mechanics module,fem.TimeStep(thermal.TimeStepis the same class). It updates any item and doesn't have to be the first item of a step.- The attribute
meshofViewMesh,ViewFieldandViewSolid, thepyvista.UnstructuredGrid, is created on first access, i.e. a view is created without PyVista. felupe[autodiff]requirestensortrax>=0.30.0.- Private attributes and aliases are removed:
FieldDual.__args__and__kwargs__,mesh._cube_hexa,mesh._line_lineandmesh._rectangle_quad.
🗑️ Deprecated
- The material parameter
ΔtofMaterialStrain, the former name of the time increment oflinear_elastic_viscoelastic(). It will be removed in 13.0.0. Usedtimeinstead.
🐞 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. forNeoHooke,LinearElastic,OgdenRoxburghand composite materials).FreeVibration: the shiftsigma(raised aTypeError), 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.XDMFWriterPluginwithout the argumentkwargs.Scheme.plot(weighted=True)of quadrature schemes with negative weights.math.solve_nd()andmath.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 aCutbackPlugin, 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 aMeshContainer, and the values are taken from the first field of the unknownsx0of 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. ofSolidBody.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 dependencyanywidget(pip install felupe[dashboard], also included infelupe[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 bysnapshot.save("job.html"). WithDashboardWidgetPlugin(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 everyfile_intervalseconds (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
SolidBodyNearlyIncompressiblewith the new argumentSolidBodyNearlyIncompressible(..., 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 ofVolumetricStrainEnergy(then, without the bulk modulus). The built-in kinds are quadratic in the Seth-Hill strainE_m = (λ^m - 1) / mof the volumetric stretchλ = J^(1/3), i.e.U(J) = 9K/2 E_m^2:"volume-ratio"forU(J) = K (J - 1)^2 / 2(m=3, default, as before),"stretch"forU(J) = 9K (J^(1/3) - 1)^2 / 2(m=1) and"log"forU(J) = K ln(J)^2 / 2(limit m → 0). The argumentbulk=Noneis 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 aValueError. - Add
VolumetricStrainEnergy(bulk, kind="volume-ratio"), the volumetric part of the strain energy density function as a function of the volume ratio. An instanceUis callable, i.e.U(J),U.dUdJ(J)andU.d2UdJdJ(J)return the function and its first and second derivatives, for the kinds"volume-ratio","stretch"and"log". Unlike aConstitutiveMaterial, it is evaluated by the volume ratioJ, not by the deformation gradient. A custom volumetric part is a subclass which implements__call__(J),dUdJ(J)andd2UdJdJ(J). It is used byNeoHooke,Volumetric,NearlyIncompressibleandSolidBodyNearlyIncompressible, which provide it by the attributevolumetric. - Add the argument
volumetric="volume-ratio"toNeoHooke(mu=None, bulk=None, parallel=False, volumetric="volume-ratio")andVolumetric(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 ofVolumetricStrainEnergy(then, without the bulk modulus), e.g.NeoHooke(mu=1, bulk=5000, volumetric="stretch"). The default results are bit-identical. Without the bulk modulus,NeoHookehas no volumetric part (as before). The argumentbulkofVolumetricis 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 byscipy.sparse.linalg.splu()with options tuned for the (structurally) symmetric matrices of the finite element method. An instance is a solver functionx = solver(A, b), e.g.Job.evaluate(solver=fem.solve.SuperLUSolver()). The symmetric mode of SuperLU with the minimum degree ordering of the structure ofA^T + Arequires 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 aMultiPointConstraintor aContactRigidPlane, do not lead to pivoting, which would increase the fill-in and the time of the factorization by orders of magnitude, e.g. aThreeFieldVariationof 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 ofThreeFieldVariationandNearlyIncompressible(onFieldsMixed) or of a mixed weak form byForm, 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 entriesA_ii = 0are perturbed before the factorization (static pivoting, like PARDISO) by-ε Σ_j A_ji² / |A_jj|(sum over the rowsjwith non-zero diagonal entries), i.e. by the relative perturbationε(the argumentdiag_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 bySuperLUSolver.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 thresholdfallback_pivot_thresh, e.g. for an exactly singular matrix. Withdiag_perturbation=0orrefine=False, the zero diagonal entries are not perturbed. E.g., an incompressible mixed u/p-formulation byFormwith 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 bySuperLUSolver.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 tolerancetol(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 thresholdfallback_pivot_thresh. Withfallback_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 toscipy.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 torelax=20. The size of the panels (panel_size=20, the default of SuperLU) has no significant influence. Likespsolve(), a single right-hand side returns a 1d-array and an exactly singular matrix emits aMatrixRankWarningand returns NaN values. Multiple right-hand sides and sparse right-hand sides are supported. The LU decomposition is available bySuperLUSolver.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
Joband the built-in plugins (ProgressPlugin,XDMFWriterPlugin,CharacteristicCurvePlugin,AnimationWriterPlugin,DashboardWidgetPlugin,LinesearchPluginandCutbackPlugin), how plugins are combined and how a custom plugin is written by a subclass ofPluginor by a callable. - Add selectable plotting backends for the scenes of the plot-methods, e.g. of
Mesh.plot(),FieldContainer.plot()andSolidBody.plot().set_plotting_backend(name)sets the current plotting backend by its name andget_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 ofview.PlottingBackend, which implementsis_plotter(plotter),prepare_plotter(plotter=None, **kwargs)andadd_view(plotter, scene, **kwargs), registered byview.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. apyvista.Plotteris 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()andMesh.imshow(), are taken byPlottingBackend.screenshot(), which is supported by PyVista. A plotting backend without screenshots raises aNotImplementedErrorwith 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)andPlottingBackend.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 aNotImplementedErrorwith a hint to the plotting backend"pyvista". The plots ofPointLoad,CylindricalConstraint,MultiPointConstraint,Boundary, the quadrature schemes (e.g.GaussLegendre) and the points ofCartesianConstraintare drawn by the primitives of the plotting backend of the plotter. The lines of the plotting backend of PyVista have the properties ofpyvista.Plotter.add_lines()(not lit, with edges in the color of the lines), also for the lines ofMultiPointConstraintand the axis ofCylindricalConstraint(before, these were lit). The lines ofMultiPointConstraintare added as one mesh (before, one mesh per line). The images are unchanged, except for single pixels where the lines of aMultiPointConstraintoverlap. - Add the optional primitives
PlottingBackend.add_shape(plotter, shape, color=None, opacity=None, show_edges=None, **kwargs)andPlottingBackend.add_legend(plotter, entries=None, size=None, background_color=None, **kwargs)and the methodPlottingBackend.default_color()(default: None) of the plotting backends. A shape is a plane, a rectangle, a cylinder or a cone of the internal moduleview._shapes, optionally clipped at the planesx[axis] = 0, whose methodshape.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 ofContactRigidPlane,ContactRigidCylinder,MultiPointContact, the symbols of the supports ofCartesianConstraintand the legends ofBoundaryDict.plot()andMeshContainer.plot()are drawn by the primitives of the plotting backend of the plotter. The default color of the first mesh ofMeshContainer.plot()andMeshContainer.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 aValueErrorfor an empty mesh).Element.plot()andRegion.plot()require the plotting backend of PyVista, another plotting backend raises aNotImplementedError.AnimationWriterPluginwrites 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 clippedContactRigidPlanein 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 maskSurface.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 plotterview.WebGLPlotter()has the methodsshow(filename=None)andexport_html(filename)and the propertyhtml, the self-contained HTML page of the viewer. Like with PyVista, the plotter is shown byshow(): 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 aniframe), otherwise it is written to a file, which is opened in the web browser (without a given filename, a temporary file in the folderfelupeof 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 byview._surface.triangulate_surface()(withnonlinear_subdivision=k, the edges of the faces of quadratic and Lagrange cells are subdivided intoorder * 2 ** (k - 1)segments, i.e. the faces are curved fork > 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_logoor other keyword-arguments ofpyvista.Plotter.add_mesh()(exceptcolor,opacity,styleandshow_scalar_bar), raise a warning once and they are ignored. Addview._surface.polynomial_order(meshes)and the faces of the trianglesSurface.facesand fixtriangulate_surface()for meshes without cells. - Add the Jupyter widget of the WebGL viewer of the plotting backend
"webgl", which is returned byview.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 aniframe, 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 extrafelupe[web](also included infelupe[dashboard]andfelupe[all]). - Draw the model of the
DashboardWidgetPluginby 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 plotterview.MatplotlibPlotter(ax=None, off_screen=False)has the methodsshow(),screenshot(filename=None, transparent_background=None, scale=None),savefig(),render(),enable_parallel_projection()andclose()and the attributesfigureandax. The screenshots of the plot-methods, e.g.Mesh.screenshot(),SolidBody.screenshot()andBoundaryDict.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)orboundaries.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 byfig.savefig(). The equal aspect ratio is kept by the box of the axes, i.e. a layout of the figure, e.g. byfig.tight_layout(), keeps the limits of the drawn scene. The outer surface of the meshes is triangulated byview._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. Withnonlinear_subdivision=k, the edges of the faces are subdivided intoorder * 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 fork > 1. The edges of the faces, the scalar bars (supported items ofscalar_bar_argsare"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_logoor other keyword-arguments ofpyvista.Plotter.add_mesh()(exceptcolor,opacity,style,lightingandshow_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 modulesview._shapes(outline(),arrow()andarrows()),view._scalars(surface_scalars()) andview._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 byfield.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 bynewtonraphson()(for the items) and byFreeVibration. - Add the time increment as an input of time-dependent materials, like the deformation gradient:
umat.gradient(x, dtime=0.1)andumat.hessian(x, dtime=0.1). A material with a function (Material,Hyperelastic,MaterialAD,MaterialStrainand the materials of the JAX backend) is time-dependent if the function has an argumentdtimewithout 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 attributeConstitutiveMaterial.time_dependent. Materials which wrap other materials (NearlyIncompressible,ThreeFieldVariation,ThirdMediumContactMixedand composite materials) pass the time increment to their time-dependent materials. Materials of other packages are time-dependent by an attributetime_dependent=True. A missing time increment raises aValueError, a time increment for a material which is not time-dependent aTypeError. 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,SolidBodyNearlyIncompressibleandTrussBody(new argument and attributetime_step=None) to their time-dependent materials. It is updated by aTimeStepwith the (absolute) time in the ramp of a step, e.g.ramp={time: times, ...}withtime = TimeStep(items=[solid]). Hence, the time drives viscoelastic materials, e.g. a hold step with a ramp of the time only, and theCutbackPlugininterpolates the time of subdivided substeps (before, each increment took the full constant time increment). TheCutbackPluginwarns 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()andscreenshot(), e.g.ux=[stretches, times], and inoptimize(), 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 byoptimize()either (before, it was fitted like a material parameter). - Add the argument
time=NonetoJob.evaluate()andXDMFWriterPlugin. 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
RuntimeErrorto the default exceptions ofCutbackPlugin, i.e.exceptions=(NewtonConvergenceError, ArithmeticError, numpy.linalg.LinAlgError, RuntimeError). Hence, a failed factorization of a nearly singular matrix bysolve.SuperLUSolver(default) orscipy.sparse.linalg.spsolve(), e.g.RuntimeError: failed to factorize matrix, leads to a cutback instead of a failed job. The subclassesNotImplementedErrorandRecursionErrorofRuntimeErrorare programming errors, which are still raised without a cutback (unless they are given explicitly). - Replace the arguments
dUdJandd2UdJdJofNearlyIncompressibleby the argumentvolumetric="volume-ratio"for the volumetric part of the strain energy density function, given by a kind with the bulk modulus or by an instance ofVolumetricStrainEnergy(then, without the bulk modulus), i.e.NearlyIncompressible(material, bulk=None, parallel=None, volumetric="volume-ratio"). The attributesdUdJandd2UdJdJare removed, the volumetric part is provided by the attributevolumetric. The argumentbulkis optional now (it is required for the kinds). The default results are bit-identical. - The default value of the argument
return_loadcaseof the loadcasesdof.uniaxial(),dof.biaxial()anddof.shear()isFalse(before:None, deprecated since v10.0.0, which returned the loadcase dict), i.e. only the dict of boundaries is returned by default. Useboundaries, loadcase = fem.dof.uniaxial(field, return_loadcase=True)to get the loadcase dict. Unpacking the dict of boundaries raises aTypeErrorwith a hint, e.g.boundaries, loadcase = fem.dof.uniaxial(field). - The argument
pluginsofJobandCharacteristicCurveis keyword-only, e.g.Job(steps, plugins=[...]). Before, it was the third positional argument ofJob, after the removedcallback. - Evaluate the in-plane values, gradients and Hessians of
FieldPlaneStrainandFieldAxisymmetricby the methods of the base classField, instead of copies of them (the private methods_interpolate_2d(),_grad_2d()and_hess_2d()are removed). The results are bit-identical. The argumentoutof the methodsinterpolate(),grad()andhess()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,outwas 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-8for 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-8forfloat64(unchanged) and3.453e-4if the linear equation system or the unknowns arefloat32. Hence, a model with fields in single-precision (dtype=numpy.float32), on a region cast byRegion.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 toJob.evaluate()andCharacteristicCurve.evaluate()without a given tolerance. If no tolerance is given,IterationState.tolis None in the hooksbefore_newtonandbefore_iterationof the first iteration. - The default solver of
newtonraphson(),Job.evaluate(),CharacteristicCurve.evaluate(),solve.solve()andproject()issolve.SuperLUSolver()(before:scipy.sparse.linalg.spsolve()). The results are equal up to the round-off errors of the solutions of the linear equation systems. Usesolver=scipy.sparse.linalg.spsolveto get the previous default solver. Note thatspsolve()uses UMFPACK ifscikit-umfpackis installed,solve.SuperLUSolver()does not. - Separate the data of the views from their plots by PyVista, as a first step towards plotting backends.
ViewMesh,ViewFieldandViewSolidkeep the mesh and the results by the new attributespoints,cells,cell_type,point_dataandcell_data. Their attributemesh, thepyvista.UnstructuredGridwith 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 tomesh. The PyVista-related code ofScene.plot()is moved to the internal classview._backends.PyVistaBackendand the labels of the scalar bar are created by the internal moduleview._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 ofmesh(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)andFieldContainer.merge(), e.g. a displacement field of one body andFieldsMixedof 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 ofThirdMediumContactMixedof third media next toThreeFieldVariationorSolidBodyNearlyIncompressiblebodies. 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 aTypeError. - 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 andx0=fieldinJob.evaluate()), i.e. the displacement fields and the mixed-field formulations of the guide are merged in the same way. - Move
thermal.TimeStepto the mechanics module, also available asfem.TimeStep(thermal.TimeStepis the same class). It updates the attributetime_stepof 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 fromCintostatevars. - 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.0forfelupe[autodiff], which providestensortrax.math.no_variation()forfinite_strain_viscoelastic(),ogden_roxburgh()(unchanged results) and Ex. 18. - Rename the argument
Δtoflinear_elastic_viscoelastic()todtime(a material parameterΔtofMaterialStrainis still taken asdtime, but it is deprecated, see below). A time increment of zero takes the limitb_i = 2 G_iof 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@v6andcodecov/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
ΔtofMaterialStrain, the former name of the time incrementdtimeoflinear_elastic_viscoelastic(). It is still taken asdtime(for a material model formulation with an argumentdtimeand without an argumentΔt), but it emits aDeprecationWarning, which is attributed to the line of the code of the user. It will be removed in v13.0.0. Usedtimeinstead, e.g.MaterialStrain(linear_elastic_viscoelastic, λ=λ, μ=μ, G=G, τ=τ, dtime=0.5, statevars=...)instead ofMaterialStrain(linear_elastic_viscoelastic, λ=λ, μ=μ, G=G, τ=τ, Δt=0.5, statevars=...). Without a material parameterdtime, the material is time-dependent, i.e. the time increment is an input of the material.
Removed
- Remove the argument
callbackofJobandCharacteristicCurveand 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 byJob(steps, plugins=[lambda context, state: callback(state.stepnumber, state.substepnumber, context.substep, a=1)]), see the notes ofJob. Unknown keyword-arguments of a job, e.g. a typo ofplugins, raise aTypeError(before, they were passed to the callback). - Remove the argument
callbackofnewtonraphson()(deprecated since v11.3.0), which was also passed byJob.evaluate(callback=callback). Use a plugin with the hookafter_iterationinstead, e.g.newtonraphson(..., plugins=[NewtonCallback()])orJob(steps, plugins=[NewtonCallback()])withclass NewtonCallback(Plugin): def after_iteration(self, context, state): callback(state.dx, state.x, state.iteration, state.xnorm, state.fnorm, state.success), see the notes ofnewtonraphson(). - Remove the unused arguments
progress_barandcallback_kwargsofnewtonraphson()(deprecated since v11.3.0). - Remove
newtonrhapson()andtools.newtonrhapson()(deprecated since v10.2.0). Usenewtonraphson()andtools.newtonraphson(). - Remove the argument
boundsofdof.symmetry()(deprecated since v10.0.0). Useboundaries. - 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_lineandmesh._rectangle_quadfrom the namespace offelupe.mesh(they were listed in__all__, i.e. exported byfrom felupe.mesh import *). They were not used. The public meshes areLine,RectangleandCube. - Remove the private attributes
FieldDual.__args__andFieldDual.__kwargs__, which stored the arguments of a dual field to re-create it in a former version ofFieldContainer.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)orTetrahedronQuadrature(order=3), byScheme.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
solverofproject(), which was ignored. The linear equation system of the projection was always solved byscipy.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. AValueErroris raised instead, like innewtonraphson(). - Fix
FreeVibration.evaluate(sigma=...), which raised aTypeErrorbecause the shiftsigmawas passed twice to the solver. The default shift is stillsigma=0. - Fix the default field container of
FreeVibration.evaluate(x0=None): like inJob, the top-level field containerx0of 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 anIndexErrorfor merged mixed field containers).FreeVibration.extract(x0=None)uses the field container ofFreeVibration.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 approximately1 / (1 + mu * dtime / eta). - Broadcast the trailing (batch) axes of the left- and the right-hand side in
math.solve_nd()andmath.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. ofSolidBody(..., multiplier=2.0)(before, only the stiffness matrix was scaled), i.e. the multiplier scales the contribution of the item. - Fix
revolve()ofSolidBodyandSolidBodyNearlyIncompressiblefor state variables, e.g. of a viscoelastic material (before, aValueErrorfor 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 ifCandCicommute), the state variables are initially zero and the template ofjax.Hyperelasticreturns 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 andpsalone 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. forNeoHooke,LinearElastic,OgdenRoxburghand composite materials). - Fix the
XDMFWriterPluginas plugin of a job without the argumentkwargs(before, anAttributeErrorwas 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
VolumetricStrainEnergyand use it inSolidBodyNearlyIncompressibleby @adtzlr in #1197 - Add the argument
volumetrictoNeoHooke,VolumetricandSolidBodyNearlyIncompressibleby @adtzlr in #1198 - Replace the callables of
NearlyIncompressibleby the argumentvolumetricby @adtzlr in #1199 - Derive the default tolerance of
newtonraphson()from the data types by @adtzlr in #1201 - Add
solve.SuperLUSolverand 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 defaultx0and the multiplier ofFreeVibrationby @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
TimeStepto the mechanics module by @adtzlr in #1228 - Add the time increment
dtimeas 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=0for time-dependent material models by @adtzlr in #1233 - Fix
revolve()of solid bodies with state variables by @adtzlr in #1234 - Add the time increment
dtimeas an input of JAX materials by @adtzlr in #1235 - Add the time increment
dtimeas 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
dtimeout ofoptimize()and warn on cutbacks by @adtzlr in #1240 - Write the time of a
TimeStepto XDMF result files by @adtzlr in #1241 - Remove unused files by @adtzlr in #1242
- Drop the default argument
return_loadcase=Falseof 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.meshby @adtzlr in #1245 - Update the actions of the workflows to Node.js 24 by @adtzlr in #1246
- Deprecate the material parameter
ΔtofMaterialStrainby @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