I’m excited to share a major advancement in OOFEM’s multiphysics module (mpm). The new symbolic term feature enables you to define individual terms directly in input files using mathematical expressions—eliminating the need for hard-coded term libraries.

Key Innovation: Expression Compiler & Virtual Machine

The implementation includes:

• Internal Expression Compiler: Parses symbolic expressions with support for matrix algebra and mathematical operators
• Virtual Machine Evaluation: Expressions are compiled once into optimized “code” for efficient runtime evaluation
• Rich Operator Library: Predefined operators (functors) for divergence, gradient, field interpolation, and more

This approach combines the flexibility of symbolic definitions with the performance of compiled code execution.

Example 1: 1D Heat Transport

Let’s start with a simple example of 1D stationary heat transport:

Weak Form

The weak form can be written as

Variable Definition

Define the variables appearing in the weak form:

Variable name "t" interpolation "feilin" type 1 quantity 0 size 1 dofs 1 10 # temperature 
Variable name "dt" interpolation "feilin" type 1 quantity 0 size 1 dofs 1 10 # test function temperature

Symbolic Term Definition

Instead of relying on hard-coded terms, we use the SymbolicTerm directive. For term $T_1$:

SymbolicTerm 1 variable "t"  testvariable "dt" mmode 25 lexpression "Grad(dt,gp).T*[[1.0]]*Grad(t,gp)" rexpression "Grad(dt,gp).T*[[1.0]]*Grad(t,gp)*ru(t, cell, ts)"

Expression Components:

• rexpression: Defines the weak form residual term
• lexpression: Defines the linearization with respect to the trial variable (for Newton iterations)
• variable: Trial variable to solve for
• testvariable: Test function for weak form

Built-in Operators Used:

• Grad(var, gp): Evaluates gradient at Gauss point (e.g., $\nabla N^{e}(x_{gp}) $)
• ru(var, cell, ts): Retrieves nodal unknown values for variable at current cell and time step
• N(var, gp): Interpolation matrix $N^e(x_{gp})$ at Gauss point

Heat Source Term $T_3$ (for $Q=1$):

Note that this term requires no linearization since it doesn’t depend on the unknown field:

SymbolicTerm 2 variable "t"  testvariable "dt" mmode 25 lexpression "0.0" rexpression "N(w,gp).T*[[1.0]]" # constant heat source

The complete example is available in the tests/regression/mpm/mpms06.in test case.

Example 2: Multiphysics—Incompressible Elasticity

The symbolic term concept extends naturally to multiphysics problems. Here we illustrate the mixed formulation of incompressible elasticity with pressure and displacement fields:

The weak form of the above equations can be written as \(\int_\Omega\overbrace{2\mu\nabla^sw:\rm{dev}[\nabla^su]}^{T_1}\ d\Omega-\int_\Omega\overbrace{ \nabla\cdot w\ p}^{T_2}\ d\Omega=\int_{\Gamma_t}\overbrace{w\cdot \bar t}^{T_5}\ d\Gamma\)

Weak Form of Mixed u-p Formulation

This is a classic mixed finite element formulation for incompressible media.

Problem Variables

• $u, p$: Unknown displacement and pressure fields
• $w, q$: Corresponding test functions

Symbolic Input Syntax

Variables are defined in the input deck as:

Variable name "u" interpolation "feiquad" type 1 quantity 0 size 2 dofs 2 1 2 
Variable name "w" interpolation "feiquad" type 1 quantity 0 size 2 dofs 2 1 2 
Variable name "p" interpolation "feilin"  type 0 quantity 3 size 1 dofs 1 11  
Variable name "q" interpolation "feilin" type 0 quantity 3 size 1 dofs 1 11 

Field Definitions:

• Fields ($u, w$): Quadratic interpolation (feiquad), vector fields (type 1), 2 DOFs (x and y components of displacement vector)
• Pressure fields ($p, q$): Linear interpolation (feilin), scalar fields (type 0)

Defining Weak Form Terms

Each component of the weak form is defined as a SymbolicTerm:

Term $T_1$: Stiffness—displacement test function and displacement unknown, plain strain (mmode 7)

SymbolicTerm 1 variable "u"  testvariable "w" mmode 7 \
  lexpression "B(w,gp).T*Dm_dev(gp,ts)*B(u,gp)" \
  rexpression "B(w,gp).T*Sig_dev(u,gp,ts)"

Where B(var,gp) is the strain-displacement matrix and Dm_dev/Sig_dev are deviatoric material stiffness and stress operators.

Term $T_2$: Coupling—displacement test and pressure unknown, plain strain (mmode 7)

SymbolicTerm 2 variable "p"  testvariable "w" mmode 7 \
  lexpression "Div(w,gp).T*N(p,gp)" \
  rexpression "Div(w,gp).T*N(p,gp)*ru(p, cell, ts)"

Where Div(var,gp) computes divergence at the Gauss point.

Terms $T_3$ and $T_4$: Pressure test—displacement and pressure unknowns:

SymbolicTerm 3 variable "u"  testvariable "dp" mmode 7 \
  lexpression "N(dp,gp).T*Div(u,gp)" \
  rexpression "N(dp,gp).T*Div(u,gp)*ru(u, cell, ts)"

SymbolicTerm 4 variable "p"  testvariable "dp" mmode 7 ctype 27 uvmt 1 \
  lexpression "N(dp,gp).T*2.4000000000024e-7*N(p,gp)" \
  rexpression "N(dp,gp).T*2.4000000000024e-7*N(p,gp)*ru(p, cell, ts)"

Integration Definition

Terms are integrated over specific domains ($\Omega,\ \Gamma_t$) using predefined sets:

Integral 1 domain 1 set 1 term 1
Integral 2 domain 1 set 1 term 2 factor -1.0
Integral 3 domain 1 set 1 term 3 factor -1.0
Integral 4 domain 1 set 1 term 4 
Integral 5 domain 1 set 2 term 5

The complete example is available in the tests/regression/mpm/mpms_cook2_u2p1.in test case.

Why Symbolic Terms Matter

This symbolic approach offers significant advantages:

1. Flexibility: Define custom physics without modifying core libraries
2. Readability: Mathematical expressions directly mirror the weak form on paper
3. Performance: One-time compilation produces optimized VM bytecode
4. Maintainability: Physics definitions live in input files, not scattered across C++ code
5. Extensibility: Easy to add new operators and mathematical constructs

Conclusion

The new symbolic term feature with expression compiler and virtual machine represents a paradigm shift for OOFEM’s multiphysics capabilities. By combining mathematical expressiveness with compiled execution efficiency, it enables researchers to rapidly prototype and deploy new coupled formulations without the overhead of C++ development.

Stay tuned for further enhancements to the symbolic framework!

Feel free to share feedback or questions in the comments section below.

OOFEM supports Python scripting through its Python bindings, enabling users to write scripts, develop custom elements, material models, and solvers—all in Python. Thanks to recent advancements, OOFEM and its binding code can now be compiled into a WebAssembly (WASM) Python module.

By leveraging Pyodide (a WebAssembly-based Python distribution for browsers and Node.js) and JupyterLite (a browser-based version of JupyterLab), you can now run and interact with OOFEM entirely within your web browser—no installation needed.

While this might seem like a lightweight demo, it actually unlocks powerful new opportunities for teaching, training, and getting started with finite element analysis. It’s especially useful for educational settings or for newcomers exploring OOFEM for the first time.

Check out the OOFEM python tutorial and try out the browser-based examples directly—no setup required!

The support by Václav Šmilauer is highly acknowledged.

With this we conclude today post on oofem JupyterLite integration. Hope you enjoyed and stay tuned for following updates!

You are welcome to leave a comment below to give a feedback.

A formulation of the elasticity problem able to represent the incompressible behavior can be written using mixed approach involving pressure and displacement fields

The weak form of the above equations can be written as \(\int_\Omega\overbrace{2\mu\nabla^sw:\rm{dev}[\nabla^su]}^{T_1}\ d\Omega-\int_\Omega\overbrace{ \nabla\cdot w\ p}^{T_2}\ d\Omega=\int_{\Gamma_t}\overbrace{w\cdot \bar t}^{T_3}\ d\Gamma\)

where

• $u, p$ are unknown displacement and pressure fields (Variables).
• $w, q$ are test fields (Variables) In order to obtain stable results, the approximations should satisfy Babuška-Brezzi condition or some form of stabilization would be required. To satisfy the B-B condition, the approximation order of displacement should be higher than that of hydrostatic pressure. In the following we will consider 2D case.

In the input deck, the Variables ($u,p,w,q$) can be set up using following syntax

Variable name "u" interpolation "feilin" type 1 quantity 0 size 2 dofs 2 1 2 
Variable name "w" interpolation "feilin" type 1 quantity 0 size 2 dofs 2 1 2 
Variable name "p" interpolation "feiconst"  type 0 quantity 3 size 1 dofs 1 11  
Variable name "q" interpolation "feiconst" type 0 quantity 3 size 1 dofs 1 11 

where interpolation determines the interpolation used for specific field. Here we use linear approximation (interpolation “feilin”) for displacement field and related test field and constant approximation (interpolation “feiconst”) for pressure (so called Q1P0 element). The $u, w$ fields are vector fields (type 1) with physical meaning of displacement (quantity 0) and two degrees of freedom (size 2 dofs 2 1 2). And $p, q$ are scalar fields (type 0) with physical meaning of pressure (quantity 3 size 1 dofs 1 11).

The weak form above consists of several terms to be evaluated

• $T_1$: This is represented by BTSigmaTerm, evaluated for $w$ test field and $u$ as unknown field, under plain strain assumptions (mmode 7) and considering deviatoric part only (lhsmatmode 29)

  BTSigmaTerm 1 variable "u"  testvariable "w" mmode 7 lhsmatmode 29
  

• $T_2$: represented by BTamNTerm, evaluated for $w$ test field and $u$ as unknown field, under plain strain assumptions (mmode 7) and with scalar parameter equal to 1.0 (atype 28)

  BTamNTerm 2 variable "p" testvariable "w" mmode 7 atype 28
  

• Similarly, we set up remaining three terms $T_3, T_4=T_2^T$ and $T_5$:

  NTamTBTerm 3 variable "u" testvariable "q" mmode 7 atype 28
  NTcN 4 variable "p" testvariable "q" mmode 7 ctype 27
  NTfTerm 5 variable "u" testvariable "w" mmode 6 flux 2 0. 6.25
  

  The terms are integrated over specific domains ($\Omega,\ \Gamma_t$), defined using corresponding sets (defined bellow in the example):

  Integral 1 domain 1 set 1 term 1
  Integral 2 domain 1 set 1 term 2 factor -1.0
  Integral 3 domain 1 set 1 term 3 factor -1.0
  Integral 4 domain 1 set 1 term 4 factor -1.0
  Integral 5 domain 1 set 2 term 5
  

  Example: Cook membrane

  The Cook’s membrane is a standard benchmark problem. It consists of a tapered plate clamped on one of its sides with a transversal distributed load applied to the opposite side. The plate is in plain strain and its dimensions, as well as the material parameters and boundary conditions, are shown in figure bellow

The complete OOFEM input deck for mesh consisting of 2x2 is shown below

cook2.out
Demo of symbolic mpm problem; Cook membrane benchmark
# 
test nsteps 1 nvariables 4 nterms 5 nintegrals 5 lhsterms 4 1 2 3 4 rhsterms 1 5
Variable name "u" interpolation "feilin" type 1 quantity 0 size 2 dofs 2 1 2 # displacement 
Variable name "w" interpolation "feilin" type 1 quantity 0 size 2 dofs 2 1 2 # test function
Variable name "p" interpolation "feiconst"  type 0 quantity 3 size 1 dofs 1 11 # pressure 
Variable name "q" interpolation "feiconst" type 0 quantity 3 size 1 dofs 1 11 # test function
BTSigmaTerm 1 variable "u"  testvariable "w" mmode 7 lhsmatmode 29
BTamNTerm 2 variable "p" testvariable "w" mmode 7 atype 28
NTamTBTerm 3 variable "u" testvariable "q" mmode 7 atype 28
NTcN 4 variable "p" testvariable "q" mmode 7 ctype 27
NTfTerm 5 variable "u" testvariable "w" mmode 6 flux 2 0. 6.25
#NTfTerm 5 variable "u" testvariable "w" mmode 6 flux 2 0. 31.25
Integral 1 domain 1 set 1 term 1
Integral 2 domain 1 set 1 term 2 factor -1.0
Integral 3 domain 1 set 1 term 3 factor -1.0
Integral 4 domain 1 set 1 term 4 factor -1.0
Integral 5 domain 1 set 2 term 5
domain HeatTransfer
outputmanager tstep_all dofman_all element_all
ndofman 9 nelem 6 nbc 1 ncrosssect 1 nic 0 nltf 2 nmat 1 nset 3
Node 1 coords 3 0.0 0.0 0.0
Node 2 coords 3 24.0 22.0 0.0
Node 3 coords 3 48.0 44.0 0.0
Node 4 coords 3 0.0 22.0 0.0
Node 5 coords 3 24.0 37.0 0.0
Node 6 coords 3 48.0 52.0 0.0
Node 7 coords 3 0.0 44.0 0.0
Node 8 coords 3 24.0 52.0 0.0
Node 9 coords 3 48.0 60.0 0.0
q1 1 nodes 4 1 2 5 4 mat 1 crosssect 1
q1 2 nodes 4 2 3 6 5 mat 1 crosssect 1
q1 3 nodes 4 4 5 8 7 mat 1 crosssect 1
q1 4 nodes 4 5 6 9 8 mat 1 crosssect 1
l1 5 nodes 2 3 6 mat 1 crosssect 1
l1 6 nodes 2 6 9 mat 1 crosssect 1
simplecs 1 thick 5.0
isole 1 d 1 e 250 n 0.49999 talpha 1.
# clamped-displacement
boundarycondition 1 loadtimefunction 1 set 3 values 2 0 0   dofs 2 1 2
constantfunction 1 f(t) 1
PiecewiseLinFunction 2 nPoints 4 t 4 -10. 0. 1. 5. f(t) 4 0. 0. 1.0 1.0
set 1 elementranges  {(1 4)}
set 2 elementranges  {(5 6)}
set 3 elementedges 4 1 4 3 4

The complete input deck can be found in tests/mpm/cook2_u1p0.in file.

Switching to high-order interpolation

To switch to high order element Q2P1 with quadratic interpolation of displacement and linear interpolation of pressure we need just to use different interpolations for variables. The updated variable input records are following

Variable name "u" interpolation "feiquad" type 1 quantity 0 size 2 dofs 2 1 2 # displacement 
Variable name "w" interpolation "feiquad" type 1 quantity 0 size 2 dofs 2 1 2 # test function
Variable name "p" interpolation "feilin"  type 0 quantity 3 size 1 dofs 1 11 # pressure 
Variable name "q" interpolation "feilin" type 0 quantity 3 size 1 dofs 1 11 # test function

The complete input deck can be found in tests/mpm/cook2_u2p1.in file.

Note: At the time of writing, the oofem version from mpm2 branch is required to run the example.

To illustrate the convergence, sequence of uniform meshes of the plate is considered, starting from a mesh consisting of a single elements and proceeding by uniform refinement.

The figure below shows the vertical displacement of the plane tip plotted against the number of element segments along each side. The solution is compared to reference solution ¹.

With this I conclude today post on mpm module. Hope you enjoyed and stay tuned for following updates!

You are welcome to leave a comment below to give a feedback.

References

What is MPM? MPM is new multi-physic OOFEM module, developed to make implementation of multi-physics problems more simple. In this tutorial we will focus on symbolic MPM extension. This extension is somehow different from traditional OOFEM modules.

In traditional OOFEM problem setup, the user discretizes the problem using problem-specific elements, boundary conditions, etc. that provide necessary functionality to solve the problem. On the other hand, the symbolic MPM module allows to use universal, problem independent elements. These elements just define geometry. What is going to be evaluated is defined using Terms, that are evaluated on elements and integrated using Integrals. Terms can be evaluated on any element using user defined Interpolations. In this way, the problem definition is more like defining the weak form of the problem.

The basic design ideas behind MPM are following:

• MPM defines Interpolations, Variables, Terms, Integrals as reusable blocks to create multiphysics formulations
• Variables represent unknown fields (or test felds) in a weak form of the problem. The variable has its interpolation, type (scalar, vector) and physical meaning defined.
• Terms represent an integrand in weak formulation to be evaluated (integrated). Term definition is independent on underlying element geometry and interpolation. It defines two key methods:
  • method to evaluate the term value, typically contributing to RHS of discrete system.
  • method to evaluate the consistent linearization of the term, so if Term is T(u), depending on unknown u, this term evaluates dT/du, which typically contributes to the LHS.
• Interpolations are representing different FE interpolations.
• Integral represents the integral of term in a weak form. It can compute its contributions to the discrete set of equations.

The concept allows for parametrization with different element geometries and interpolations. Also, the components (interpolations, terms) can be reused/shared between different formulations. In the previous post on mpm module I have introduced the Python interface of MPM module. In this post, I will illustrate mpm features on example set-up from traditional OOFEM input deck.

We will consider the same linear 2D elasticity problem, defined by following weak form of equilibrium equations:

where

• u,w are variables (fileds), represented by Variable class instances
• $\left[ (\partial w)^T \sigma (\partial u)\right] $ and $\left[ (w)^Tt \right]$ are Terms, parametrized (to be evaluated) by u,w, represented by classes BTSigmaTerm and NTfTerm (derived from parent Term class).

When term is evaluated, the interpolations of the test and unknown fields as well as the element geometry are substituted. In the following notation, the approximations on the element level are expressed as $u^e=\sum N_u r_u$ and $w^e=\sum N_w r_w$.

Simple example

We will use OOFEM input deck to demonstrate the concept of setting up the problem of cantilever beam fixed on the left-hand side and loaded by distributed loading on free, right-hand edge.

     y↑ 
      |6              7               8               9                10
      +---------------+---------------+---------------+---------------+  +­­­­­­­­­­↑
      |               |               |               |               |  |↑
      |               |               |               |               |  |↑
      |       1       |       2       |       3       |       4       | 5|↑
      |               |               |               |               |  |↑
      |               |               |               |               |  |↑
      +---------------+---------------+---------------+---------------+  +↑ fy=1.0   --->x
      1               2               3               4                 5

In the following I illustrate the setup of the problem using traditional oofem input deck syntax, which has been extended to allow for definition of Variables, Terms, and Integrals. If you are already familiar with OOFEM input syntax you will conceptually understand, the details and syntax can be found in OOFEM input manual. For presentation purposes, the complete input deck has been broken into parts to allow for intermediate comments:

demo.out
Demo of symbolic mpm problem; bending of clamped cantilever (l=3, h=0.3) loaded at the free end
#
# Note the new input sections for Terms, Variables and Integrals
# this exampkle requires oofem to be compiled with MPM support (USE_MPM=ON)
#  
test nsteps 1 nvariables 2 nterms 2 nintegrals 2 lhsterms 1 1 rhsterms 1 2 nmodules 1
#vtkxml primvars 1 1 tstep_all
errorcheck

Introduce test and unknown vector fields with linear approximation space:

Variable name "u" interpolation "feilin" type 1 quantity 0 size 2 dofs 2 1 2 # displacement 
Variable name "w" interpolation "feilin" type 1 quantity 0 size 2 dofs 2 1 2 # test function

Set up Terms appearing in the weak form

BTSigmaTerm 1 variable "u"  testvariable "w" mmode 6
NTfTerm 2 variable "u" testvariable "w" mmode 6 flux 2 0. 1.

Set up two integrals (one over the volume, second over the boundary where load is applied)

Integral 1 domain 1 set 1 term 1
Integral 2 domain 1 set 2 term 2

The input file continues with traditional records. Note that we are using universal elements (quads q1 and lines l1)

domain HeatTransfer
outputmanager tstep_all dofman_all element_all
ndofman 10 nelem 5 nbc 2 ncrosssect 1 nic 0 nltf 2 nmat 1 nset 4
# Set up nodes
node 1  coords 3 0.            0.           0.
node 2  coords 3 0.75          0.           0.
node 3  coords 3 1.5           0.           0.
node 4  coords 3 2.25          0.           0.
node 5  coords 3 3.0           0.           0.
node 6  coords 3 0.            0.3          0.
node 7  coords 3 0.75          0.3          0.
node 8  coords 3 1.5           0.3          0.
node 9  coords 3 2.25          0.3          0.
node 10 coords 3 3.0           0.3          0.
# Set up universal (quad) elements
q1 1 nodes 4 1 2 7 6  mat 1 crosssect 1
q1 2 nodes 4 2 3 8 7  mat 1 crosssect 1
q1 3 nodes 4 3 4 9 8  mat 1 crosssect 1
q1 4 nodes 4 4 5 10 9 mat 1 crosssect 1
# boundary element 
l1 5 nodes 2 5 10     mat 1 crosssect 1
# Traditional set up of materials, cross sections boundary conditions and sets
simplecs 1 thick 1.0
isole 1 d 1 e 1 n 0.3 talpha 1.
# x-displacement
boundarycondition 1 loadtimefunction 1 set 3 values 1 0   dofs 1 1 
# y-displacement
boundarycondition 2 loadtimefunction 1 set 4 values 1 0   dofs 1 2 
#
#
constantfunction 1 f(t) 1
PiecewiseLinFunction 2 nPoints 4 t 4 -10. 0. 1. 5. f(t) 4 0. 0. 1.0 1.0 
set 1 elements 4 1 2 3 4
# 
set 2 elements 1 5
# x-bc, note that set 3 is defined using element edge
set 3 elementedges 2 1 4
# y-bc, note that set 3 is defined using element edge
#set 4 nodes 3 1 6 11
set 4 elementedges 2 1 4 

Save the above input file into demo.in file.

./oofem -f demo.in

The complete input deck can be found in tests/mpm/mpms03.in file.

Simple example - quadratic interpolation

Let’s switch now to quadratic interpolation. The nice thing here is that it is sufficient to change only two lines in input file to get solved the problem using quadratic interpolation. We just need to locate the records defining test and unknown fields and update the interpolation:

Variable name "u" interpolation "feiquad" type 1 quantity 0 size 2 dofs 2 1 2 # displacement 
Variable name "w" interpolation "feiquad" type 1 quantity 0 size 2 dofs 2 1 2 # test function

All the magic needed to introduce additional nodes on shared edges, setting up integration rules, etc. will happen automatically for you. The complete input deck can be found in tests/mpm/mpms04.in file.

Simple example - results & conclusions

The analytical solution (beam theory, assuming only the bending moment contribution) is
$w_{ex}=FL^3/(3EI) = 0.3\times3^3/(3\times1\times0.3^3/12.)=1200$.

The resulting end deflection (node 10), obtained with linear approximation is $w_{lin}=345.03$. The deflection obtained using quadratic interpolation is $w_q=1178.8$, clearly demonstrating the superior convergence properties of quadratic interpolation over the linear one.

However, the purpose of this post was to illustrate the power of MPM symbolic module and its capabilities. With this I conclude today post on mpm module.

Hope you enjoyed and stay tuned for following updates! You can leave a comment below to give a feedback.

What is MPM? MPM is new multi-physic OOFEM module, developed to make implementation of multi-physics problems more simple.

What are the design ideas behind MPM?

• MPM defines Interpolations, Variables, Terms, Integrals as reusable blocks to create multi-physics formulations
• Variables represent unknown fields (or test fields) in a weak form of the problem. The variable has its interpolation, type (scalar, vector) and physical meaning defined.
• Terms represent an integrand in weak formulation to be evaluated (integrated). Term definition is independent on underlying element geometry and interpolation. It defines two key methods:
  • method to evaluate the term value, typically contributing to RHS of discrete system.
  • method to evaluate the consistent linearization of the term, so if Term is T(u), depending on unknown u, this term evaluates dT/du, which typically contributes to the LHS.
• Interpolations are representing different FE interpolations.
• Integral represents the integral of term in a weak form. It can compute its contributions to the discrete set of equations.

The concept allows for parametrization with different element geometries and interpolations. Also, the components (interpolations, terms) can be reused/shared between different formulations. I will illustrate the concept using oofem python bindings, which allows for fast prototyping.

In the example below, we reuse already defined terms in oofem, but it is possible to define your own terms, interpolations, etc.

As an example, consider the weak form of equilibrium equations:

where

• u,w are variables (fileds), represented by Variable class instances
• $\left[ (\partial w)^T \sigma (\partial u)\right] $ and $\left[ (w)^Tt \right]$ are Terms, parametrized (to be evaluated) by u,w, represented by classes BTSigmaTerm and NTfTerm (derived from parent Term class).

When term is evaluated, the interpolations of the test and unknown fields as well as the element geometry are substituted. In the following notation, the approximations on the element level are expressed as $u^e=\sum N_u r_u$ and $w^e=\sum N_w r_w$. As this in general yields to a nonlinear system of equations, the term on left hand side evaluates

• residual contribution for given element, essentially evaluating itself with all variables known. In our example this corresponds to evaluating $\int_\Omega^e (\partial N_w)^T\sigma(\partial N_u r_u)\ d\Omega^e$
• its linearization, corresponding in our case to $\int_\Omega^e (\partial N_w)^T \frac{\partial \sigma}{\partial \varepsilon} (\partial N_u)\ d\Omega^e$.

Simple example

We will use OOFEM python interface to demonstrate the concept on the problem presented above. First set up simple mesh, consisting of single quad element, defined by four nodes. Plus standard definition of materials, boundary conditions, etc.

The demo plane-stress elasticity problem consist of two elements. One is quad element representing the domain, the second is boundary element (linear segment) representing boundary between nodes 2,3 subjected to distributed loading. Node 1 is fixed in all directions, node 4 is fixed in x direction.

     y↑ 4[0,5]         3[3,4]
      +---------------+  +→
      |               |  |→
      |               |  |→
      |       1       | 2|→
      |               |  |→
      |               |  |→
      +---------------+  +→ fx=1.0   --->x
      1 [0,0]           2[1,2]

# Requires oofempy compiled with __MPM_MODULE ON
import sys
sys.path.extend(['/home/bp/devel/oofem.git/build', '/home/bp/devel/oofem.git/bindings/python'])
import oofempy
import util

 

# Create a new dummy problem (placeholder for our demo) with one domain.
problem = oofempy.dummyProblem(nSteps=1, outFile='test_7.out')
domain = oofempy.domain(1, 1, problem, oofempy.domainType._HeatTransferMode, tstep_all=1, dofman_all=0, element_all=0)
problem.setDomain(1, domain, True)
   
# Define nodes
n1 = oofempy.node(1, domain, coords=(0, 0, 0. ))
n2 = oofempy.node(2, domain, coords=(1., 0.0, 0. ))
n3 = oofempy.node(3, domain, coords=(1., 1., 0. ))
n4 = oofempy.node(4, domain, coords=(0, 1, 0. ))
   
# Defdine elements, note that q1 defines just element geometry.
q1 = oofempy.q1(1, domain, nodes=(1,2,3,4), mat=1, crossSect=1) # quad element #1
l1 = oofempy.l1(2, domain, nodes=(2,3), mat=1, crossSect=1)     # boundary element #2

# Dirichlet Boundary conditions
bc1 = oofempy.boundaryCondition(1, domain, loadTimeFunction=1, dofs=(1,2), values=(0.,0.), set=1)
bc2 = oofempy.boundaryCondition(2, domain, loadTimeFunction=1, dofs=(1,),  values=(0.,),   set=2)
# material and cross section
mat = oofempy.isoLE(1, domain, d=1., e=1., n=0.3, talpha=1.)
cs  = oofempy.simpleCS(1, domain, mat=1, thickness=1.0)
# time functions
ltf1 = oofempy.constantFunction(1, domain, f_t=1.0)
# some sets (groups of nodes and elements) for later use
s1 = oofempy.createSet(1, domain, nodes=(1,))
s2 = oofempy.createSet(2, domain, nodes=(4,))
s3 = oofempy.createSet(3, domain, elements=(1,))
bs1 = oofempy.createSet(4, domain, elements=(2,))
util.setupDomain(domain, nodes=(n1,n2,n3,n4), elems=(q1,l1), css=(cs,), mats=(mat,), bcs=(bc1,bc2), ics=(), ltfs=(ltf1,), sets=(s1,s2,s3,bs1))

Now the interesting part begins:

• Define the $u$ and $w$ fields (variables), with linear interpolation, with physical meaning of Displacement vector of size 2, with two degrees of freedom u,v (2D)
• Create instances of BTSigmaTerm, NTfTerm to be evaluated for $u,w$ in plane stress mode.

interpolation = oofempy.linearinterpolation()
w= u = oofempy.Variable(interpolation, oofempy.VariableQuantity.Displacement, oofempy.VariableType.vector, 2, [1,2], None)
mt = oofempy.BTSigmaTerm(w, u, oofempy.MaterialMode._PlaneStress)
lt = oofempy.NTfTerm(w, u, oofempy.MaterialMode._PlaneStress)
tstep = problem.giveNextStep()

Now define integrals forming our weak form. Integral I1 over $\Omega$, defined by set s3 (containing element 1) and boundary integral I2 over boundary edge 2-3, defined by set bs1.
The integrals need to be initialized (allocates the needed DOFs, sets up the element integration rules, etc.) as well as the entire problem (number the equations).

I1 = oofempy.Integral(domain, s3, mt)
problem.addIntegral(I1)
I1.initialize()

I2 = oofempy.Integral(domain, bs1, lt)
I2.initialize()

problem.postInitialize()
problem.forceEquationNumbering()

OctreeLocalizer: init
Spatial localizer init done

We are now approaching the part where we will use all the concepts:

• Create sparse matrix instance (lhs) to hold stiffness matrix
• The stiffness matrix is assembled by integral I1 instance using its assemble_lhs method, that will integrate the linearization of our term over all elements in domain defined by integral domain.

lhs=oofempy.skyline()
lhs.buildInternalStructure(problem, 1, oofempy.EModelDefaultEquationNumbering());
I1.assemble_lhs(lhs, oofempy.EModelDefaultEquationNumbering(), tstep)
lhs.printYourself()

FloatMatrix with dimensions : 5 5
 4.945e-01  -1.786e-01   5.495e-02  -1.374e-02   1.786e-01  
-1.786e-01   4.945e-01   1.374e-02  -3.022e-01  -2.473e-01  
 5.495e-02   1.374e-02   4.945e-01   1.786e-01  -1.374e-02  
-1.374e-02  -3.022e-01   1.786e-01   4.945e-01   5.495e-02  
 1.786e-01  -2.473e-01  -1.374e-02   5.495e-02   4.945e-01  

Assemble load vector forming right hand side of the problem

rhs = oofempy.FloatArray(5)

I2.assemble_rhs(rhs, oofempy.EModelDefaultEquationNumbering(), tstep)
rhs.printYourself()

FloatArray of size : 5 
 5.000e-01   0.000e+00   5.000e-01   0.000e+00   0.000e+00  

Finally, use suitable linear solver to solve for unknown displacement field.

r = oofempy.FloatArray(5)
linsolv = oofempy.ldltfactorization(domain, problem)
linsolv.solve(lhs, rhs, r)
print ("Displacement vector = ", r)

Displacement vector =  <oofempy.FloatArray: {1, -2.77556e-17, 1, -0.3, -0.3, }>

Hope you enjoyed!

Particularly, the following posts are welcome:

• Feature previews: Share sneak peeks of upcoming features or enhancements. This generates excitement and anticipation among your users.
• New features: Inform the community about the latest features you’ve implemented. Explain how they work, their benefits, and how users can leverage them effectively.
• Present your interesting work: Document and discuss challenges you’ve encountered when solving particular problem. Describe your model and present results as this can be both educational and engaging.
• Present your papers and research findings obtained with the help of OOFEM: Diseminate and share your results with OOFEM community.
• Project-Related Announcements: Keep community informed about project milestones, releases, and other significant updates.

To contribute, clone the oofem.github.io repository. Create new post in _posts directory and make a pull request. Please follow Minimal-mistakes and Jekyll conventions and formatting.

Remember, fostering a culture of knowledge sharing and collaboration will inspire users to actively participate and contribute to the OOFEM project. 🌟📝

Course date: 9-11. September, 2024 Venue: Czech Technical University, Prague, Czech Republic See Courses page for more information and registration