finite element analysis for continuum mechanics of solid bodies
GPL-3.0 License
Region.astype(dtype=None)
to copy and cast the region arrays to a specified type.Field(..., dtype=None)
to cast the array with field values to a specified type.Field.extract(dtype=None)
to cast the extracted field gradient/interpolated values to a specified type.hello_world()
to print the lines of a minimal-working-example to the console.mesh.interpolate_line(mesh, xi, axis)
to interpolate a line mesh. The attribute points_derivative
holds the derivatives of the independent variable w.r.t. the dependent variable(s). The column of the independent variable is filled with zeros.SolidBody.assemble.matrix(block=True)
, also for SolidBody.assemble.vector(block=True)
and the assemble-methods of SolidBodyNearlyIncompressible
. If block=False
, these methods will assemble a list of the upper-triangle sub block-vectors/-matrices instead of the combined block-vector/-matrix.SolidBodyForce
as a replacement for SolidBodyGravity
with more general keyword arguments ("values"
instead of "gravity"
, "scale"
instead of "density"
).Laplace
to be used as user-material in a solid body. Works with scalar- and vector-valued fields.mechanics.Assemble(..., multiplier=None)
argument which is used in external items like SolidBodyForce
, SolidBodyGravity
and PointLoad
and is applied in newtonrhapson(items, ...)
.view
which contains the View...
classes like ViewSolid
or ViewField
, previously located at tools._plot
.grad
- and hess
-arguments to the reload()
- and copy()
-methods of a Region
, i.e. Region.reload(grad=None, hess=None)
.LinearElasticOrthotropic
.SolidBodyCauchyStress
in addition to SolidBodyPressure
.mesh.cell_types()
which returns an object-array with cell-type mappings for FElupe and PyVista.MeshContainer.from_unstructured_grid(grid, dim=None, **kwargs)
to create a mesh-container from an unstructured grid (PyVista).field = Field(region, values=1, dtype=None)
values from field.values = np.ones(shape) * values
to field = np.full(shape, fill_value=values, dtype=dtype)
. This enforces field = Field(region, values=1)
to return the gradient array with data-type int
which was of type float
before.SolidBodyForce
, SolidBodyGravity
and PointLoad
with dtype=float
.SolidBodyForce
, SolidBodyGravity
and PointLoad
by -1.0
. Instead, mechanics.Assemble(multiplier=-1.0)
is used in the solid bodies.mechanics.Assemble
, mechanics.Evaluate
and mechanics.Results
from private to public.assembly
module to the global namespace.h
and dhdX
. This recovers the integral-form assembly performance from v8.6.0.assembly.expression.Basis
, assembly.expression.BasisField
and assembly.expression.BasisArray
) as especially their docstrings are useful to understand how a Basis is created on a field.function()
-, gradient()
- and hessian()
-methods of the core constitutive material formulations. This removes the ability for temporary material parameters in LinearElastic(E=None, nu=0.3).gradient(x, E=1.0)
, use LinearElastic(E=1.0, nu=0.3).gradient(x)
instead. This affects the material formulations LinearElastic
, LinearElasticPlaneStrain
, LinearElasticPlaneStress
, LinearElasticLargeStrain
, NeoHooke
and NeoHookeCompressible
. None
is still supported for the material parameters of NeoHooke
and NeoHookeCompressible
.LinearElasticPlaneStrain
from the top-level package namespace because this should only be used with Field(region, dim=2)
. The preferred method is to use FieldPlaneStrain(region, dim=2)
and the default LinearElastic
. LinearElasticPlaneStrain
remains available in constitution.LinearElasticPlaneStrain
.Mesh.as_pyvista()
to Mesh.as_unstructured_grid()
and add Mesh.as_pyvista()
as alias.SolidBodyGravity
, SolidBodyForce
should be used instead.Region.astype(dtype=None)
and Field(..., dtype=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/797
hello_world()
by @adtzlr in https://github.com/adtzlr/felupe/pull/799
mesh.interpolate_line(mesh, xi, axis)
by @adtzlr in https://github.com/adtzlr/felupe/pull/811
mesh.interpolate_line()
by @adtzlr in https://github.com/adtzlr/felupe/pull/812
SolidBody.assemble.matrix(block=False)
by @adtzlr in https://github.com/adtzlr/felupe/pull/813
SolidBodyForce
and Laplace
by @adtzlr in https://github.com/adtzlr/felupe/pull/814
Assemble(multiplier=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/817
quadrature
submodule by @adtzlr in https://github.com/adtzlr/felupe/pull/824
mechanics
submodule by @adtzlr in https://github.com/adtzlr/felupe/pull/825
Basis
, BasisField
and BasisArray
public by @adtzlr in https://github.com/adtzlr/felupe/pull/835
hess
argument to Region(hess=False)
by @adtzlr in https://github.com/adtzlr/felupe/pull/836
LinearElasticOrthotropic
by @adtzlr in https://github.com/adtzlr/felupe/pull/840
SolidBodyCauchyStress
by @adtzlr in https://github.com/adtzlr/felupe/pull/842
LinearElasticPlaneStrain
in top-level package namespace by @adtzlr in https://github.com/adtzlr/felupe/pull/844
felupe.mesh.cell_types()
by @adtzlr in https://github.com/adtzlr/felupe/pull/846
MeshContainer.from_unstructured_grid()
by @adtzlr in https://github.com/adtzlr/felupe/pull/847
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.8.0...v9.0.0
Published by adtzlr 4 months ago
Region(uniform=False)
, a flag to invoke a reduced evaluation of the element shape functions and their gradients. If True, only the first cell is evaluated. This drastically speeds up linear-elasticity on uniform grid meshes (e.g. voxel-like quads and hexahedrons).FormItem(..., ramp_item=0).update(value)
. This enables a FormItem
to be used as a ramped-item in a Step
.Region(uniform=False)
: A performance feature for uniform grid meshes by @adtzlr in https://github.com/adtzlr/felupe/pull/792
FormItem().update(values)
by @adtzlr in https://github.com/adtzlr/felupe/pull/796
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.7.0...v8.8.0
Published by adtzlr 5 months ago
[!NOTE]
This is the first release with support for NumPy 2.0.
math.solve_nd(A, b, n=1)
as a generalized function of math.solve_2d(A, b)
with supported broadcasting on the elementwise-operating trailing axes.math.solve_2d(A, b)
on math.solve_nd(A, b, n=2)
with a batched-rhs supported in NumPy 2.0.ogden_roxburgh()
and OgdenRoxburgh
to use the Gauss error function erf
instead of tanh
as internal sigmoid function.inverse
indices-array of np.unique(..., return_inverse=True)
in mesh.merge_duplicate_points()
to ensure compatibility with NumPy 2.0.PlotMaterial.evaluate()
after each completed load case.PlotMaterial.evaluate()
after each completed load case by @adtzlr in https://github.com/adtzlr/felupe/pull/784
math.solve_nd(A, b, n=1)
by @adtzlr in https://github.com/adtzlr/felupe/pull/785
math.solve_nd()
by @adtzlr in https://github.com/adtzlr/felupe/pull/787
ogden_roxburgh()
and OgdenRoxburgh
to use erf
instead of tanh
by @adtzlr in https://github.com/adtzlr/felupe/pull/788
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.6.0...v8.7.0
Published by adtzlr 5 months ago
alexander(C1, C2, C2, gamma, k)
material model formulation to be used in Hyperelastic()
.miehe_goektepe_lulei(mu, N, U, p, q)
material model formulation to be used in Hyperelastic()
.ogden_roxburgh(r, m, beta, material, **kwargs)
material model formulation to be used in Hyperelastic()
.ConstitutiveMaterial.optimize(relative=False)
.constitutive_material(Msterial, name=None)
.morph_representative_directions(p)
to be used in MaterialAD()
.morph(p)
to be used in Hyperelastic()
.@total_lagrange
and @updated_lagrange
for Total / Updated Lagrange material formulations to be used in MaterialAD
.anssari_benam_bucchi(mu, N)
material model formulation to be used in Hyperelastic()
.lopez_pamies(mu, alpha)
material model formulation to be used in Hyperelastic()
.constitution
module.ConstitutiveMaterial.plot(show_kwargs=True)
. For list-based material parameters of length 1, the brackets aren't shown now. E.g., this affects optimized material parameters.ConstitutiveMaterial.optimize()
.ConstitutiveMaterial.optimize()
.ogden_roxburgh
using AD for Hyperelastic
by @adtzlr in https://github.com/adtzlr/felupe/pull/762
ConstitutiveMaterial.optimize(relative=False)
by @adtzlr in https://github.com/adtzlr/felupe/pull/764
constitutive_material(Material)
decorator by @adtzlr in https://github.com/adtzlr/felupe/pull/768
@total_lagrange
and @updated_lagrange
decorators for MaterialAD
by @adtzlr in https://github.com/adtzlr/felupe/pull/773
morph_representative_directions()
as Total-Lagrange material for MaterialAD
by @adtzlr in https://github.com/adtzlr/felupe/pull/774
ConstitutiveMaterial.optimize()
by @adtzlr in https://github.com/adtzlr/felupe/pull/778
lopez_pamies(mu, alpha)
by @adtzlr in https://github.com/adtzlr/felupe/pull/779
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.5.1...v8.6.0
Published by adtzlr 6 months ago
NeoHookeCompressible(mu=1, lmbda=None)
.MaterialStrain.plot()
.NeoHookeCompressible(lmbda=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/754
MaterialStrain.plot()
by @adtzlr in https://github.com/adtzlr/felupe/pull/755
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.5.0...v8.5.1
Published by adtzlr 6 months ago
umat_new, res = ConstitutiveMaterial.optimize(ux=[stretches, stresses], ps=None, bx=None)
to optimize the material parameters on given experimental data for incompressible uniaxial, biaxial and / or planar tension / compression data by scipy.optimize.least_squares()
.ConstitutiveMaterial.optimize()
by @adtzlr in https://github.com/adtzlr/felupe/pull/750
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.4.0...v8.5.0
Published by adtzlr 7 months ago
math.solve_2d(A, b, solver=np.linalg.solve, **kwargs)
to be used in newtonrhapson(solve=solve_2d, ...)
for two-dimensional unknowns. This is useful for local Newton-iterations related to viscoelastic evolution equations inside constitutive material formulations.Job.plot(xoffset=0.0, yoffset=0.0)
.ConstitutiveMaterial.plot()
.Scene.plot("Principal Values of ...")
. This ensures that the labels are matching user-defined arrays of principal values.Scene.plot()
by @adtzlr in https://github.com/adtzlr/felupe/pull/739
math.solve_2d(A, b)
by @adtzlr in https://github.com/adtzlr/felupe/pull/742
ConstitutiveMaterial.plot()
by @adtzlr in https://github.com/adtzlr/felupe/pull/743
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.3.1...v8.4.0
Published by adtzlr 7 months ago
newtonrhapson(verbose=None)
and Job.evaluate(verbose=None)
. If None, this defaults to True (as before) but evaluates the environmental variable FELUPE_VERBOSE
if present with FELUPE_VERBOSE == "true"
. This does not ignore custom verbosity levels.verbose=None
in Job.evaluate()
and newtonrhapson()
by @adtzlr in https://github.com/adtzlr/felupe/pull/736
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.3.0...v8.3.1
Published by adtzlr 7 months ago
Mesh.as_pyvista(cell_type=None)
.1.0
to 2.0
in ViewMesh.plot(line_width=2.0)
.Mesh.as_meshio()
.ViewMesh.plot(line_width=1.0)
.math.tovoigt()
for one-dimensional tensors.Mesh.as_pyvista()
, fix and change default ViewMesh.plot(line_width=1.0)
by @adtzlr in https://github.com/adtzlr/felupe/pull/733
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.2.1...v8.3.0
Published by adtzlr 7 months ago
FieldContainer.evaluate.strain(fun=lambda stretch: stretch)
for custom strain-stretch callables. The fun
-argument was previously ignored.field.EvaluateFieldContainer(field)
by @adtzlr in https://github.com/adtzlr/felupe/pull/728
EvaluateFieldContainer
to field/_evaluate.py
by @adtzlr in https://github.com/adtzlr/felupe/pull/729
FieldContainer.evaluate.strain(fun=lambda stretch: stretch)
for custom fun
-callables by @adtzlr in https://github.com/adtzlr/felupe/pull/731
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.2.0...v8.2.1
Published by adtzlr 7 months ago
FieldContainer.evaluate.strain(tensor=True, asvoigt=False, k=0)
, FieldContainer.evaluate.log_strain(tensor=True, asvoigt=False)
or FieldContainer.evaluate.green_lagrange_strain(tensor=True, asvoigt=False)
. These methods refer to math.strain(k=0)
which uses math.strain_stretch_1d(k=0)
by default with the strain exponent k
of the Seth-Hill strain formulation.math.eig()
which returns a namedtuple with attributes eigenvalues
and eigenvectors
. Now consistent with NumPy. This also affects math.eigh()
.math.eig()
from (a, i, ...)
to (i, a, ...)
. Now consistent with NumPy. This also affects math.eigh()
.math.strain(fun=math.strain_stretch_1d, k=0)
with a default strain-exponent of k=0
which returns the logarithmic strain.GaussLegendreBoundary
by @adtzlr in https://github.com/adtzlr/felupe/pull/724
FieldContainer.evaluate.strain()
by @adtzlr in https://github.com/adtzlr/felupe/pull/726
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.1.0...v8.2.0
Published by adtzlr 7 months ago
mesh.expand(expand_dim=True)
and mesh.revolve(expand_dim=True)
. E.g., this allows the expansion and / or revolution of a quad-mesh with points in 3d-space.MultiPointContact.plot(offset=0, **kwargs)
to plot the rigid contact plane(s) or line(s) at a given offset.MultiPointConstraint.plot(**kwargs)
to plot the lines of a multi-point constraint.mesh.revolve(phi=361)
.mesh.revolve(phi=361)
by @adtzlr in https://github.com/adtzlr/felupe/pull/715
mesh.expand(expand_dim=True)
and mesh.revolve(expand_dim=True)
by @adtzlr in https://github.com/adtzlr/felupe/pull/716
MultiPointContact.plot(**kwargs)
method by @adtzlr in https://github.com/adtzlr/felupe/pull/718
MultiPointConstraint.plot(**kwargs)
by @adtzlr in https://github.com/adtzlr/felupe/pull/719
plot()
-methods of region, element and quadrature by @adtzlr in https://github.com/adtzlr/felupe/pull/721
Full Changelog: https://github.com/adtzlr/felupe/compare/v8.0.0...v8.1.0
Published by adtzlr 7 months ago
mesh.expand(axis=-1)
(ignored for n=1
).mesh.rotate(mask=None)
.ViewMesh
.SolidBody.plot(project=None)
, where project
has to be a callable like project(values, region)
.FieldContainer.plot(project=None)
, where project
has to be a callable like project(values, region)
.BasisField.basis
is now a subclassed array BasisArray
with a grad
-attribute.math.grad(x, **kwargs)
is enhanced to return gradients of fields (like before) and the gradient-attribute of basis-arrays (added).grad_v
and grad_u
arguments are removed from the form-expression decorator Form
. This changes the required function signature of the weakform-callable to weakform(v, u, **kwargs)
. The tuple of optional arguments is also removed. Gradients of v
and u
are now obtained by math.grad(v)
or v.grad
.project()
for Triangle
, Tetra
as well as their MINI- and Quadratic-variants.extrapolate(mean=True)
in project(mean=True)
.res = extrapolate(values, region)
, i.e. values.shape = (3, 3, 4, 100)
will be returned as res.shape = (121, 3, 3)
instead of res.shape = (121, 9)
.MeshContainer.stack([idx])
.MeshContainer[idx]
.opacity=0.99
argument to MeshContainer.plot()
and MeshContainer.screenshot()
.imshow(dpi=None)
for solids, field- and mesh-containers.GaussLegendre(order=2, dim=2)
according to the points of the BiQuadraticQuad
element by default.GaussLegendre
quadrature schemes for order > 2 according to the VTK-Lagrange element formulations. That means for linear and quadratic quads and hexahedrons, the points of GaussLegendre
are sorted according to the default VTK elements and for all higher-order elements according to the Lagrange-elements.RegionLagrange(permute=True)
by default.ViewScene.plot()
by default.tools.topoints(values, region, average=True, mean=False)
. Remove all other arguments. If values of single quadrature-point per cells is given, then the values are broadcasted to the number of points-per-cell. If values are provided on more quadrature points than the number of points-per-cell, then the values are trimmed. E.g., this is required for QuadraticHexahedron
with 20 points and 27 quadrature-points.mesh.expand(n=1)
. This expands the dimension of the points-array.CubeArbitraryOrderHexahedron
.SolidBody
and SolidBodyNearlyIncompressible
on a 2d-Field (plane stress): Automatic fall-back to Kirchhoff-stress and print a warning.move
in dof.biaxial()
.move
, axis_compression
, axis_shear
and compression
in dof.shear()
.Form
: Remove required grad_v
and grad_u
args and obtain the gradient by v.grad
or grad(v)
by @adtzlr in https://github.com/adtzlr/felupe/pull/688
dof.biaxial()
and dof.shear()
by @adtzlr in https://github.com/adtzlr/felupe/pull/689
tools.extrapolate(mean=True)
for project(mean=True)
by @adtzlr in https://github.com/adtzlr/felupe/pull/691
mesh.expand(n=1)
and add axis of expansion mesh.expand(axis=-1)
by @adtzlr in https://github.com/adtzlr/felupe/pull/697
imshow()
-methods of solid, field and mesh by @adtzlr in https://github.com/adtzlr/felupe/pull/699
mesh.rotate(mask=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/700
ArbitraryOrderLagrangeElement
VTK-compatible by @adtzlr in https://github.com/adtzlr/felupe/pull/702
Scene.plot()
: Hide internal edges of quadratic celltypes by @adtzlr in https://github.com/adtzlr/felupe/pull/705
SolidBody.plot(project=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/707
FieldContainer.plot(project=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/710
tools.topoints(values, region)
by @adtzlr in https://github.com/adtzlr/felupe/pull/712
topoints( values, region, average=True, mean=False)
by @adtzlr in https://github.com/adtzlr/felupe/pull/713
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.19.1...v8.0.0
Published by adtzlr 8 months ago
tools.project()
for meshes where some points are not connected to cells.project()
for meshes with points without cells by @adtzlr in https://github.com/adtzlr/felupe/pull/687
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.19.0...v7.19.1
Published by adtzlr 8 months ago
FieldDual(disconnect=True)
for a dual (secondary) field with an optionally disconnected mesh. This also enables FieldsMixed(disconnect=True)
in mixed fields.BazantOh(n=21)
.NearlyIncompressible
as a simplified version of ThreeFieldVariation
. A constitutive material formulation on the distortional part of a strain energy function in terms of the deformation gradient has to be provided, e.g. by umat = NearlyIncompressible(NeoHooke(mu=1), bulk=5000)
.Job(callback=lambda stepnumber, substepnumber, substep, **kwargs: None, **kwargs)
and CharacteristicCurve(callback=lambda stepnumber, substepnumber, substep, **kwargs: None, **kwargs)
.DiscreteGeometry
properties x
, y
and z
to access the columns of the points-array.math.equivalent_von_mises(A)
for three-dimensional second-order tensors.ViewSolid
, available as Solid.plot("Equivalent of Cauchy Stress")
.mesh.stack(meshes)
as method to MeshContainer.stack()
. Note that this only supports mesh containers with meshes of same cell-types.NeoHooke.gradient(out=None)
and NeoHooke.hessian(out=None)
for a location to store the results. Also for NeoHookeCompressible
.out
-keyword to gradient()
and hessian
of NearlyIncompressible
and ThreeFieldVariation
.ViewMaterial(statevars=None)
and ViewMaterialIncompressible(statevars=None)
.tools.project(values, region, average=True, mean=False, dV=None, solver=scipy.sparse.linalg.spsolve)
to project given values at quadrature points to mesh-points. This replaces the old tools.project(values, region, average=True, mean=False)
in a backward-compatible way. The new method is computationally more expensive but is also much more flexible.quadrature.Triangle(order=5)
and quadrature.Tetrahedron(order=5)
.Region.copy(mesh=None, element=None, quadrature=None)
to copy a region and re-evaluate this copy if necessary.Mesh.save()
to Mesh.write()
and add Mesh.save()
as an alias to Mesh.write()
.NeoHooke
, NeoHookeCompressible
, SolidBody
and SolidBodyNearlyIncompressible
.math.inv(out=None)
and math.det(out=None)
.tensortrax
. A workaround is used to ensure compatibility with tensortrax
<= v0.17.1.ViewMaterial.plot(**kwargs)
and ViewMaterialIncompressible.plot(**kwargs)
to the matplotlib axes object ax.plot(**kwargs)
.off_screen
and notebook
keyword-arguments to pyvista.Plotter(**kwargs)
if they are True
. This is needed for not ignoring a global variable like pyvista.OFF_SCREEN = True
.verbose=0
if the environmental variable "FELUPE_VERBOSE"
is "false"
. This is useful for running the examples when building the documentation.bilinearform
in FormItem(bilinearform=None)
. An empty FormItem
is now a valid item in a Step
. For empty vectors/matrices, the shape is inferred from sum(FieldContainer.fieldsizes)
instead of FieldContainer.fields[0].values.size
.tools.extrapolate(values, region, average=True, mean=False)
which extrapolates values at quadrature points to mesh-points.Region.reload(mesh, element, quadrature)
.math.dot(A, B, mode=(2,3))
and math.ddot(A, B, mode=(2,3))
.FieldDual
is in the fields of a FieldContainer
for IntegralForm
.math.inv(A)
for arrays with shape A.shape = (1, 1, ...)
. Also raise an error if shape[:2]
not in [(3, 3), (2, 2), (1, 1)]
.math.det(A)
if A.shape[:2]
not in [(3, 3), (2, 2), (1, 1)]
.SolidBody._vector(kwargs={})
by SolidBody._vector(kwargs=None)
. Also for ._matrix()
and for SolidBodyNearlyIncompressible
.fem.assembly.expression.Form
for the integration of a linear form with different mesh- and field-dimensions.Mesh.save()
to Mesh.write()
and add Mesh.save()
as an alias of it by @adtzlr in https://github.com/adtzlr/felupe/pull/626
FieldDual
for the dual (secondary) fields in mixed fields by @adtzlr in https://github.com/adtzlr/felupe/pull/629
BazantOh()
by @adtzlr in https://github.com/adtzlr/felupe/pull/632
NearlyIncompressible(material, bulk)
by @adtzlr in https://github.com/adtzlr/felupe/pull/633
math.dot(A, B, mode=(2,3))
and math.ddot(A, B, mode=(2,3))
by @adtzlr in https://github.com/adtzlr/felupe/pull/641
Job(callback=lambda i, j, res, **kwargs: None, **kwargs)
by @adtzlr in https://github.com/adtzlr/felupe/pull/642
FieldDual
in IntegralForm
by @adtzlr in https://github.com/adtzlr/felupe/pull/643
math.inv(A)
for A.shape[:2] == (1, 1)
by @adtzlr in https://github.com/adtzlr/felupe/pull/644
FieldDual(disconnect=None)
. by @adtzlr in https://github.com/adtzlr/felupe/pull/646
DiscreteGeometry
properties x
, y
and z
by @adtzlr in https://github.com/adtzlr/felupe/pull/648
math.equivalent_von_mises(A)
by @adtzlr in https://github.com/adtzlr/felupe/pull/650
MeshContainer.stack()
by @adtzlr in https://github.com/adtzlr/felupe/pull/652
math.det(A, out=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/659
tensortrax.math
by @adtzlr in https://github.com/adtzlr/felupe/pull/667
off_screen
and notebook
keyword-arguments to pyvista.Plotter(**kwargs)
if they are True
by @adtzlr in https://github.com/adtzlr/felupe/pull/670
Form
for different mesh- and field-dimensions by @adtzlr in https://github.com/adtzlr/felupe/pull/675
tools.project()
by @adtzlr in https://github.com/adtzlr/felupe/pull/683
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.18.0...v7.19.0
Published by adtzlr 8 months ago
FieldContainer
by the &
-operator between fields and field containers, i.e. field = displacement & pressure
, where displacement = Field(region, dim=2)
and pressure = Field(region)
. This also works for field & pressure
as well as pressure & field
.Field(region, dim=3).as_container()
is equal to FieldContainer([Field(region, dim=3)])
.ViewMaterial(umat)
to view force-stretch curves for uniaxial tension/compression, planar shear and equi-biaxial tension.ViewMaterialIncompressible(umat)
to view force-stretch curves for incompressible uniaxial tension/compression, planar shear and equi-biaxial tension.ConstitutiveMaterial.view(incompressible=False)
, ConstitutiveMaterial.plot(incompressible=False)
and ConstitutiveMaterial.screenshot(incompressible=False)
.NeoHooke.kwargs = {"mu": self.mu, "bulk": self.bulk}
.umat = CompositeMaterial(material, other_material)
.&
-operator to combine constitutive materials umat = material & other_material
. Note that only the first material must contain state variables.RegionQuadraticTriangle
and RegionQuadraticTetra
in FieldsMixed
.Mesh.flip(mask=None)
: Take care of the mask (it wasn't applied to the cells-array of the mesh).FieldContainer
by all logical-and combinations of Field
and FieldContainer
by @adtzlr in https://github.com/adtzlr/felupe/pull/618
Field.as_container()
by @adtzlr in https://github.com/adtzlr/felupe/pull/619
ViewMaterialIncompressible
by @adtzlr in https://github.com/adtzlr/felupe/pull/620
ConstitutiveMaterial
by @adtzlr in https://github.com/adtzlr/felupe/pull/621
Volumetric
, CompositeMaterial
and &
-operator for ConstitutiveMaterial
by @adtzlr in https://github.com/adtzlr/felupe/pull/623
Mesh.flip(mask=None)
: Take care of the mask by @adtzlr in https://github.com/adtzlr/felupe/pull/625
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.17...v7.18.0
Published by adtzlr 9 months ago
vertex = Point(a=0)
.vertex.expand(n=11, z=1)
.vertex.revolve(n=11, phi=180)
.umat
if it has no attribute umat.x
. Set the shape of the state variables by default to (0, q, c)
in SolidBody
and SolidBodyNearlyIncompressible
.mesh.Point(a=0)
by @adtzlr in https://github.com/adtzlr/felupe/pull/616
umat
if it has no attribute x
by @adtzlr in https://github.com/adtzlr/felupe/pull/617
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.16...v7.17
Published by adtzlr 9 months ago
MeshContainer.plot()
, img = MeshContainer.screenshot()
and ax = MeshContainer.imshow()
. The default list of colors contains PyVista's default color as first item and then the list of matplotlib's named colors C1, C2, etc (excluding C0).Mesh.merge_duplicate_points(decimals=None)
and make Mesh.sweep(decimals=None)
an alias of it.Mesh.merge_duplicate_cells()
.Mesh.imshow(ax=None)
, FieldContainer.imshow(ax=None)
and SolidBody.imshow(ax=None)
from v7.15.MeshContainer.plot()
, img = MeshContainer.screenshot()
and ax = MeshContainer.imshow()
by @adtzlr in https://github.com/adtzlr/felupe/pull/611
mesh.merge_duplicate_points()
and mesh.merge_duplicate_cells()
by @adtzlr in https://github.com/adtzlr/felupe/pull/612
Mesh.imshow(ax=None)
, FieldContainer.imshow(ax=None)
and SolidBody.imshow(ax=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/613
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.15.0...v7.16
Published by adtzlr 9 months ago
Mesh.imshow(ax=None)
, FieldContainer.imshow(ax=None)
and SolidBody.imshow(ax=None)
.Full Changelog: https://github.com/adtzlr/felupe/compare/v7.14.0...v7.15.0
Published by adtzlr 9 months ago
FieldContainer.extract(out=None)
.Mesh.update(callback=None)
. This is especially useful if the points array of a mesh is changed and an already existing instance of a region has to be reloaded: Mesh.update(points=new_points, callback=region.reload)
.ax = FieldContainer.imshow()
which acts as a wrapper on top of the img = FieldContainer.screenshot(filename=None)
method. The image data is passed to a matplotlib figure and the ax
object is returned.ax = Mesh.imshow()
which acts as a wrapper on top of the img = Mesh.screenshot(filename=None)
method. The image data is passed to a matplotlib figure and the ax
object is returned.SolidBody
and SolidBodyNearlyIncompressible
(same as already implemented for mesh and fields).tools.NewtonResult(xnorms=None, fnorms=None)
.Job.fnorms
.Mesh
for getting point ids next to a given point coordinate Mesh.get_point_ids(value)
.Mesh
for getting cells attached to a given point coordinate Mesh.get_cell_ids(point_ids)
.Mesh
for getting neighbour cells Mesh.get_cell_ids_neighbours(cell_ids)
.Mesh
for getting shared points between neighbour cells Mesh.get_point_ids_shared(cell_ids_neighbours)
.Mesh
for getting points on regular grids which are located at corners Mesh.get_point_ids_corners()
.Mesh
for modifying the cell connectivity at corners Mesh.modify_corners(point_ids=None)
, supported for regular quad and hexahedron meshes.math.dot(**kwargs)
to the underlying einsum-calls.math.cdya()
by reducing the number of (intermediate) arrays to be created from 4 to 2.SolidBody
and SolidBodyNearlyIncompressible
. This enhances the performance.Mesh.screenshot()
from filename="field.png"
to filename="mesh.png"
.None = Job.evaluate()
to job = Job.evaluate()
.LinearElasticLargeStrain
from NeoHooke
to NeoHookeCompressible
.pyvista.start_xvfb()
on a posix-os. If required, run it manually.tools._newton.Result
to tools._newton.NewtonResult
and add it to the public API as tools.NewtonResult
because this class is returned as a result of Newton's method.r
-arguments of tools.force()
and tools.moment()
to forces
.point
-argument of tools.moment()
to centerpoint
.r
-argument in tools.save()
to forces
. Remove the unused argument converged
..vtk
to .vtu
in tools.save(filename="result.vtu")
.gravity=None
in SolidBodyGravity(field, gravity=None, density=1.0)
.tools.moment()
. Use math.cross()
. The old implementation was completely wrong!cdya()
and pass kwargs in dot()
by @adtzlr in https://github.com/adtzlr/felupe/pull/593
field.extract(out=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/594
out
-locations to the integral forms and use them in the solid bodies by @adtzlr in https://github.com/adtzlr/felupe/pull/595
Mesh.update(callback=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/596
pyvista.start_xvfb()
on a posix-os by @adtzlr in https://github.com/adtzlr/felupe/pull/597
Mesh.imshow()
and FieldContainer.imshow()
by @adtzlr in https://github.com/adtzlr/felupe/pull/598
job = Job.evaluate()
by @adtzlr in https://github.com/adtzlr/felupe/pull/599
LinearElasticLargeStrain
from NeoHooke
to NeoHookeCompressible
by @adtzlr in https://github.com/adtzlr/felupe/pull/601
tools._newton.Result
to tools.NewtonResult
by @adtzlr in https://github.com/adtzlr/felupe/pull/603
tools.moment(field, forces, boundary, centerpoint=np.zeros(3))
by @adtzlr in https://github.com/adtzlr/felupe/pull/605
tools.NewtonResult(xnorms=None, fnorms=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/606
tools.save()
-argument r
to forces
by @adtzlr in https://github.com/adtzlr/felupe/pull/607
Mesh
by @adtzlr in https://github.com/adtzlr/felupe/pull/608
Mesh
-methods by @adtzlr in https://github.com/adtzlr/felupe/pull/609
fig
-argument in CharacteristicCurve.plot(ax=None)
by @adtzlr in https://github.com/adtzlr/felupe/pull/610
Full Changelog: https://github.com/adtzlr/felupe/compare/v7.13.0...v7.14.0