# Manufacturing complex lattices

In this post, we take a look at some of the challenges you face as lattice complexity increases.

A recurring request from our customers is about manufacturing large lattice structures - *really* large lattice structures. Smaller lattices with only a few hundred rods can easily be handled in traditional CAD software, and with more specialised software our customers routinely handle lattices with some hundred thousand rods. But when lattices grow above a million rods, challenges arise. While one million rods may sound like a lot, it is actually easily within reach of most metal AM machines. With a unit cell size of 1 mm, a 10-by-10-by-10 cm cube is already containing one million unit cells, each containing for example 4 rods; and with the ever growing build envelopes of modern metal AM machines, the desire to manufacture large lattices is not disappearing.

The approach taken by most specialised software is to exploit the fact that each individual layer only contains a fraction of the total geometry. We can therefore perform the geometric calculations on a much smaller subset of the information. If the lattice structure is regular, we can even exploit this and clone a slice of a unit cell instead of cloning the unit cell and slicing the resulting large structure. Furthermore, the independence of the layers make the computation trivial to parallelise and distribute over the many cores of modern computers. For specialised software, slicing is no longer the bottleneck!

The real challenges arise when you transfer the data to the machine and actually start to manufacture the part. At this point the machine needs to calculate the specific laser paths (the beam compensated contours and hatches). For most parts this is not an issue: since the calculations only involve a single layer, the geometric complexity is manageable. As the lattices grow, however, each layer becomes increasingly complex. For large enough lattices, this is bound to cause trouble!

To complicate the problem, each machine brand:

- has its own hatch pattern and associated parameters.
- has its own software to calculate this hatch pattern.
- has its own proprietary file format to store the hatch patterns.

As a result, users are locked to their brand software, which may or may not be up to the task. Currently, specialised software (like the ones for slicing) doesn't exist for hatching, since most brands are keeping the specifications to themselves. Not surprisingly, machine brands have primarily focused on developing their hardware, and the software have been somewhat neglected (though there are signs that this is improving at the moment!)

The current situation is complex, since each machine brand must be treated differently. A few experiences:

- Some machines will calculate the hatches for each layer
*while*the machine is printing. Since this calculation can be time consuming, we have experienced significant delays in between layers. The worst case so far: 30 minutes waiting time between*each*layer! As if AM was not slow enough already... - Some machines pre-calculate the hatches just before the build job starts and keep the result in memory. While the time consuming aspect is not so critical here, this implies serious requirements with respect to available memory. This is made worse by the fact, that the hatch may depend also on the previous and the next layer. The worst case so far: A computer equipped with 256 GB RAM running out of memory before the computation finished.
- Some machines allow us to pre-calculate the hatches and save them to a file. The machine will read either the whole file or, even better, just the next layer and print it. Hooray! This is great if the specific software is fast. Unfortunately, this is often not the case - see above! If we know the file specification, we can pre-calculate hatches in our own software - but knowing the file specification requires a collaborating machine brand.

In Adimant, we have ongoing dialogues with most of the major brands, but the response varies from the very forthcoming to complete disregard. To work around the software limitations, we have a range of choices spanning from the simplest tricks to complicated hacks, from file splitting procedures to reverse engineered data formats. Despite the obstacles, we so far managed to get all our lattices printed — one way or another.

Written by Klaus Loft Højbjerre ·