mlhp 0.2.0__tar.gz → 0.2.2__tar.gz

{mlhp-0.2.0 → mlhp-0.2.2}/.gitlab-ci.yml

@@ -427,11 +427,12 @@ wheels_macos_xcode:
 
   variables:
     HOMEBREW_NO_AUTO_UPDATE: 1
+    MACOSX_DEPLOYMENT_TARGET: "15.0"
 
   before_script:
     - python3 -m pip install cibuildwheel
-    - curl -O https://mac.r-project.org/openmp/openmp-15.0.7-darwin20-Release.tar.gz
-    - sudo tar fvxz openmp-15.0.7-darwin20-Release.tar.gz -C /
+    - brew install cmake libomp
+    - export OpenMP_ROOT=$(brew --prefix libomp)
 
   script:
     - export CIBW_ENVIRONMENT="SKBUILD_CMAKE_DEFINE=\"MLHP_ALL_OPTIMIZATIONS=OFF;MLHP_COMMIT_ID=$(git rev-parse HEAD)\" CXXFLAGS=\"-Ofast\""

{mlhp-0.2.0 → mlhp-0.2.2}/CMakeLists.txt

@@ -154,7 +154,8 @@ CreateExamplePythonDriver( elastic_fcm_csg "Compute with a csg geometry." )
 CreateExamplePythonDriver( elastic_fcm_stl "Compute with an stl geometry." )
 CreateExamplePythonDriver( elastic_gmsh "Compute with unstructured grid from gmsh file." )
 CreateExamplePythonDriver( elastic_gyroid "Gyroid TPMS implicit geometry." )
-CreateExamplePythonDriver( elastic_wave_IMEX_SEM "Immsersed spectral elements with implicit Newmark on cut elements." )
+CreateExamplePythonDriver( elastic_mapped_thin_solid "Curved thin-walled geometry from a mapped grid." )
+CreateExamplePythonDriver( elastic_wave_IMEX_SEM "Immersed spectral elements with implicit Newmark on cut elements." )
 CreateExamplePythonDriver( hyperelastic_gyroid "Large deformation Gyroid TPMS implicit geometry." )
 CreateExamplePythonDriver( interactive_eigenmodes "Interactive eigenvalue analysis using a line segment boundary." INTERACTIVE )
 CreateExamplePythonDriver( j2_plasticity_compiled "Immersed J2 plasticity using a cffi-compiled material." )
@@ -162,6 +163,7 @@ CreateExamplePythonDriver( planestress_fcm_lshaped_adaptive "Immersed l-shaped d
 CreateExamplePythonDriver( planestress_fcm_plate_with_hole "Plate with a hole using FCM." )
 CreateExamplePythonDriver( poisson_compiled "Define integrand with numba or cffi." )
 CreateExamplePythonDriver( scalar_wave_SEM "Spectral elements for scalar wave equation." )
+CreateExamplePythonDriver( thermoelastic_spinodoid_fcm "One-way thermomechanical spinodoid with FCM and Nitsche." )
 
 # Copy example input geometry and the example runner next to the example drivers
 # in bin so argument-less runs find them. Example builds only; the geometry is

{mlhp-0.2.0 → mlhp-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mlhp
-Version: 0.2.0
+Version: 0.2.2
 Summary: An efficient finite element library for boundary-conforming and embedded domain methods.
 Author: Philipp Kopp
 License: MIT License

{mlhp-0.2.0 → mlhp-0.2.2}/examples/elastic_fcm_csg.py

@@ -1,10 +1,10 @@
 """Linear elasticity with FCM on a constructive solid geometry (CSG)
-domain (sphere-cube intersection with cylinders subtracted). Showcases
-core features of embedded domain methods:
+domain (a sphere with cylinders subtracted, cut to a box by the mesh).
+Showcases core features of embedded domain methods:
 - Filtering of elements outside the domain
-- Displacement BC on a reconstructed triangulation using integral penalty
-- Traction BC on a reconstructed triangulation
-- Postprocessing on a domain boundary triangulation"""
+- Displacement BC on a planar slice through the mesh using integral penalty
+- Traction BC on a planar slice through the mesh
+- Postprocessing on a domain boundary recovery"""
 
 import mlhp
 
@@ -15,17 +15,13 @@ print("1. Setting up mesh and basis", flush=True)
 origin, max = [-0.78] * D, [0.78] * D
 
 sphere = mlhp.implicitSphere([0.0, 0.0, 0.0], 1.0)
-cube = mlhp.implicitCube(origin, max)
-intersection = mlhp.implicitIntersection([sphere, cube])
-
 circle = mlhp.implicitSphere([0, 0], 0.4)
-
 cylinder1 = mlhp.extrude(circle, -1.0, 1.0, 0)
 cylinder2 = mlhp.extrude(circle, -1.0, 1.0, 1)
 cylinder3 = mlhp.extrude(circle, -1.0, 1.0, 2)
 
 cylinders = mlhp.implicitUnion([cylinder1, cylinder2, cylinder3])
-domain = mlhp.implicitSubtraction([intersection, cylinders])
+domain = mlhp.implicitSubtraction([sphere, cylinders])
 
 scaling = 2 * 2.5 / 0.78
 
@@ -35,31 +31,23 @@ domain = mlhp.implicitTransformation(domain, mlhp.scaling([scaling] * D))
 youngsModulus = 200 * 1e9
 poissonsRatio = 0.3
 
-polynomialDegree = 1
+degree = 1
 nelements = [50] * D
-alphaFCM = 1e-8
-penalty = 1e5 * youngsModulus
+alpha = 1e-8
+penalty = 200 * youngsModulus
 
-# ##################### FIX ####################
-origin = [scaling * o - 1e-10 for o in origin]
-max = [scaling * m + 1e-10 for m in max]
+origin = [scaling * o for o in origin]
+max = [scaling * m for m in max]
 
 lengths = [m - o for o, m in zip(origin, max)]
 
 grid = mlhp.makeGrid(nelements, lengths, origin)
-print(grid)
-
-grid = mlhp.makeRefinedGrid(mlhp.makeFilteredGrid(grid, domain=domain, nseedpoints=polynomialDegree + 2))
-basis = mlhp.makeHpTrunkSpace(grid, degree=polynomialDegree, nfields=D)
+grid = mlhp.makeRefinedGrid(mlhp.makeFilteredGrid(grid, domain=domain, nseedpoints=degree + 2))
+basis = mlhp.makeHpTrunkSpace(grid, degree=degree, nfields=D)
 
 print(grid)
 print(basis)
 
-resolution = [polynomialDegree + 3] * D
-triangulation, celldata = mlhp.recoverDomainBoundary(grid, domain, resolution)
-
-print(basis)
-
 print("2. Allocating linear system", flush=True)
 
 matrix = mlhp.allocateSparseMatrix(basis)
@@ -67,14 +55,15 @@ vector = mlhp.allocateRhsVector(matrix)
 
 print("3. Computing weak boundary integrals", flush=True)
 
-def createBoundaryQuadrature(func):
-    filteredTriangulation, filteredCelldata = triangulation.filter(mlhp.implicitFunction(D, func), celldata)
-    quadrature = mlhp.simplexQuadrature(filteredTriangulation, filteredCelldata)
+def createBoundaryQuadrature(coordinate):
+    face, facedata = mlhp.createPlanarSlice(grid, 0, coordinate, domain,
+                                            cutDepth=degree)
+    quadrature = mlhp.simplexQuadrature(face, facedata)
 
-    return filteredTriangulation, filteredCelldata, quadrature
+    return face, facedata, quadrature
 
-intersected0, celldata0, quadrature0 = createBoundaryQuadrature(f"x < {origin[0] + 1e-3}")
-intersected1, celldata1, quadrature1 = createBoundaryQuadrature(f"x > {origin[0] + lengths[0] - 1e-3}")
+intersected0, celldata0, quadrature0 = createBoundaryQuadrature(origin[0])
+intersected1, celldata1, quadrature1 = createBoundaryQuadrature(origin[0] + lengths[0])
 
 integrand0 = mlhp.l2BoundaryIntegrand(mlhp.vectorField(D, [penalty] * D),
                                       mlhp.vectorField(D, [0.0] * D))
@@ -95,10 +84,10 @@ constitutive = mlhp.isotropicElasticMaterial(E, nu)
 integrand = mlhp.staticDomainIntegrand(kinematics, constitutive, rhs)
 
 quadrature = mlhp.spaceTreeQuadrature(domain,
-    depth=polynomialDegree + 1, epsilon=alphaFCM)
+    depth=degree + 1, epsilon=alpha)
 
 #quadrature = mlhp.momentFittingQuadrature(domain,
-#    depth=polynomialDegree + 3, epsilon=alphaFCM)
+#    depth=degree + 1, epsilon=alpha)
 
 mlhp.integrateOnDomain(basis, integrand, [matrix, vector], quadrature=quadrature)
 
@@ -125,7 +114,7 @@ processors = [mlhp.solutionProcessor(D, dofs, "Displacement"),
               mlhp.vonMisesProcessor(gradient, kinematics, constitutive, "VonMises2"),
               mlhp.strainEnergyProcessor(gradient, kinematics, constitutive)]
 
-surfmesh = mlhp.localSimplexCellMesh(triangulation, celldata)
+surfmesh = mlhp.boundaryCellMesh(domain, [degree + 2] * D)
 
 output0 = mlhp.PVtuOutput(filename="outputs/linear_elasticity_fcm_csg_boundary")
 output1 = mlhp.PVtuOutput(filename="outputs/linear_elasticity_fcm_csg_fcmmesh")
@@ -144,5 +133,6 @@ surfoutput1 = mlhp.VtuOutput(filename="outputs/linear_elasticity_fcm_csg_boundar
 mlhp.basisOutput(basis, surfmesh0, surfoutput0, processors)
 mlhp.basisOutput(basis, surfmesh1, surfoutput1, processors)
 
-# Backwards consistency check
-assert(abs(sum([mlhp.norm(diff) for diff in gradient]) - 1.57227628e-04) < 1e-12)
+# Guards the result against unintended change; fails by design if example is modified.
+gradientNorm = sum([mlhp.norm(diff) for diff in gradient])
+assert abs(gradientNorm - 1.665646231e-04) < 1e-10, gradientNorm

{mlhp-0.2.0 → mlhp-0.2.2}/examples/elastic_fcm_stl.py

@@ -57,7 +57,7 @@ vector = mlhp.allocateRhsVector(matrix)
 print("2. Computing weak boundary integrals", flush=True)
 
 def createBoundaryQuadrature(func):
-    filtered = triangulation.filter(mlhp.implicitFunction(D, func))
+    filtered = mlhp.filterSimplexMesh(triangulation, mlhp.implicitFunction(D, func))
     intersected, celldata = mlhp.intersectWithMesh(filtered, grid)
     quadrature = mlhp.simplexQuadrature(intersected, celldata)
 
@@ -132,6 +132,5 @@ surfwriter1 = mlhp.VtuOutput(filename="outputs/linear_elasticity_fcm_stl_boundar
 mlhp.meshOutput(grid, surfmesh0, surfwriter0, [])
 mlhp.meshOutput(grid, surfmesh1, surfwriter1, [])
 
-# Guards the result against unintended change; if you modify the example it
-# fails by design - comment it out, or update the value when developing mlhp.
-assert abs(mlhp.norm(dofs) - 1.3324004e-05) < 1e-9, mlhp.norm(dofs)
+# Guards the result against unintended change; fails by design if example is modified.
+assert abs(mlhp.norm(dofs) - 1.3324004e-05) < 1e-8, mlhp.norm(dofs)

{mlhp-0.2.0 → mlhp-0.2.2}/examples/elastic_gyroid.py

@@ -102,7 +102,7 @@ surfoutput = mlhp.PVtuOutput(filename="outputs/gyroid_surf")
 mlhp.basisOutput(basis, gridmesh, gridoutput, processors)
 mlhp.basisOutput(basis, surfmesh, surfoutput, processors)
 
-# Check consistency with previous versions
+# Guards the result against unintended change; fails by design if example is modified.
 assert(abs(mlhp.norm(allDofs) - 0.05364596974082) < 1e-10)
 
 # # Alternatively: use numba to pass compiled implicit function

mlhp-0.2.2/examples/elastic_mapped_thin_solid.py

@@ -0,0 +1,159 @@
+"""Multi-level hp-refinement on a curved geometry created by a mapped, filtered
+mesh."""
+
+# Recreates example 4.4 of doi:10.1016/j.cma.2016.07.007, the three-dimensional
+# Girkmann problem given in doi:10.1016/j.cma.2004.07.042.
+
+import math
+
+import mlhp
+
+# Geometry, material and load of Fig. 12 in doi:10.1016/j.cma.2004.07.042
+alpha = math.radians(30.0)   # Elevation of the shell edge above the xy-plane
+beta = math.radians(10.0)    # Opening at the top of the shell
+R1 = 10.0                    # Mid-surface radius of the shell
+t1 = 0.1                     # Shell thickness
+t2, L2 = 0.4, 0.4            # Stiffener width and height
+
+E, nu = 6.825e10, 0.3
+density, gravity = 500.0, 10.0
+pressure = 1e5
+
+grading = 2.0
+nmeridional, nazimuthal = 4, 2
+
+degree = 4
+nrefinements = 3
+
+print("1. Setting up geometry mapping", flush=True)
+
+# Index space: x from 0 to 3 radially, with x in [1, 2] the shell thickness and
+# the two remaining columns the rest of the stiffener. y from 0 to 1 is the
+# azimuthal quarter, z from 0 to 1 the stiffener and z from 1 to 2 the shell.
+# Splitting the stiffener into three columns makes the junction conforming.
+ri, ro = R1 - t1 / 2, R1 + t1 / 2
+zc = R1 * math.sin(alpha)                    # Junction plane = top of stiffener
+R2 = R1 * math.cos(alpha)
+rhoi = math.sqrt(ri**2 - zc**2)              # Shell footprint on the stiffener
+rhoo = math.sqrt(ro**2 - zc**2)
+rho0, rho1 = R2 - t2 / 2, R2 + t2 / 2        # Stiffener radii
+
+r = f"({ri} + (x - 1.0)*{t1})"
+theta = f"(acos({zc}/{r})*(2.0 - z) + {beta}*(z - 1.0))"
+phi = f"({0.5 * math.pi}*y)"
+
+# Above the stiffener columns there are no cells, so the stiffener branch is
+# continued into that part of index space. Switching branches at z = 1 instead
+# would make the central differences straddle both branches on the free
+# stiffener top faces, leaving only the glued faces of the shell discontinuous.
+distance = "((1.0 - x) if x < 1.0 else (0.0 if x < 2.0 else (x - 2.0)))"
+isShell = f"z - 1.0 > {distance}"
+
+radius = (f"(({r}*sin{theta}) if {isShell} else "
+          f"(({rho0} + x*{rhoi - rho0}) if x < 1.0 else "
+          f"((({r})**2 - {zc**2})**0.5 if x < 2.0 else "
+          f"({rhoo} + (x - 2.0)*{rho1 - rhoo}))))")
+
+height = f"(({r}*cos{theta}) if {isShell} else {zc} - (1.0 - z)*{L2})"
+
+mapping = mlhp.vectorField(3, f"[{radius}*cos{phi}, {radius}*sin{phi}, {height}]")
+
+# Meridional elements grow away from the junction, so that the shell element at
+# the stiffener is of the size of the stiffener itself
+sizes = [grading**i for i in range(nmeridional)]
+meridional = [1.0]
+
+for size in sizes:
+    meridional.append(meridional[-1] + size / sum(sizes))
+
+ticks = [[0.0, 1.0, 2.0, 3.0],
+         [i / nazimuthal for i in range(nazimuthal + 1)],
+         [0.0] + meridional]
+
+print("2. Setting up mesh and basis", flush=True)
+
+grid = mlhp.makeGrid(ticks)
+
+# Remove the stiffener columns above the junction to obtain the T-shaped section
+centers = [grid.map(icell, [0.0] * 3) for icell in range(grid.ncells())]
+mask = [not (c[2] > 1.0 and (c[0] < 1.0 or c[0] > 2.0)) for c in centers]
+
+mapped = mlhp.makeMappedGrid(mlhp.makeFilteredGrid(grid, mask=mask), mapping)
+mesh = mlhp.makeRefinedGrid(mapped)
+
+# Refine towards the re-entrant corner edge at the inner shell surface
+corner = mlhp.implicitFunction(
+    3, f"(sqrt(x**2 + y**2) - {rhoi})**2 + (z - {zc})**2 < {(L2 / 8)**2}")
+
+mesh.refine(mlhp.refineTowardsBoundary(corner, nrefinements))
+
+basis = mlhp.makeHpTrunkSpace(mesh, degree=degree, nfields=3)
+
+print(mesh)
+print(basis)
+
+print("3. Computing boundary conditions", flush=True)
+
+# Symmetry on the xz- and yz-planes, vertical support at the stiffener bottom
+zero = mlhp.scalarField(3, 0.0)
+
+dirichlet = mlhp.combineDirichletDofs([
+    mlhp.integrateDirichletDofs(zero, basis, [0], ifield=0),
+    mlhp.integrateDirichletDofs(zero, basis, [2], ifield=1),
+    mlhp.integrateDirichletDofs(zero, basis, [4], ifield=2)])
+
+print("4. Assembling linear system", flush=True)
+
+kinematics = mlhp.smallStrainKinematics(3)
+constitutive = mlhp.isotropicElasticMaterial(mlhp.scalarField(3, E), mlhp.scalarField(3, nu))
+weight = mlhp.vectorField(3, [0.0, 0.0, -density * gravity])
+
+domainIntegrand = mlhp.staticDomainIntegrand(kinematics, constitutive, weight)
+surfaceIntegrand = mlhp.normalNeumannIntegrand(mlhp.scalarField(3, -pressure))
+
+# The outer surface is curved and thus not selectable by bounding box. In index
+# space it is the x-max face of every cell that has no neighbour there.
+outside = mesh.boundariesByFaceIndex([1])[0]
+faceQuadrature = mlhp.quadratureOnMeshFaces(mesh, cellFaces=outside)
+
+matrix = mlhp.allocateSparseMatrix(basis, dirichlet[0])
+vector = mlhp.allocateRhsVector(matrix)
+
+mlhp.integrateOnDomain(basis, domainIntegrand, [matrix, vector], dirichletDofs=dirichlet)
+mlhp.integrateOnSurface(basis, surfaceIntegrand, [vector], faceQuadrature, dirichletDofs=dirichlet)
+
+print("5. Solving linear system", flush=True)
+
+interiorDofs, norms = mlhp.cg(matrix, vector, M=mlhp.diagonalPreconditioner(matrix),
+                              maxiter=10000, residualNorms=True)
+dofs = mlhp.inflateDofs(interiorDofs, dirichlet)
+
+print(f"    {len(norms) - 1} iterations, residual reduction {norms[-1] / norms[0]:.2e}")
+
+print("6. Postprocessing solution", flush=True)
+
+processors = [mlhp.solutionProcessor(3, dofs, "Displacement"),
+              mlhp.vonMisesProcessor(dofs, kinematics, constitutive)]
+
+postmesh = mlhp.gridCellMesh([1 if degree == 1 else degree + 3] * 3)
+output = mlhp.PVtuOutput(filename="outputs/mapped_thin_solid")
+
+mlhp.basisOutput(basis, postmesh, output, processors)
+
+# Volume of the quarter model, integrating the mapped geometry
+volume = mlhp.ScalarDouble(0.0)
+
+mlhp.integrateOnDomain(basis, mlhp.functionIntegrand(mlhp.scalarField(3, 1.0)), [volume])
+
+expected = (math.pi / 2 * (math.cos(beta) * (ro**3 - ri**3) / 3 - zc * (ro**2 - ri**2) / 2)
+            + math.pi / 4 * (rho1**2 - rho0**2) * L2)
+
+print(f"    volume : {volume.get()} (analytical: {expected})")
+print(f"    norm   : {mlhp.norm(dofs)}")
+
+# Guards the result against unintended change; if you modify the example it
+# fails by design - comment it out, or update the value when developing mlhp.
+# The volume is not exact because the Jacobian of the mapping is approximated
+# by central differences and detJ is not polynomial.
+assert abs(volume.get() / expected - 1.0) < 1e-8, volume.get()
+assert abs(mlhp.norm(dofs) - 0.0104088153393) < 1e-8, mlhp.norm(dofs)

{mlhp-0.2.0 → mlhp-0.2.2}/examples/elastic_wave_IMEX_SEM.py

@@ -88,7 +88,9 @@ def extractBoundaryFace(boundary, height):
     faceBounds0 = [-1e50] * (D - 1) + [height - 1e-4 * lengths[-1]]
     faceBounds1 = [+1e50] * (D - 1) + [height + 1e-4 * lengths[-1]]
     faceFilter = mlhp.implicitTransformation(mlhp.implicitCube(faceBounds0, faceBounds1), rotation)
-    return boundary[0].filter(faceFilter, celldata=boundary[1])
+    # Clipped, not filtered: the recovered cap is rimmed by inclined triangles that reach
+    # into the slab, which filterSimplexMesh would drop entirely
+    return mlhp.clipSimplexMesh(boundary[0], faceFilter, celldata=boundary[1])
 
 boundary = mlhp.recoverDomainBoundary(grid, domain, [p + 2] * D)
 
@@ -247,7 +249,8 @@ if D == 2:
         for i, dofs in enumerate(results):
             print(f"\rEvaluating result {i + 1} / {len(results)}", flush=True, end='')
             output = postprocess(dofs, mlhp.DataAccumulator())
-            triangulation, (u, vonmises) = output.triangulation(), output.data()
+            triangulation = output.triangulation()
+            u, vonmises = output.field("Displacement"), output.field("VonMisesStress")
             triangulation.x += warp_scaling * np.reshape(u, (-1, D)).T[0]
             triangulation.y += warp_scaling * np.reshape(u, (-1, D)).T[1]
 
@@ -284,5 +287,5 @@ if D == 3:
     for i, u in enumerate(results):
         postprocess(u, mlhp.PVtuOutput(filename=f"outputs/elastic_wave_{i}"))
 
-# Check consistency with previous result
-#assert(abs(mlhp.norm(dofs1) - 5.6633689e-08) < 1e-14)
+# Guards the result against unintended change; fails by design if example is modified.
+assert abs(mlhp.norm(dofs1) - 1.6872021802e-2) < 1e-8, mlhp.norm(dofs1)

{mlhp-0.2.0 → mlhp-0.2.2}/examples/fichera_corner.cpp

@@ -95,6 +95,7 @@ int main( )
     std::cout << "Number of internal dofs : " << interiorSolution.size( ) << std::endl;
     std::cout << "Energy error || u - u^h || / || u || * 100% : " << percent << std::endl;
 
+    // Guards the result against unintended change; fails by design if example is modified.
     MLHP_CHECK( basis->ndof( ) == 12369, "First backward consistency check failed." );
     MLHP_CHECK( std::abs( percent - 9.995783899e-03 ) < 1e-9, "Second backward consistency check failed." );
 }

{mlhp-0.2.0 → mlhp-0.2.2}/examples/hyperelastic_gyroid.py

@@ -52,10 +52,10 @@ dofs = mlhp.DoubleVector(basis.ndof(), 0.0)
 # already scales with alpha.
 kinematics = mlhp.greenLagrangeStrain(D)
 material = mlhp.neoHookeanMaterial(mlhp.scalarField(D, E), mlhp.scalarField(D, nu))
-real = mlhp.staticDomainIntegrand(kinematics, material, dofs)
+real = mlhp.staticDomainIntegrand(kinematics, material, dofs=dofs)
 
 elastic = mlhp.isotropicElasticMaterial(mlhp.scalarField(D, E), mlhp.scalarField(D, nu))
-fictitious = mlhp.staticDomainIntegrand(mlhp.smallStrainKinematics(D), elastic, dofs)
+fictitious = mlhp.staticDomainIntegrand(mlhp.smallStrainKinematics(D), elastic, dofs=dofs)
 
 integrand = mlhp.selectIntegrand(domain, real, default=fictitious)
 
@@ -124,7 +124,7 @@ for istep in range(nsteps):
 
     print(flush=True)
 
-# Backwards consistency check
+# Guards the result against unintended change; fails by design if example is modified.
 assert abs(mlhp.norm(dofs) - 22.663127256849243) < 1e-8, mlhp.norm(dofs)
 
 print("Done.", flush=True)

{mlhp-0.2.0 → mlhp-0.2.2}/examples/interactive_eigenmodes.py

@@ -83,7 +83,8 @@ def compute(vertices):
     # Plot result
     plt.cla()
     plt.plot(*outline, '--', color='gray')
-    plt.tricontourf(result.triangulation(mpl=True), result.data()[0], levels=20, cmap='turbo')
+    plt.tricontourf(result.triangulation(mpl=True), result.field("VonMisesStress"),
+                    levels=20, cmap='turbo')
     refinedGrid.plot(show=False)
     plt.title("Von Mises stress in first nonzero eigenmode.")
     plt.xlabel("x")

{mlhp-0.2.0 → mlhp-0.2.2}/examples/j2_plasticity_compiled.py

@@ -28,6 +28,12 @@ nsteps = nelastic + nplastic
 
 print("Compiling...", flush=True)
 
+# The C-extensions were written against this mlhp C-interface ABI version.
+# Since we pass the target ABI version, mlhp can detect when its ABI is in-
+# compatible and will raise an error. When this happens, adjust function
+# signatures based on docstrings/Python bindings and increment abi_version.
+cabi_version = 1
+
 # Material parameters are passed as a data vector registered with the
 # constitutive equation and history update below, so the C code is a plain
 # string and the parameters can be changed without recompiling.
@@ -142,10 +148,10 @@ ffibuilder.set_source("_j2_cffi", """
     // Material callback: strain is the strain increment (incremental=True),
     // userFields[0] is the history field, outputs stress / tangent /
     // energyDensity are null if not requested.
-    static void material(double* stress, double* tangent, double* energyDensity,
-                         double* gradient, double* strain, double* xyz, double* rst,
-                         double** userFields, double** userData, double* tmp,
-                         int64_t* sizes, int64_t* userFieldSizes, int64_t ielement)
+    static int64_t material(double* stress, double* tangent, double* energyDensity,
+                            double* gradient, double* strain, double* xyz, double* rst,
+                            double** userFields, double** userData, double* tmp,
+                            int64_t* sizes, int64_t* userFieldSizes, int64_t ielement)
     {
         double stressLocal[6], tangentLocal[36], history1[13];
 
@@ -166,14 +172,16 @@ ffibuilder.set_source("_j2_cffi", """
 
             energyDensity[0] = ((1.0 + nu) * inner - nu * trace * trace) / (2.0 * E);
         }
+
+        return 0;
     }
 
     // History update callback: commits the return mapping result once per
     // converged load step. Receives total strains of both states.
-    static void update(double* history, double** gradients, double** strains,
-                       double* xyz, double* rst, double** userFields, double** userData,
-                       double* tmp, int64_t* sizes, int64_t* userFieldSizes,
-                       int64_t ielement)
+    static int64_t update(double* history, double** gradients, double** strains,
+                          double* xyz, double* rst, double** userFields, double** userData,
+                          double* tmp, int64_t* sizes, int64_t* userFieldSizes,
+                          int64_t ielement)
     {
         double dstrain[6], stress[6], tangent[36], history1[13];
 
@@ -185,6 +193,8 @@ ffibuilder.set_source("_j2_cffi", """
         j2(userData[0], history, dstrain, stress, tangent, history1);
 
         memcpy(history, history1, 13 * sizeof(double));
+
+        return 0;
     }
 
     const unsigned long long material_address = (unsigned long long)&material;
@@ -262,7 +272,7 @@ for istep in range(nsteps):
 
     material = mlhp.constitutiveEquation(
         D, lib.material_address, fields=[history], symmetric=True,
-        incremental=True, data=[params], abi=1)
+        incremental=True, data=[params], abi=cabi_version)
 
     dofs1 = dofs0.copy()
     norm0 = 1.0
@@ -279,8 +289,8 @@ for istep in range(nsteps):
         # keeps the solve definite. It acts on the total dofs to prevent
         # fictitious dof drift.
         increment = mlhp.add(dofs1, dofs0, -1.0)
-        plastic = mlhp.staticDomainIntegrand(kinematics, material, increment)
-        fictitious = mlhp.staticDomainIntegrand(kinematics, elastic, dofs1)
+        plastic = mlhp.staticDomainIntegrand(kinematics, material, dofs=increment)
+        fictitious = mlhp.staticDomainIntegrand(kinematics, elastic, dofs=dofs1)
         integrand = mlhp.selectIntegrand(domain, plastic, default=fictitious)
 
         mlhp.integrateOnDomain(
@@ -306,10 +316,10 @@ for istep in range(nsteps):
     # Create return mapping update and project it onto local polynomials
     updated = mlhp.meshFunctionStrainUpdate(
         history, basis, basis, dofs0, dofs1, lib.update_address,
-        kinematics=kinematics, data=[params], abi=1)
-
-    history = mlhp.localL2Projection(updated, mesh, degree, quadrature=quadrature)
+        kinematics=kinematics, data=[params], abi=cabi_version)
 
+    history = mlhp.localL2Projection(mesh, updated, degree, quadrature=quadrature)
+    
     # Write fields at the converged state. The material evaluates stress from
     # the history at the beginning of the step plus the converged increment.
     increment = mlhp.add(dofs1, dofs0, -1.0)
@@ -320,8 +330,25 @@ for istep in range(nsteps):
         mlhp.stressProcessor(increment, kinematics, material),
         mlhp.vonMisesProcessor(increment, kinematics, material),
         mlhp.strainEnergyProcessor(increment, kinematics, material),
-        mlhp.functionProcessor(history, "ProjectedHistory")]
+        mlhp.functionProcessor(history, "History")]
+
+    # Showcase the global L2 projection here, although it's not required (since we
+    # are using local L2 to interpolate history variables). One could use global L2
+    # for smooth postprocessing like we do here or even use it for the analysis.
+    zeroDofs = mlhp.DoubleVector(dofs1.size, 0.0)
+    historyBasis = mlhp.makeHpTrunkSpace(basis.mesh(), degree=1, nfields=1)
+    historyGlobal = mlhp.globalL2Projection(historyBasis, updated, quadrature=quadrature)
+
+    materialGlobal = mlhp.constitutiveEquation(
+        D, lib.material_address, fields=[historyGlobal], 
+        symmetric=True, incremental=True, data=[params], abi=cabi_version)
+
+    processors += [
+        mlhp.stressProcessor(zeroDofs, kinematics, materialGlobal, "StressGlobalL2"),
+        mlhp.vonMisesProcessor(zeroDofs, kinematics, materialGlobal, "VonMisesStressGlobalL2"),
+        mlhp.functionProcessor(historyGlobal, "HistoryGlobalL2")]
 
+    # Write output files
     surfmesh = mlhp.boundaryCellMesh(domain, [degree + 2] * D)
     output = mlhp.PVtuOutput(filename=f"outputs/j2_plasticity_compiled_{istep + 1}")
 
@@ -331,7 +358,7 @@ for istep in range(nsteps):
     dofs0 = dofs1
     
 
-# Backwards consistency check
+# Guards the result against unintended change; fails by design if example is modified.
 assert abs(mlhp.norm(dofs0) - 4.5844435603322350e-03) < 1e-8, mlhp.norm(dofs0)
 
 print("Done.")