Finite Element Analysis

Andreas D.

Last update: Jan 9, 2023

Related tags

Deep Learning python scientific-computing partial-differential-equations fem finite-element-analysis pde solid-mechanics hyperelasticity

Overview

FElupe - Finite Element Analysis

FElupe is a Python 3.6+ finite element analysis package focussing on the formulation and numerical solution of nonlinear problems in continuum mechanics of solid bodies. Its name is a combination of FE (finite element) and the german word Lupe (magnifying glass) as a synonym for getting a little insight how a finite element analysis code looks like under the hood.

Installation

Install Python, fire up a terminal and run

pip install felupe[all]

where [all] installs all optional dependencies. By default, FElupe does not require numba and sparse. In order to make use of all features of FElupe, it is suggested to install all optional dependencies.

Hello, FElupe!

A quarter model of a solid cube with hyperelastic material behavior is subjected to a uniaxial elongation applied at a clamped end-face. This involves the creation of a mesh, a region and a displacement field. Furthermore, the boundary conditions are created by a template for a uniaxial loadcase. The material behavior is defined through a FElupe-built-in Neo-Hookean material formulation. Inside a Newton-Rhapson procedure, the internal force vector and the tangent stiffness matrix are generated by assembling both linear and bilinear forms of static equilibrium. Finally, the solution of the incremental displacements is calculated und updated until convergence is reached. For more details beside this high-level code snippet, please have a look at the documentation.

import felupe as fe

# create a hexahedron-region on a cube
region = fe.RegionHexahedron(fe.Cube(n=11))

# add a displacement field and apply a uniaxial elongation on the cube
displacement = fe.Field(region, dim=3)
boundaries, dof0, dof1, ext0 = fe.dof.uniaxial(displacement, move=0.2, clamped=True)

# define the constitutive material behavior
umat = fe.NeoHooke(mu=1.0, bulk=2.0)

# newton-rhapson procedure
res = fe.newtonrhapson(displacement, umat=umat, dof1=dof1, dof0=dof0, ext0=ext0)

# save result
fe.save(region, res.x, filename="result.vtk")

Documentation

The documentation is located here.

Changelog

All notable changes to this project will be documented in this file. The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

[Unreleased]

Added

Add a new method to deepcopy a Mesh with Mesh.copy()
Add broadcasting capability for trailing axes inside the parallel form integrators.
Add Basis on top of a field for virtual fields used in linear and bilinear forms.
Add LinearForm and BilinearForm (including mixed variants) for vector/matrix assembly out of weak form expressions.
Add parallel keyword for threaded integration/assembly of LinearForm and BilinearForm.

Changed

Enhance Boundary for the application of prescribed values of any user-defined Field which is part of FieldMixed.
The whole mixed-field has to be passed to dof.apply() along with the offsets returned from dof.partition for mixed-field formulations.
Set default value shape=(1, 1) for hessian() methods of linear elastic materials.

Fixed

Fixed einstein summation of math.dot() for two vectors with trailing axes.

Removed

Remove dof.extend because dof.partition does not need it anymore.

[1.6.0] - 2021-12-02

Added

Add LinearElasticPlaneStress and LinearElasticPlaneStrain material formulations.
Add region argument for LinearElastic.hessian().

Changed

Re-formulate LinearElastic materials in terms of the deformation gradient.
Re-formulate LinearElastic material in matrix notation (Speed-up of ~10 for elasticity matrix compared to previous implementation.)
Move previous LinearElastic to constitution.LinearElasticTensorNotation.

[1.5.0] - 2021-11-29

Added

Add kwargs of field.extract() to fun and jac of newtonrhapson.

Changed

Set default number of threads in MatadiMaterial to multiprocessing.cpu_count().
Moved documentation to Read the Docs (Sphinx).

Fixed

Fix dim in calculation of reaction forces (tools.force) for FieldMixed.
Fix calculation of reaction moments (tools.moment) for FieldMixed.

[1.4.0] - 2021-11-15

Added

Add mask argument to Boundary for the selection of user-defined points.
Add shear loadcase.
Add a wrapper for matadi materials as MatadiMaterial.
Add verbose and timing arguments to newtonrhapson.

Fixed

Obtain internal dim from Field in calculation of reaction force tools.force.
Fix math.dot for combinations of rank 1 (vectors), rank 2 (matrices) and rank 4 tensors.

[1.3.0] - 2021-11-02

Changed

Rename mesh.as_discontinous() to mesh.disconnect().
Rename constitution.Mixed to constitution.ThreeFieldVariation.
Rename unstack to offsets as return of dof-partition and all subsequent references.
Import tools (newtonrhapson, project, save) and constitution (NeoHooke, LinearElastic and ThreeFieldVariation) to FElupe's namespace.
Change minimal README-example to a high-level code snippet and refer to docs for details.

[1.2.0] - 2021-10-31

Added

Add template regions, i.e. a region with a Hexahedron() element and a quadrature scheme GaussLegendre(order=1, dim=3) as RegionHexahedron, etc.
Add biaxial and planar loadcases (like uniaxial).
Add a minimal README-example (Hello FElupe!).

Changed

Deactivate clamped boundary (clamped=False) as default option for uniaxial loading dof.uniaxial.

[1.1.0] - 2021-10-30

Added

Add inverse quadrature method quadrature.inv() for Gauss-Legendre schemes.
Add discontinous representation of a mesh as mesh method mesh.as_discontinous().
Add tools.project() to project (and average) values at quadrature points to mesh points.

Changed

Removed quadpy dependency and use built-in polynomials of numpy for Gauss-Legendre calculation.

Fixed

Fix typo in first shear component of math.tovoigt() function.
Fix wrong stress projection in tools.topoints() due to different quadrature and cell ordering.

[1.0.1] - 2021-10-19

Fixed

Fix import of dof-module if sparse is not installed.

[1.0.0] - 2021-10-19

Added

Start using a Changelog.
Added docstrings for essential classes, methods and functions.
Add array with point locations for all elements.

Changed

Rename element methods (from basis to function and from basisprime to gradient).
Make constitutive materials more flexible (allow material parameters to be passed at stress and elasticity evaluation umat.gradient(F, mu=1.0)).
Rename ndim to dim.
Simplify element base classes.
Speed-up calculation of indices (rows, cols) for Fields and Forms (about 10x faster now).
Update test_element.py according to changes in element methods.

Removed

Automatic check if the gradient of a region can be calculated based on the dimensions. The grad argument in region(grad=False) has to be enforced by the user.

License

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.

Comments

[v1.0.1] Wrong stress projection to points
Quadrature points are indexed differently compared to the cell connectivity (due to the usage of quadpy). Thus, stress projection delivers wrong results.

A collection of tasks:

[x] For linear quadratures the point ordering should be permuted in order to match cell ordering.

[x] add a tools.project function for the stress projection to mesh-points (basically the code-snippet above)

[x] argument to average results

[x] add tools.project() to Getting Started Example (see tests)

[x] check axisymmetric stress result

[x] add permute for Gauss-Legendre order=2 dim=3

bug
opened by adtzlr 10
Define slow?

Hi @adtzlr

Thanks for open-sourcing felupe. Looks great. I have used both FEniCS and scikit-fem and completely agree with you on native-installation of FEniCS on Windows (I use it mostly via Docker) and the the convenience of scikit-fem. For the latter, with numba even though the forms are considerably longer, the timings have been reasonable so far, especially for a pure python code.

I will try felupe for myself sometime this week. But have you observed significant differences between scikit-fem and felupe timings? Is this documented somewhere? My use cases also reside in finite incompressible elasticity so it might be worthwhile knowing it.

In any case, yet another nice tool in pure python to have at disposal.

Cheers!
documentation

opened by bhaveshshrimali 10
[v1.0.1] Tune import time

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

opened by adtzlr 9
Implementation of the Mean-Dilatation technique for nearly-incompressible materials

as described by Bonet & Wood, section 8.6.5 (p.231). Try to create a solid body ~~SolidBodyMeanDilatation~~ SolidBodyNearlyIncompressible, which only needs a user material for the distortional part.
enhancement

opened by adtzlr 5

Flexible weak form expressions

FElupe does only provide form assemblers for a given formal architecture of weak form expressions (double-dot products), for example a linear form with the gradient of v:

∫ f_ij : v_i,j dx

With some minor additions very flexible weak-form definitions similar to the interior-basis functionality of scikit-fem may be possible with FElupe. This is just a quick and dirty extension, notation and class methods may be improved in the future.


import felupe as fe
import numpy as np

class Basis:
    def __init__(self, field):
        self.field = field
        self.grad = np.einsum(
            "ij,akpe->aijkpe", np.eye(self.field.region.element.dim), self.field.region.dhdX
        )
        self.basis = np.einsum(
            "ij,ap,e->aijpe", 
            np.eye(self.field.region.element.dim), 
            self.field.region.h, 
            np.ones(self.field.region.mesh.ncells)
        )

class LinearForm:
    def __init__(self, v, grad_v=False):
        self.v = v
        self.grad_v = grad_v
        self.dx = v.field.region.dV
        self.form = fe.IntegralForm(None, v.field, self.dx, grad_v=grad_v)

    def integrate(self, weakform, *args, **kwargs):
        if self.grad_v:
            v = self.v.grad
        else:
            v = self.v.basis
        values = np.zeros((len(v), *v.shape[-3:]))
        for a, vbasis in enumerate(v):
            for i, vb in enumerate(vbasis):
                values[a, i] = weakform(vb, *args, **kwargs) * self.dx
        return values.sum(-2)
    
    def assemble(self, weakform, *args, **kwargs):
        values = self.integrate(weakform, *args, **kwargs)
        return self.form.assemble(values)

class BilinearForm:
    def __init__(self, v, u, grad_v=False, grad_u=False):
        self.v = v
        self.grad_v = grad_v
        self.u = u
        self.grad_u = grad_u
        self.dx = v.field.region.dV
        self.form = fe.IntegralForm(None, v.field, self.dx, u.field, grad_v, grad_u)

    def integrate(self, weakform, *args, **kwargs):
        
        if self.grad_v:
            v = self.v.grad
        else:
            v = self.v.basis
            
        if self.grad_u:
            u = self.u.grad
        else:
            u = self.u.basis
            
        values = np.zeros((len(v), v.shape[-3], len(u), *u.shape[-3:]))
        
        for a, vbasis in enumerate(v):
            for i, vb in enumerate(vbasis):
                
                for b, ubasis in enumerate(u):
                    for j, ub in enumerate(ubasis):
                        
                        values[a, i, b, j] = weakform(vb, ub, *args, **kwargs) * self.dx
        
        return values.sum(-2)
    
    def assemble(self, weakform, *args, **kwargs):
        values = self.integrate(weakform, *args, **kwargs)
        return self.form.assemble(values)

Using these two classes in the following example is already quite intuitive. Note that no fourth-order tensor has to be created for the assembly of the stiffness matrix.

from felupe.math import ddot

def lform(v, F):
    return ddot(F, v)

def bform(v, u, F):
    return ddot(F, v) * ddot(F, u)

mesh = fe.Cube(n=3)
region = fe.RegionHexahedron(mesh)
field = fe.Field(region, dim=3)
basis = Basis(field)

L = LinearForm(v=basis, grad_v=True)
r = L.integrate(lform, F=field.extract())

a = BilinearForm(v=basis, u=basis, grad_v=True, grad_u=True)
K = a.integrate(bform, F=field.extract())

checks are fine for both linear and bilinear forms:

L.form.fun = field.extract()
check = np.allclose(r, L.form.integrate())
print(check)

a.form.fun = fe.math.dya(field.extract(), field.extract())
check = np.allclose(K, a.form.integrate())
print(check)

enhancement

opened by adtzlr 4

Improve `tools.newtonrhapson`
Make this function actually usable for both single- and mixed-field problems.

[x] add default fun

[x] add default jac

[x] add default solve

[x] add default check

[x] add tests

enhancement
opened by adtzlr 4
Add `UserMaterialStrain` for small-strain elastic-plastic material formulations

The idea is to use only one single function for both the stress and the elasticity evaluation (like UMAT in Abaqus, HYPELA2 in Marc, etc). A tangent=True input could be provided for effective evaluations.

Input Arguments for function: de, e (old), s (old), statevars (old)

Outputs: dsde, s (new), statevars (new)
enhancement

opened by adtzlr 3

Add function decorator for weakforms

introduce a new function decorator @Form():

import numpy as np
from felupe.math import ddot
import felupe as fem

mesh = fem.mesh.triangulate(fem.Rectangle(n=6))
region = fem.RegionTriangle(mesh)
field = fem.Field(region)
coords = fem.Field(
    region, dim=mesh.dim, values=mesh.points
).interpolate()

@fem.Form(v=field, u=field, grad_v=True, grad_u=True)
def a(dv, du):
    return ddot(dv, du)

@fem.Form(v=field)
def L(v, coords):
    x, y = coords
    f = np.sin(np.pi * x) * np.sin(np.pi * y)
    return f * v

L.assemble(v=field, kwargs={"coords": coords})
a.assemble(v=field, u=field)

fixes #207

enhancement

opened by adtzlr 3

Fix tetrahedral meshes
If a tet mesh is imported with node numbering resulting in negative volumes this leads to an error in felupe.

Tasks:

[x] generate a fix function which can be applied to both triangle and tetrahedral meshes

[x] add quadrature rules for linear/quadratic triangle/tetrahedrons
opened by adtzlr 3
Naming convention / Nomenclature
Go through all files and unify namings.

Overview of tasks...

[x] mesh.py (see 810f82fcd717fb26e8884b3b3cd5d0b64c781a0a)

[x] doftools.py (see 875d9e878c670b92780861263146dcdcd7d23242)

[x] element.py (see 66552d4f094483a75f5ce650252b3f6477887356)

[x] field.py (see 6fa911b2e081b9b07fdba5450d8e0b8333f1e0fb)

[x] forms.py (see 716ce210cf0044361b957ea846ba8d41aa3db094) ~~- [x] math.py~~ ~~- [x] quadrature.py~~

[x] region.py (see 90a883831d073a04ea4bc78fbdbfcdb128b90c7b) ~~- [x] solve.py~~

[x] utils.py (see b32ee308185ef88530c2c3d995dfd5e0fc9ed5ba)

enhancement question
opened by adtzlr 3
Add `project(mean=True)`

This enables support for triangles and tetrahedrons in project().

fixes #328 as discussed in #322, derived by the idea of @ZAARAOUI999

also fixes #302 (duplicate)

Idea

Project the cell mean-values to mesh-points.

Notes

Computes the weighted average by using the quadrature weights.
enhancement

opened by adtzlr 2
Switch to sparse arrays
SciPy recommends to use sparse arrays instead of sparse matrices for new work.

https://docs.scipy.org/doc/scipy/reference/sparse.html

Tasks

[ ] search/replace "csr_matrix" 》"csr_array"

[ ] test if pypardiso is compatible

enhancement good first contribution
opened by adtzlr 0
Implement Contact

Ideally implement a contact pair in a very general way. We have everything ready with a very nice RegionBoundary, actually only 😊 the contact algorithm is missing.

I think it should be treated like a SolidBody, i.e. a Contact may be added to Step(items=[rubber, steel, contact]).
help wanted

opened by adtzlr 1
Adopt Mesh to meshio.Mesh?

either a "real" meshio Mesh or the current Mesh organized in cell-blocks.

This opens a few questions: Should cell sets/tags be supported? How to organize regions?

But the main benefit is that the mesh tools operate on meshio Meshes, which should be really useful.
question

opened by adtzlr 1
Truss Implementation
Add a truss element (see TrussPy)

(Truss element from TrussPy)

Todo:

[ ] add a truss element or re-use a line-element

[ ] add a quadrature-rule for a truss

[ ] add a RegionTruss

enhancement
opened by adtzlr 5

Releases(v6.2.5)

v6.2.5(Jan 1, 2023)
[6.2.5] - 2023-01-02

Fixed

Once again fix init if tensortrax is not installed.

What's Changed

Fix import of UserMaterialHyperelastic by @adtzlr in https://github.com/adtzlr/felupe/pull/367

Full Changelog: https://github.com/adtzlr/felupe/compare/v6.2.4...v6.2.5
Source code(tar.gz)
Source code(zip)
v6.2.4(Jan 1, 2023)
[6.2.4] - 2023-01-01

Changed

Update actions used in CI/CD workflows.

Source code(tar.gz)
Source code(zip)
v6.2.3(Jan 1, 2023)
[6.2.3] - 2023-01-01

Changed

Remove setup.cfg, change pyproject.toml and store the version tag only once within the source code (__about__.py).

What's Changed

Change pyproject.toml by @adtzlr in https://github.com/adtzlr/felupe/pull/362

Full Changelog: https://github.com/adtzlr/felupe/compare/v6.2.2...v6.2.3
Source code(tar.gz)
Source code(zip)
v6.2.2(Dec 20, 2022)
[6.2.2] - 2022-12-20

Fixed

Fix init if tensortrax is not installed.

What's Changed

Fix init if tensortrax is not installed. by @adtzlr in https://github.com/adtzlr/felupe/pull/360

Full Changelog: https://github.com/adtzlr/felupe/compare/v6.2.1...v6.2.2
Source code(tar.gz)
Source code(zip)
v6.2.1(Dec 19, 2022)
[6.2.1] - 2022-12-19

Fixed

Fix version string.

What's Changed

fix version string by @adtzlr in https://github.com/adtzlr/felupe/pull/359

Full Changelog: https://github.com/adtzlr/felupe/compare/v6.2.0...v6.2.1
Source code(tar.gz)
Source code(zip)
v6.2.0(Dec 16, 2022)
[6.2.0] - 2022-12-16

Added

Add Total-Lagrange UserMaterialHyperelastic(fun, parallel=False, **kwargs) based on optional tensortrax. Only available if tensortrax is installed.

Add constitutive isotropic hyperelastic model formulations to be used with UserMaterialHyperelastic() (constitution.ogden(C, mu, alpha), etc.).

Auto-Generated Release-Notes

What's Changed

Add UserMaterialHyperelastic() by @adtzlr in https://github.com/adtzlr/felupe/pull/355

Make tensortrax optional by @adtzlr in https://github.com/adtzlr/felupe/pull/357

Add models for isotropic hyperelasticity UserMaterialHyperelastic() by @adtzlr in https://github.com/adtzlr/felupe/pull/358

Full Changelog: https://github.com/adtzlr/felupe/compare/v6.1.0...v6.2.0
Source code(tar.gz)
Source code(zip)
v6.1.0(Dec 10, 2022)
[6.1.0] - 2022-12-10

Changed

Enhance plotting with custom x- and y-data in CharacteristicCurve.plot(x, y) and allow a list of items for force evaluation in CharacteristicCurve(items=[...]) to be passed.

Enhance math.linsteps(points=[0, 5, 0], num=[5, 10]) by supporting a list of substeps.

Enhance compression of shear loadcase: Apply the compression on the bottom and the top dof.shear(compression=(0, 0)).

Auto-Generated Release-Notes

What's Changed

Enhance CharacteristicCurve(items=[...]).plot(x, y) by @adtzlr in https://github.com/adtzlr/felupe/pull/350

Enhance linsteps by supporting a list of substeps by @adtzlr in https://github.com/adtzlr/felupe/pull/352

Enhance dof.shear(compression=(0, 0) by @adtzlr in https://github.com/adtzlr/felupe/pull/354

Full Changelog: https://github.com/adtzlr/felupe/compare/v6.0.0...v6.1.0
Source code(tar.gz)
Source code(zip)
v6.0.0(Nov 20, 2022)
[6.0.0] - 2022-11-20

Added

Add project(mean=True) to project cell mean-values to mesh-points. Now project() supports Triangles and Tetrahedrons.

Add RegionBoundary.mesh_faces() for a mesh with face-cells on the selected boundary of a region.

Add pseudo-elastic material OgdenRoxburgh() which may be used with SolidBodyNearlyIncompressible().

Add umat = UserMaterial(stress, elasticity, nstatevars=0, **kwargs) with user-defined functions for the (first Piola-Kirchhoff) stress tensor P, statevars_new = umat.gradient([F, statevars], **kwargs) and the according fourth-order elasticity tensor A = umat.hessian([F, statevars], **kwargs) based on the deformation gradient.

Add UserMaterialStrain() for small-strain based user-defined material formulations with an umat-interface suitable for elastic-plastic frameworks.

Add LinearElasticPlasticIsotropicHardening() which is based on UserMaterialStrain() and constitution.linear_elastic_plastic_isotropic_hardening().

Add new math helpers math.ravel() and math.reshape().

Add optional axis argument on which the norm is evaluated math.norm(axis=None).

Changed

Unify material definition with methods for the stress P, statevars_new = umat.gradient([F, statevars]) and the elasticity tensor A = umat.hessian([F, statevars]). This breaks support for materials defined by matadi<=0.1.10.

Do not broadcast the (constant) elasticity tensor for linear-elastic materials as einsumt>=0.9.3 supports broadcasting along the parallel-executed dimension.

Change not-updating attribute of FieldContainer(fields).values to a method FieldContainer(fields).values() which returns the current field values.

Removed

Remove unused SolidBodyTensor() and SolidBodyTensorNearlyIncompressible().

Remove unused region argument of LinearElastic().hessian().

Auto-Generated Release-Notes

What's Changed

Add project(mean=True) by @adtzlr in https://github.com/adtzlr/felupe/pull/329

Add RegionBoundary.mesh_faces() by @adtzlr in https://github.com/adtzlr/felupe/pull/334

Add pseudo-elastic material OgdenRoxburgh() by @adtzlr in https://github.com/adtzlr/felupe/pull/335

Unify umat for hyperelastic and tensor-based material formulations by @adtzlr in https://github.com/adtzlr/felupe/pull/339

Do not broadcast linear-elastic elasticity tensor by @adtzlr in https://github.com/adtzlr/felupe/pull/342

FieldContainer: Change attribute values to method values() by @adtzlr in https://github.com/adtzlr/felupe/pull/344

Add UserMaterialStrain() by @adtzlr in https://github.com/adtzlr/felupe/pull/346

Enhance and Fix the Documentation by @adtzlr in https://github.com/adtzlr/felupe/pull/347

Full Changelog: https://github.com/adtzlr/felupe/compare/v5.3.1...v6.0.0
Source code(tar.gz)
Source code(zip)
v5.3.1(Nov 3, 2022)
Changelog since [5.3.0] - 2022-11-03

Fixed

Fix volume evaluation of (nearly) incompressible solids for axisymmetric fields.

Auto-Generated Release-Notes

What's Changed

Fix incompressible solid: Wrong volume evaluation for axisymmetric fields by @adtzlr in https://github.com/adtzlr/felupe/pull/327

Full Changelog: https://github.com/adtzlr/felupe/compare/v5.3.0...v5.3.1
Source code(tar.gz)
Source code(zip)
v5.3.0(Nov 3, 2022)
Changelog since [5.2.0] - 2022-10-08

Added

Add optional pre-compression to shear-loadcase dof.shear(compression=0.0).

Add MeshContainer and string-representation for Mesh objects.

Add a mesh-reader using meshio mesh.read(filename, ...).

Add SolidBodyNearlyIncompressible(umat, field, bulk) for (nearly) incompressible solids and a given (distortional-part only) constitutive material formulation. This is a pure displacement-based alternative to the three-field-formulation technique.

Changed

Support an optional user-defined meshio-object in Job().evaluate(mesh=None, filename="result.xdmf").

Support a distortional-part only Neo-Hookean material formulation with no bulk modulus defined NeoHooke(mu=1.0).

Fixed

Fix missing ArbitraryOrderLagrangeElement.points attribute.

Fix ignored mask only_surface=True for RegionBoundary().mesh.cells_faces.

Set default pressure to zero in SolidBodyPressure().

Take the mesh from the global x0-field if x0 is passed to job.evaluate(x0=...).

Fix missing update of global field x0 in job.evaluate(x0) after each completed substep.

Auto-Generated Release-Notes

What's Changed

Add points attribute to lagrange element by @adtzlr in https://github.com/adtzlr/felupe/pull/301

Add pre-compression to shear loadcase by @adtzlr in https://github.com/adtzlr/felupe/pull/305

Fix ignored surface mask for cells_faces of RegionBoundary by @adtzlr in https://github.com/adtzlr/felupe/pull/307

Add MeshContainer and string-representation for Mesh objects by @adtzlr in https://github.com/adtzlr/felupe/pull/312

Enhance Mesh-Container by @adtzlr in https://github.com/adtzlr/felupe/pull/313

Add mesh.read(filename, ...) by @adtzlr in https://github.com/adtzlr/felupe/pull/316

job.evaluate(x0=...): Take mesh from global field x0 if present by @adtzlr in https://github.com/adtzlr/felupe/pull/320

Add SolidBodyNearlyIncompressible(umat, field, bulk) by @adtzlr in https://github.com/adtzlr/felupe/pull/323

Fix missing update of x0 in job.evaluate(x0) after each completed substep by @adtzlr in https://github.com/adtzlr/felupe/pull/324

Full Changelog: https://github.com/adtzlr/felupe/compare/v5.2.0...v5.3.0
Source code(tar.gz)
Source code(zip)
v5.2.0(Oct 7, 2022)
Changelog since [5.1.0] - 2022-09-09

Added

Add xscale and yscale arguments to CharacteristicCurve.plot().

Add mesh.Grid(*xi) as generalized line, rectangle or cube with custom linspaces.

Add mesh.concatenate(meshes) to join a sequence of meshes with identical cell types.

Add x0 argument to Job.evaluate(x0=field).

Add mask argument to mesh.runouts(mask=slice(None)).

Add callback(stepnumber, substepnumber, substep) argument to CharacteristicCurve() (like in Job()).

Add an on-the-fly XDMF writer for a job (via meshio) Job.evaluate(filename="result.xdmf") with the possibility to add optional point_data and cell_data dicts.

Changed

Remove Warning if einsumt requirement is not found (switch to numpy without any warnings).

Requires Python 3.7+.

Fixed

Fix ignored axis argument of mesh.revolve(axis=1).

Auto-Generated Release-Notes

What's Changed

Add xscale and yscale arguments to CharacteristicCurve.plot() by @adtzlr in https://github.com/adtzlr/felupe/pull/281

Add mesh.Grid(*xi) and mesh.concatenate([mesh1, mesh2, ...]) by @adtzlr in https://github.com/adtzlr/felupe/pull/284

Add job.evaluate(x0=field) by @adtzlr in https://github.com/adtzlr/felupe/pull/286

Fix mesh.revolve(axis=1) by @adtzlr in https://github.com/adtzlr/felupe/pull/288

Add callback argument to CharacteristicCurve() by @adtzlr in https://github.com/adtzlr/felupe/pull/290

Remove Warning if einsumt is not installed by @adtzlr in https://github.com/adtzlr/felupe/pull/292

Add XDMF writer by @adtzlr in https://github.com/adtzlr/felupe/pull/294

Full Changelog: https://github.com/adtzlr/felupe/compare/v5.1.0...v5.2.0
Source code(tar.gz)
Source code(zip)
v5.1.0(Sep 8, 2022)
Changelog since [5.0.0] - 2022-08-21

Changed

Enhance Boundary: Select Points by value in addition to a callable (fx=lambda x: x == 0 is equivalent to fx=0), also add mode="and" and mode="or" argument.

Support line elements within the revolution function mesh.revolve().

Import previously hidden functions fun_items() and jac_items() as tools.fun() and tools.jac(), respectively (useful for numeric continuation).

Add step- and substep-numbers as arguments to the callback(stepnumber, substepnumber, substep)-function of a Job.

Auto-Generated Release-Notes

What's Changed

Enhance Boundary class by @adtzlr in https://github.com/adtzlr/felupe/pull/274

Support Line-elements within mesh.revolve() by @adtzlr in https://github.com/adtzlr/felupe/pull/276

Import fun_items() and jac_items() from felupe.tools._newton by @adtzlr in https://github.com/adtzlr/felupe/pull/277

Docs: Add numeric continuation tutorial with contique by @adtzlr in https://github.com/adtzlr/felupe/pull/278

Callback: Add args (step- and substep-numbers) by @adtzlr in https://github.com/adtzlr/felupe/pull/279

Full Changelog: https://github.com/adtzlr/felupe/compare/v5.0.0...v5.1.0
Source code(tar.gz)
Source code(zip)
v5.0.0(Aug 21, 2022)
Changelog since [4.0.0] - 2022-08-07

Added

Add SolidBodyGravity for body forces acting on a solid body.

Support list of linked fields in Newton-Rhapson solver newtonrhapson(fields=[field_1, field_2]).

Automatic init of state variables in SolidBodyTensor.

Add mesh.runouts() for the creation of runouts of rubber-blocks of rubber-metal structures.

Add FieldPlaneStrain which is a 2d-field and returns gradients of shape (3, 3) (for plane strain problems with 3d user materials).

Add PointLoad for the creation of external force vectors.

Add Step with a generator for substeps, Job and CharacteristicCurve.

Changed

Move MultiPointConstraint to mechanics module and unify handling with SolidBody.

Rename bodies argument of Newton-Rhapson solver to items (now supports MPC).

Return partitioned system as dict from loadcases loadcase=dict(dof0=dof0, dof1=dof1, ext0=ext0).

Check function residuals norm in newtonrhapson() instead of incremental field-values norm.

Fixed

Fix assembled vectors and results of SolidBodyPressure for initially defined pressure values.

Fix verbose=0 option of newtonrhapson().

Fix wrong assembly of axisymmetric mixed-fields due to introduced plane strain field-trimming.

Auto-Generated Release-Notes

What's Changed

Add SolidBodyGravity an Fix SolidBodyPressure by @adtzlr in https://github.com/adtzlr/felupe/pull/237

Modernize MultiPointConstraint by @adtzlr in https://github.com/adtzlr/felupe/pull/238

Improve loadcase by @adtzlr in https://github.com/adtzlr/felupe/pull/240

Newton-Rhapson: Support multiple fields by @adtzlr in https://github.com/adtzlr/felupe/pull/242

Newton remove fields arg by @adtzlr in https://github.com/adtzlr/felupe/pull/243

Fix multiple mixed subfields by @adtzlr in https://github.com/adtzlr/felupe/pull/245

Enhance SolidBodyTensor: Automatic init of statevars by @adtzlr in https://github.com/adtzlr/felupe/pull/247

Fix verbose of newton by @adtzlr in https://github.com/adtzlr/felupe/pull/249

Check function residuals norm in newton by @adtzlr in https://github.com/adtzlr/felupe/pull/251

Fix update of state variables in Newton-Rhapson by @adtzlr in https://github.com/adtzlr/felupe/pull/253

Add Mesh-tool mesh.runouts() by @adtzlr in https://github.com/adtzlr/felupe/pull/255

Add FieldPlaneStrain by @adtzlr in https://github.com/adtzlr/felupe/pull/257

Field Integration: Fix field-trimming for plane strain by @adtzlr in https://github.com/adtzlr/felupe/pull/260

Multiply force vector of gravity by -1 by @adtzlr in https://github.com/adtzlr/felupe/pull/262

Add PointLoad by @adtzlr in https://github.com/adtzlr/felupe/pull/263

Rename mask argument to points of point-load by @adtzlr in https://github.com/adtzlr/felupe/pull/266

Add Step, Job and CharacteristicCurve by @adtzlr in https://github.com/adtzlr/felupe/pull/270

Add missing import FieldPlaneStrain by @adtzlr in https://github.com/adtzlr/felupe/pull/272

Full Changelog: https://github.com/adtzlr/felupe/compare/v4.0.0...v5.0.0###
Source code(tar.gz)
Source code(zip)
v4.0.0(Aug 6, 2022)
Changelog since [3.1.0] - 2022-05-02

Added

Add SolidBody.evaluate.kirchhoff_stress() method. Contrary to the Cauchy stress method, this gives correct results in incompressible plane stress.

Add SolidBodyTensor for tensor-based material definitions with state variables.

Add bodies argument to newtonrhapson().

Add a container class for fields, FieldContainer (renamed from FieldMixed).

Add len(field) method for FieldContainer (length = number of fields).

Changed

Unify handling of Field and FieldMixed.

Constitutive models use lists as in- and output (consistency between single- and mixed-formulations).

Allow field updates directly from 1d sparse-solved vector without splitted by field-offsets.

Fixed

Fix tovoigt() helper for data with more or less than two trailing axes and 2D tensors.

Fix errors for force() and moment() helpers if the residuals are sparse.

Removed

Remove wrapper for matADi-materials (not necessary with field containers).

Remove IntegralFormMixed and IntegralFormAxisymmetric from global namespace.

Auto-Generated Release-Notes

What's Changed

Fix tovoigt() helper by @adtzlr in https://github.com/adtzlr/felupe/pull/219

Add SolidBody kirchhoff stress by @adtzlr in https://github.com/adtzlr/felupe/pull/221

Add SolidBodyTensor by @adtzlr in https://github.com/adtzlr/felupe/pull/224

Enhance newtonrhapson(): Add body argument by @adtzlr in https://github.com/adtzlr/felupe/pull/226

Newton-Rhapson: Remove body and add bodies argument by @adtzlr in https://github.com/adtzlr/felupe/pull/227

Unify handling of Field and FieldMixed by @adtzlr in https://github.com/adtzlr/felupe/pull/229

Add field-container length method by @adtzlr in https://github.com/adtzlr/felupe/pull/233

Docs: Fix tutorial "shear" by @adtzlr in https://github.com/adtzlr/felupe/pull/235

Full Changelog: https://github.com/adtzlr/felupe/compare/v3.1.0...v4.0.0
Source code(tar.gz)
Source code(zip)
v3.1.0(May 2, 2022)
Changelog since [3.0.0] - 2022-04-28

Added

Add optional parallel (threaded) basis evaluation and add Form(v, u, parallel=True).

Add mechanics submodule with SolidBody and SolidBodyPressure.

Fixed

Fix matADi materials for (mixed) axisymmetric analyses.

Fix missing radius in axisymmetric integral forms.

Auto-Generated Release-Notes

What's Changed

Enhance Basis: Parallel evaluation by @adtzlr in https://github.com/adtzlr/felupe/pull/212

Add mechanics submodule: SolidBody and SolidBodyPressure by @adtzlr in https://github.com/adtzlr/felupe/pull/216

Full Changelog: https://github.com/adtzlr/felupe/compare/v3.0.0...v3.1.0
Source code(tar.gz)
Source code(zip)
v3.0.0(Apr 28, 2022)
Changelog since [2.0.1] - 2022-01-11

Added

Add sym argument to Bilinearform.integrate() and Bilinearform.assemble().

Add FieldsMixed which creates a FieldMixed of length n based on a template region.

Add function to mirror a Mesh mesh.mirror().

Add a new parallel assembly that uses a threaded version of np.einsum instead (einsumt).

Add parallel versions of math helpers (dya, cdya, dot, ddot) using einsumt.

Add parallel keyword to constitutive models (NeoHooke, LinearElasticTensorNotation and ThreeFieldVariation).

Add RegionBoundary along with template regions for Quad and Hexahedron and GaussLegendreBoundary.

Add optional normal vector argument for function and gradient methods of AreaChange.

Add a new Mesh-tool triangulate(), applicable on Quad and Hexahedron meshes.

Add a new Mesh-method Mesh.as_meshio().

Add a function decorator @Form(...) for linear and bilinear form objects.

Changed

Enforce consistent arguments for functions inside mesh (points, cells, cell_data or Mesh).

Rename Numba-parallel assembly to jit.

Move single element shape functions and their derivatives from region.h to region.element.h and region.dhdr to region.element.dhdr.

Repeat element shape functions and their derivatives for each cell (as preparation for an upcoming RegionBoundary).

Improve mesh.convert() by using the function decorator @mesh_or_data.

Allow an array to be passed as the expansion arguments of mesh.expand() and mesh.revolve().

Allow optional keyword args to be passed to Mesh.save(**kwargs), acts as a wrapper for Mesh.as_meshio(**kwargs).write().

Fixed

Fix area normal vectors of RegionBoundary.

Fix integration and subsequent assembly of BilinearForm if field and mesh dimensions are not equal.

Auto-Generated Release-Notes

What's Changed

Add sym argument to Bilinearform.integrate() and Bilinearform.assemble() by @adtzlr in https://github.com/adtzlr/felupe/pull/186

Add FieldsMixed by @adtzlr in https://github.com/adtzlr/felupe/pull/190

Update coverage.yml: Add Python 3.10 by @adtzlr in https://github.com/adtzlr/felupe/pull/182

Rename keyword parallel to jit, introduce new parallel, improved Mesh-tools by @adtzlr in https://github.com/adtzlr/felupe/pull/195

Preparations for RegionBoundary by @adtzlr in https://github.com/adtzlr/felupe/pull/196

Add a region on the boundary faces/edges on a mesh by @adtzlr in https://github.com/adtzlr/felupe/pull/197

Improve AreaChange by @adtzlr in https://github.com/adtzlr/felupe/pull/198

Add axisymmetric argument to FieldsMixed by @adtzlr in https://github.com/adtzlr/felupe/pull/199

Add Mesh-Tool: triangulate() by @adtzlr in https://github.com/adtzlr/felupe/pull/202

Improve Mesh-tool convert() by @adtzlr in https://github.com/adtzlr/felupe/pull/203

Improve Mesh by @adtzlr in https://github.com/adtzlr/felupe/pull/204

Fix dimensions of value-array in assembly of BilinearForm by @adtzlr in https://github.com/adtzlr/felupe/pull/206

Add function decorator for weakforms by @adtzlr in https://github.com/adtzlr/felupe/pull/208

Change Forms How-To by @adtzlr in https://github.com/adtzlr/felupe/pull/209

Simplify How-To on Forms by @adtzlr in https://github.com/adtzlr/felupe/pull/210

Full Changelog: https://github.com/adtzlr/felupe/compare/v2.0.1...v3.0.0
Source code(tar.gz)
Source code(zip)
v2.0.1(Jan 11, 2022)
Changelog since [2.0.0] - 2022-01-10

Fixed

Fixed wrong result of assembly generated by a parallel loop with prange.

Source code(tar.gz)
Source code(zip)
v2.0.0(Jan 10, 2022)
Changelog since [1.6.0] - 2021-12-02

Added

Add a new method to deepcopy a Mesh with Mesh.copy()

Add broadcasting capability for trailing axes inside the parallel form integrators.

Add Basis on top of a field for virtual fields used in linear and bilinear forms.

Add LinearForm and BilinearForm (including mixed variants) for vector/matrix assembly out of weak form expressions.

Add parallel keyword for threaded integration/assembly of LinearForm and BilinearForm.

Changed

Enhance Boundary for the application of prescribed values of any user-defined Field which is part of FieldMixed.

The whole mixed-field has to be passed to dof.apply() along with the offsets returned from dof.partition for mixed-field formulations.

Set default value shape=(1, 1) for hessian() methods of linear elastic materials.

Fixed

Fixed einstein summation of math.dot() for two vectors with trailing axes.

Removed

Remove dof.extend because dof.partition does not need it anymore.

Source code(tar.gz)
Source code(zip)
v1.6.0(Dec 2, 2021)
Changelog since [1.5.0] - 2021-11-29

Added

Add LinearElasticPlaneStress and LinearElasticPlaneStrain material formulations.

Add region argument for LinearElastic.hessian().

Changed

Re-formulate LinearElastic materials in terms of the deformation gradient.

Re-formulate LinearElastic material in matrix notation (Speed-up of ~10 for elasticity matrix compared to previous implementation.)

Move previous LinearElastic to constitution.LinearElasticTensorNotation.

Source code(tar.gz)
Source code(zip)
v1.5.0(Nov 29, 2021)
Changelog since [1.4.0] - 2021-11-15

Added

Add kwargs of field.extract() to fun and jac of newtonrhapson.

Changed

Set default number of threads in MatadiMaterial to multiprocessing.cpu_count().

Moved documentation to Read the Docs (Sphinx).

Fixed

Fix dim in calculation of reaction forces (tools.force) for FieldMixed.

Fix calculation of reaction moments (tools.moment) for FieldMixed.

Source code(tar.gz)
Source code(zip)
v1.4.0(Nov 15, 2021)
Changelog since [1.3.0]

[1.4.0] - 2021-11-15

Added

Add mask argument to Boundary for the selection of user-defined points.

Add shear loadcase.

Add a wrapper for matadi materials as MatadiMaterial.

Add verbose and timing arguments to newtonrhapson.

Fixed

Obtain internal dim from Field in calculation of reaction force tools.force.

Fix math.dot for combinations of rank 1 (vectors), rank 2 (matrices) and rank 4 tensors.

Source code(tar.gz)
Source code(zip)
v1.3.0(Nov 2, 2021)
Changelog since [1.2.0]

[1.3.0] - 2021-11-02

Changed

Rename mesh.as_discontinous() to mesh.disconnect().

Rename constitution.Mixed to constitution.ThreeFieldVariation.

Rename unstack to offsets as return of dof-partition and all subsequent references.

Import tools (newtonrhapson, project, save) and constitution (NeoHooke, LinearElastic and ThreeFieldVariation) to FElupe's namespace.

Change minimal README-example to a high-level code snippet and refer to docs for details.

Source code(tar.gz)
Source code(zip)
v1.2.0(Oct 31, 2021)
Changelog since [1.1.0]

[1.2.0] - 2021-10-31

Added

Add template regions, i.e. a region with a Hexahedron() element and a quadrature scheme GaussLegendre(order=1, dim=3) as RegionHexahedron, etc.

Add biaxial and planar loadcases (like uniaxial).

Add a minimal README-example (Hello FElupe!).

Changed

Deactivate clamped boundary (clamped=False) as default option for uniaxial loading dof.uniaxial

Source code(tar.gz)
Source code(zip)
v1.1.0(Oct 30, 2021)
Changelog since [1.0.1]

[1.1.0] - 2021-10-30

Added

Add inverse quadrature method quadrature.inv() for Gauss-Legendre schemes.

Add discontinous representation of a mesh as mesh method mesh.as_discontinous().

Add tools.project() to project (and average) values at quadrature points to mesh points.

Changed

Removed quadpy dependency and use built-in polynomials of numpy for Gauss-Legendre calculation.

Fixed

Fix typo in first shear component of math.tovoigt() function.

Fix wrong stress projection in tools.topoints() due to different quadrature and cell ordering.

Source code(tar.gz)
Source code(zip)
v1.0.1(Oct 19, 2021)
Changelog

[1.0.1] - 2021-10-19

Fixed

Fix import of dof-module if sparse is not installed.

Source code(tar.gz)
Source code(zip)
v1.0.0(Oct 19, 2021)
Changelog of [1.0.0] - 2021-10-19

Added

Start using a Changelog.

Added docstrings for essential classes, methods and functions.

Add array with point locations for all elements.

Changed

Rename element methods (from basis to function and from basisprime to gradient).

Make constitutive materials more flexible (allow material parameters to be passed at stress and elasticity evaluation umat.gradient(F, mu=1.0)).

Rename ndim to dim.

Simplify element base classes.

Speed-up calculation of indices (rows, cols) for Fields and Forms (about 10x faster now).

Update test_element.py according to changes in element methods.

Removed

Automatic check if the gradient of a region can be calculated based on the dimensions. The grad argument in region(grad=False) has to be enforced by the user.

Source code(tar.gz)
Source code(zip)
v0.1.1(Oct 4, 2021)

First BETA release of FElupe 🥇

A lot of unused, undocumented or deprecated features have been removed. Test coverage is now > 97%. Docs have been simplified, re-tested and enhanced. The code structure is now easier to understand as all sub-modules are located in subfolders. Constitution has been simplified, Automatic Differentation capability is now outsourced to a separate package matadi.

Have fun 🏖️
Source code(tar.gz)
Source code(zip)
v0.0.11(Sep 15, 2021)
Changelog

Bugfixes:

fix MINI element by using a non-normalized bubble function r*s*t*(1-r-s-t) [1]. This prevents convergence problems.

Enhancements:

allow user-defined bubble-multiplier for MINI element

add point_data and cell_data to save option

add MultiPointContact (no friction), similar to MultiPointConstraint

add new three-field (Grad(u), P, F) template for Materials with automatic differentiation using CasADi

IntegralForm (lineaform): allow arbitrary dimension of fun if grad_v=None (non-parallel only)

add grad argument to Region (default is True)

add FieldMixed class for mixed-field problems

split huge source files into several smaller files

Source code(tar.gz)
Source code(zip)
v0.0.10(Aug 26, 2021)

Now all IntegralForms have the same arguments.
Source code(tar.gz)
Source code(zip)
v0.0.9(Jul 30, 2021)
Introduce Automatic Differentation Capability (via casADi)

felupe.constitution now contains ad.Material, ad.Materialup and ad.MaterialupJ for single-, two- and three-field formulations. Only the strain energy density function has to be defined - stress and elasticity tensors are created by automatic differentiation.

Example usage: Neo-Hookean material model

import felupe as fe import casadi as ca def W(F, mu, bulk): "Strain energy density function for Neo-Hookean material formulation." J = ca.det(F) C = F.T @ F I_C = ca.trace(C) return mu / 2 * (I_C * J ** (-2 / 3) - 3) + bulk / 2 * (J - 1) ** 2 umat = fe.constitution.ad.Material(W, mu=1.0, bulk=2.0) P = umat.f(F) A = umat.A(F)
Source code(tar.gz)
Source code(zip)