Save internally generated mesh to file

[joesmerdon]

Hi Capytaine users,

This is my first question. I'm new to capytaine, fluid modelling, meshing and programming in general.

I'm studying the interaction between a liquid surface and an array of vertically standing prisms (cylindrical, square, whatever). I'm currently trying to build the array using the tools inside capytaine by sequentially adding prisms to an array.

This gets slooow.. and I need to run multiple simulations on an array. I thought I could save time by dumping the array out into a file so I can load it in for multiple simulations. I'm trying to use the pickle package to do this.

It is not working. It can't find the relevant variable in the global dictionary (though I know it is there), and I think this might be because the variable names in python are just aliases for something that's happening at a lower level, so it's simply not valid to try and extract the mesh this way. But as I said, I'm no programmer and I don't know how it all works.

Can this be done? That is, is there a way to export a mesh generated internally in Capytaine so it can be loaded for future simulations?

Thanks in advance!

Joe

[mancellin]

Hi @joesmerdon,

Are you sure the mesh manipulation is what is slowing you down?
Usually the bottleneck is the simulation itself with its $>N^2$ complexity (where $N$ is the number of faces, or the number of bodies).
Could you give some concrete example of the kind of mesh you have/want?

[joesmerdon]

Hi @mancellin,

Thanks for your reply!

I'm creating the array by making a cylinder and then adding a cylinder to that cylinder in a for loop, so each time I am adding a cylinder to the pre-existing array with the += operator. The documentation says to use the join_bodies command if one is adding more than two bodies together, but I can't figure that out right now, as each cylinder would need its own variable name. So even before I get to running the simulation, I'm adding cylinders one by one to an array, and this is taking a long time.

Hope this illustrates my problem. Just fyi, I am simultaneously investigating ways to generate the array as a single mesh by drawing an svg file and extruding it, which may be easier in the long run, but I am trying to get to the point where I can just batch run simulations and get some initial results.

The simulations do of course take much longer than generating the mesh does -- it's just that an obvious place to optimise is to avoid re-generating the same mesh for every run.

Thanks!

Joe

[mancellin]

I see.
The canonical way to save a mesh is to use the standard file formats for meshes as found in the capytaine.io.mesh_writers. See the example in the code below.
However you will lose the information about the degrees of freedom. I tried pickles in the example code below. It seems to work, but does not seem faster than recreating the body from scratch.

import numpy as np
import capytaine as cpt

## GENERATE ARRAY WITH `join_bodies`
mesh_single_body = cpt.mesh_vertical_cylinder(center=(0, 0, -0.5), length=2.0)
single_body = cpt.FloatingBody(mesh=mesh_single_body, dofs=cpt.rigid_body_dofs(rotation_center=(0, 0, -0.5)), name="body")

x_range = np.linspace(0.0, 100.0, 20)
y_range = np.linspace(0.0, 100.0, 20)

list_of_bodies = []
for x in x_range:
    for y in y_range:
        translated_body = single_body.translated((x, y, 0), name="body_at_({:.1f},{:.1f})".format(x, y))
        list_of_bodies.append(translated_body)

all_bodies = cpt.FloatingBody.join_bodies(*list_of_bodies)

## WRITING THE MESH TO A FILE
mesh_all_bodies = all_bodies.mesh

from capytaine.io.mesh_writers import write_MAR
write_MAR("my_mesh.mar", mesh_all_bodies.vertices, mesh_all_bodies.faces)

mesh_all_bodies = cpt.load_mesh("my_mesh.mar", file_format="mar")

## TESTING PICKLES
import pickle
with open("test.pickle", 'wb') as f:
    pickle.dump(all_bodies, f)

with open("test.pickle", 'rb') as f:
    reloaded = pickle.load(f)

print(reloaded)

[mancellin]

Also I forgot about the (undocumented?) assemble_arbitrary_array

import numpy as np
import capytaine as cpt

mesh_single_body = cpt.mesh_vertical_cylinder(center=(0, 0, -0.5), length=2.0)
single_body = cpt.FloatingBody(mesh=mesh_single_body, dofs=cpt.rigid_body_dofs(rotation_center=(0, 0, -0.5)), name="body")

X = np.random.rand(100)*100.0
Y = np.random.rand(100)*100.0
points = np.array([X, Y]).transpose()

all_bodies = single_body.assemble_arbitrary_array(points)

[joesmerdon]

Hi @mancellin,

Thanks very much for the code snippets (including the demonstration of where I can use a list for join_bodies). They're exactly what I need!

Regards

Joe

[joesmerdon]

Hi @mancellin

Just a note -- doing it your way with join_bodies is indeed fast to the point that this is an unnecessary optimization. But I have been doing it by adding each new array element to the entire existing array, which is why it was so slow.

Thank you so much for your help and for writing functional code. I am learning more in minutes here than I have in days trying to do this.

Regards

Joe

[mancellin]

Glad it helped :)

By the way, if you are working on regular (Cartesian grid) arrays, there is an poorly documented experimental feature in Capytaine to speed up this kind of simulations. (Background: https://doi.org/10.1115/OMAE2018-77924)
If you think it could be worth spending some time applying it to your use-case, send me a email so we can plan a short discussion.