A high-level model class

[adtzlr]

An object-oriented approach with a top-level model class could make things for multiple solid-bodies much easier. The key-challange is to find a good balance between pre-defined assumptions and customization. This will mimic a GUI-based approach. The nice thing is that all the methods of solids, fields are directly available in the items of the model.

Here's a prototype for two hex-meshes:

import felupe as fem


class Items:
    def __init__(self):
        self.reset()

    def reset(self):
        self.meshes = []
        self.regions = []
        self.fields = []
        self.solids = []
        self.steps = []


# from femodel import Model (a future extension package felupe-model)
class Model:
    def __init__(self):
        self.items = Items()
        self.reset()

    def reset(self):
        self.items.reset()
        self.mesh = None
        self.region = None
        self.field = None
        self.job = None

    def add_solid(self, mesh, material, incompressible=False):

        self.items.meshes.append(mesh)
        self.update()

        region = fem.RegionHexahedron(self.mesh.meshes[-1])
        field = fem.Field(region, dim=mesh.dim).as_container()
        solid = fem.SolidBody(material, field)

        self.items.regions.append(region)
        self.items.fields.append(field)
        self.items.solids.append(solid)

        return self

    def add_step(self, boundaries, ramp, substeps=5):
        ramp = {
            key: fem.math.linsteps(value, num=substeps) for key, value in ramp.items()
        }
        self.items.steps.append(fem.Step(self.items.solids, ramp, boundaries))
        return self

    def update(self):
        self.mesh = fem.MeshContainer(self.items.meshes, merge=True)
        self.region = fem.RegionHexahedron(self.mesh.stack())
        self.field = fem.Field(self.region, dim=3).as_container()
        [f.link(self.field) for f in self.items.fields]
        return self

    def evaluate(self, **kwargs):
        self.job = fem.Job(self.items.steps)
        self.job.evaluate(x0=self.field, **kwargs)


mesh = fem.Cube(n=3)
material = fem.NeoHooke(mu=1, bulk=2)

model = Model()
model.add_solid(mesh, material)
model.add_solid(mesh.translate(1, axis=0), material)

boundaries, loadcase = fem.dof.uniaxial(model.field, clamped=True)

model.add_step(boundaries, ramp={boundaries["move"]: [0, 1]}, substeps=5)
model.evaluate()

ax = model.field.imshow("Displacement")