Since my comment, I've been working on it. This approach can be used to compute the warping function by using BEM which converts the PDE into a boundary version.

Although BEM uses less nodes, the FEM's matrix is banded while BEM's matrix is full, which is a down-side.
It's hard to tell if a implementation using BEM would be faster over using FEM, having a visible performance gain to compute warping properties.
But surelly it's fater computing computing polynomial integrals (such area, inertias) by the boundary. For these integrals, BEM is not needed.

I promped myself to make a package to compute the section properties by using BEM, but the lack of tools made it difficult for me to do such a task. In fact I started 3 days ago on compmec-section and I'm working on it. But before I had to create the tool compmec-shape to allow me continue.

If you want, you can use compmec-shape to separate the section analysis from the boolean operation between shapes, like shown in the issue #281. I wonder if it should be a responsability of this package.

Tool compmec-shape

I created the package compmec-shape which allows boolean operations of curved shapes (modeled by bezier curves). As example, I take figure from the issue #281:

from compmec.shape import Primitive, ShapePloter

circle_left = Primitive.circle(radius = 50, ndivangle=16)
circle_right = Primitive.circle(radius = 50, center = (35, 0), ndivangle=16)
circle_or = circle_left | circle_right
circle_and = circle_left & circle_right
circle_xor = circle_or - circle_and

plt = ShapePloter()
plt.plot(circle_xor)
plt.gca().set_aspect("equal")
plt.xlim(-60, 100)
plt.ylim(-60, 60)
plt.show()

This package can compute polynomial integrals over the shape, by converting it into a boundary integral.

from compmec.shape import IntegrateShape

A = IntegrateShape.polynomial(circle_xor, 0, 0)  # x^0 * y^0
Mx = IntegrateShape.polynomial(circle_xor, 1, 0)  # x^1 * y^0
My = IntegrateShape.polynomial(circle_xor, 0, 1)  # x^0 * y^1
Ixx = IntegrateShape.polynomial(circle_xor, 2, 0)  # x^2 * y^0
Ixy = IntegrateShape.polynomial(circle_xor, 1, 1)  # x^1 * y^1
Iyy = IntegrateShape.polynomial(circle_xor, 0, 2)  # x^0 * y^2
print(f"  A = {A}")  # 6855.115688828595
print(f" Mx = {Mx}")  # 119964.52455450044
print(f" My = {My}")  # -3.524291969370097e-12
print(f"Ixx = {Ixx}")  # 14479784.550781248
print(f"Ixy = {Ixy}")  # 2.482920535840094e-10
print(f"Iyy = {Iyy}")  # 5484575.180168655

This package has no mesher (since its objective is only make boolean operations), but the package pygmsh can be used to do create the mesh:

The code to generate this image:

import pygmsh
import numpy as np
from matplotlib import pyplot
from typing import Tuple

def outlines(triangles: Tuple[Tuple[int]]) -> Tuple[Tuple[int]]:
    """
    Given a matrix of shape (n, 3), returns a matrix of shape (m, 2)
    such (n) is the number of triangles, and (m) is the number of lines

    Simple case:
        [(0, 1, 2), (0, 1, 3)] -> [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)]
    """
    npts = len(set(triangles.flatten()))
    lines = set()
    for triangle in triangles:
        a, b, c = sorted(triangle)
        lines.add((a, b))
        lines.add((a, c))
        lines.add((b, c))
    return np.array(sorted(lines), dtype="uint64")

def create_mesh(shape):
    """
    Returns the pair (points, triangles)

    Uses pygmsh to get the coordinates of points and
    the triangles
    
    points is a numpy float array of shape (z, 3)
    triangles is a numpy integer array of shape (t, 3)
    """
    with pygmsh.geo.Geometry() as geom:
        lcar = 2
        all_points = {}
        for jordan in shape.jordans:
            new_segments = []
            for segment in jordan.segments:
                bezier_points= []
                for point in segment.ctrlpoints:
                    if id(point) not in all_points:
                        new_pt = geom.add_point(tuple(point), lcar)
                        all_points[id(point)] = new_pt
                    bezier_points.append(all_points[id(point)])
                new_bezier = geom.add_bezier(bezier_points)
                new_segments.append(new_bezier)
            new_loop = geom.add_curve_loop(new_segments)
            pl = geom.add_plane_surface(new_loop)
        mesh = geom.generate_mesh()
        points = mesh.points
        for cell in mesh.cells:
            if cell.type == "triangle":
                triangles = cell.data
    return points, triangles

points, triangles = create_mesh(circle_xor)
lines = outlines(triangles)
fig = pyplot.figure()
for line in lines:
    xvals, yvals, _ = np.array([points[i] for i in line]).T
    pyplot.plot(xvals, yvals, color="k", linewidth=0.5)
pyplot.gca().set_aspect("equal")
pyplot.show()

@carlos-adir looks like a cool package, I'll be interested to see if you are able to implement warping properties and what the performance will be like! Best of luck!

@robbievanleeuwen
You could take the approach of utilizing the boundary integrals for the area properties and only utilizing the finite element solution for the torsion and warping properties. The boundary integral approach could potentially significantly decrease the computation time for the plastic section modulus assuming you are implementing some form of solver routine to the find the neutral axis location. (my toolbox site utilizes the boundary integrals)

@carlos-adir
Walter Pilkey presents a method for the torsion problem using boundary elements in his book "Analysis and Design of Elastic Beams Computational Methods" the section in the book also points to several papers on the subject as well. If I recall correctly, there is a special condition on one of the boundary elements where the solution will diverge unless the element is sub-divided.

@buddyd16 I definitely agree this approach would be more efficient. At the moment, I'd like to keep sectionproperties as a finite element program rather than mix methods and build the code base/reduce maintainability. At the moment calculating geometric properties is not super computationally intense. Further, the plastic computation is done purely with shapely (geometric, does not use finite elements) and is extremely quick.

I hope to include some benchmarks for sectionproperties in the near future so will be interested to see how the geometric analysis by @carlos-adir compares to a finite element implementation.

@robbievanleeuwen makes total sense to me to keep all the computations using a consistent method. It's likely that any speed gain using a direct integration method with todays computers would likely go unnoticed by end users anyway.

@carlos-adir search for "Field Theory: A two-dimensional case for not using finite or boundary elements" by Pilkey and Liu as well as "Structural shape optimization for the torsion problem using direct integration and B-splines" by Schramm and Pilkey.