Introduce a method for transforming a connected mesh into a disconnected mesh. Template code:

import numpy as np
from felupe import Mesh


def as_discontinous(self):
    points = self.points[self.cells].reshape(-1, self.dim)
    cells = np.arange(self.cells.size).reshape(*self.cells.shape)
    return Mesh(points, cells, cell_type=self.cell_type)

...in order to convert a mesh for the usage with quadratic elements (Quad8, Tria6, Tetra10 and Hexahedron20)

Felupe's core code base has now evolved in a way that it should not change too much in the future. Now it would be a good time to add tests and evaluate coverage...

I think this function is not used in felupe.

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:

• For linear quadratures the point ordering should be permuted in order to match cell ordering.
• add a tools.project function for the stress projection to mesh-points (basically the code-snippet above)
• argument to average results
• add tools.project() to Getting Started Example (see tests)
• check axisymmetric stress result
• add permute for Gauss-Legendre order=2 dim=3

Easy fix: don't calculate the inverse to allow the creation of such Regions.

Better express what this function does. It disconnects all elements.

PyPardiso was removed in 3b4806d because it can't be installed via pip. (dependancy mkl-service is missing, see haasad/PyPardiso#24).

If someone would like to use pypardiso, install it the recommended way and specify the solver argument in felupe.solve.solve.

import pypardiso

# user code

felupe.solve.solve(*system, solver=pypardiso.spsolve)

Due to the usage of np.unique the nodes are getting sorted. There should be at least an option to disable the sorting (which should then be the default mode). As Numpy does not provide an option this will require some work. Pandas provide a unique function too but returns no inverse index array.

change to region.mesh.cells

casADi's implementation of eig_symbolic returns nan if a matrix contains repeated eigenvalues.

Mesh generators are too complicated for now. There should be only 2d generators (rectangles, disks). Cubes or cylinders (with a hole) should only be expansions or revolutions from 2d sections. The scaled versions of Rectangle and Cube should be created with a scale function.

Make this function actually usable for both single- and mixed-field problems.

• add default fun
• add default jac
• add default solve
• add default check
• add tests

Better explain the calculation of cauchy stresses and the usage of pypardiso in the getting started example. Add this example to the test suite.

numpy upper triangle indices are hardcoded for three-field-formulations. Change this to the number of passed fields...

self.i, self.j = np.triu_indices(3)

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.

As discussed in here,

• add support for linear & quadratic Triangle (Tri1, Tri2) and Tetrahedron (Tet1, Tet2) elements

progress:

• Tri1
• Tri2
• Tet1
• Tet2

Status: experimental

The current poisson example should be simplified to a one-dimensional field. As this was not possible in the past, the example is based on a 2d field. However, this is possible since #37 and should be adopted now.

• add a laplace-helper function to the math module which takes a field as argument felupe.math.laplace(field)

Field values can be updated with field += dxbut not withfield = field + dx. This is because Field.add()returnsNone.`

according to #19 some wordings have to be adopted.

Go through all files and unify namings.

Overview of tasks...

• mesh.py (see 810f82f)
• doftools.py (see 875d9e8)
• element.py (see 66552d4)
• field.py (see 6fa911b)
• forms.py (see 716ce21)
  - [x] math.py
  - [x] quadrature.py
• region.py (see 90a8838)
  - [x] solve.py
• utils.py (see b32ee30)

in fe.element.Hex2s() the basis function derivative is wrong. This leads to an error.

Across felupe classes, several attributes have different names, e.g. ndim and dim. This issue serves as a collection of them.

Dimensions

Try to implement mixed-field formulations for axisymmetric problems.

First Task would be to merge IntegralFormAxisymmetric into IntegralForm. This should be done by adding a kind="axi" attribute to FieldAxisymmetric and then perform the adopted assemblage.

• add kind attribute to Field
• check kind of field in IntegralForm and adopt integrate and assemble methods
  - [ ] remove IntegralFormAxisymmetric class

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!

The idea is to introduce Region templates, i.e. RegionHexahedron, RegionQuad, etc.

These template Regions have pre-defined elements and quadratures and are shorter to use.

it seems that u[dof0] - u0ext is not updated...

Also set clamped=False because this is the real homogenous loadcase. Of course, for these loading situations a finite element analysis doesn't make too much sense. They just serve as a reference implementation of some simple loadcases.

as RBE2, Penalty Method, see here

modify LinearElastic(E, nu).elasticity(strain) to LinearElastic(E, nu).elasticity(strain, stress=None) in order to calculate the initial stress contribution of the elasticity if the stress argument is passed.

This file was created to seperate some linear algebra functions for symmetrc matrices. However, these (simpler) calculations are now in math.py, where some functions have an optional sym argument.

There is a typo in converting stress (3,3) to stress (6)

ij = [(0, 0), (1, 1), (2, 2), (0, 0), (1, 2), (0, 2)]

should be

ij = [(0, 0), (1, 1), (2, 2), (0, 1), (1, 2), (0, 2)]

instead.

In order that FElupe works without all the optional dependencies it is necessary to wrap import sparse into a try/except statement.

and here

• quadrature.order was removed and hence, the order for the 3d quadrature can't be evaluated.
• element class names are not available anymore (Quad1 -> Quad, Hex1 -> Hexahedron)

As mentioned in #92 quadpy increases the import time drastically. We can drop that dependency and use built-in functions of numpy.

Add a new inv() method for GaussLegendre quadrature schemes.

Add docstrings and comments to code.

Overview

• doftools.py
• element.py
• field.py
• forms.py
• math.py
• quadrature.py
• solve.py
• utils.py
• region.py

E.g. if a one-dimensional field is applied on a 2d quad-mesh, there are Errors due to dimension mismatch.

It seems that C, F, J are not passed to the subsequent materials AsIsochoric, etc.

Several tasks have to be done here. Currently tools.py (newer) and utils.py (older) both contain useful tools/utilities - some are outdated, some need to be tweaked, etc. In the end, only one file should be kept.

Tasks

• improve tools.py
• merge utils.py -> tools.py
• delete utils.py

During the design of FElupe, the intention was to create a single function for both LinearForm and BilinearForm, called IntegralForm. Unfortunately, this introduced the separate creation of IntegralFormMixed, as things are slightly different here. The idea is to unify IntegralForm and IntegralFormMixed into a single IntegralFormGeneralized class.

IntegralForm(fun, v, dV, grad_v=False, u=None, grad_u=False)

Also, the grad_v argument should be placed in front of u, so that one can code a Lineaform as

IntegralForm(fun, v, dV, True)

...No, keep it as it is.

For mixed formulations, fun is a list whereas for single-field formulations fun is casted into a length-one list. The same applies for the test- and trial-fields v and u. If v is a list or a tuple, then grad_v must also be of the same length, i.e. grad_v=(True, False, False). Inside this new IntegralFormGeneralized the code is 💯% the same for both single and mixed field formulations.

as felupe.doftools.uniaxial(field, right, move, clamped=True)

and use it as

boundaries, dof0, dof1, u0ext = fe.doftools.uniaxial(displacement, right=1.0, move=0.4, clamped=False)

should be similar to vtk cell types...

• Line, Triangle, Quad, Tetrahedron and Hexahedron for the linear elements
• QuadraticTriangle, QuadraticTetrahedron and QuadraticTetrahedron for quadratic elements with edge-based midpoints
• TriQuadraticHexahedron for quadratic lagrange-type hexahedron with mid-faces and mid-volume points
• ArbitraryOrderLagrange for "VTK_LAGRANGE_QUAD" or "VTK_LAGRANGE_HEXAHEDRON"

A field cannot be accessed with a slice. However, this could sometimes be convenient. Take the following code:

displacement = fe.Field(region, dim=3)

# this is the current way to obtain "u1"
u1 = displacement.values.ravel()[dof1]

# this should be possible...
u1 = displacement[dof1]

calculate symmetric part of displacement gradient in voigt notation

• dim = 2-> 3 strain components
• dim = 3 -> 6 strain components

As the Newton-Rhapson algorithm is frequently used, it would be a great addition to felupe to have a flexible template function. It should be able to

• handle both

• single and
• mixed field formulations

• let the user pass a function and its jacobian along with a given state of equilibrium
• both the input variables (unknowns) and the output (equilibrium residuals) should be able to be pre- and postprocess-able
• the result should be stored in a Result class, similar to scipy.optimize

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

Tasks:

• generate a fix function which can be applied to both triangle and tetrahedral meshes
• add quadrature rules for linear/quadratic triangle/tetrahedrons

must have happened in #12

Tet10 element implementation is currently broken